rosenpass: Remove dead MockBroker code

Fixes #372
2025-12-25 12:25:58 -08:00 · 2024-07-22 00:23:53 +02:00
90 changed files with 839 additions and 7043 deletions
--- a/.github/workflows/qc.yaml
+++ b/.github/workflows/qc.yaml
@@ -195,16 +195,13 @@ jobs:
      - run: rustup component add llvm-tools-preview
      - run: |
          cargo install cargo-llvm-cov || true
-          cargo llvm-cov \
-            --workspace\
-            --all-features \
-            --lcov \
-            --output-path coverage.lcov
+          cargo llvm-cov --lcov --output-path coverage.lcov
      # If using tarapulin
      #- run: cargo install cargo-tarpaulin
      #- run: cargo tarpaulin --out Xml
      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v4.0.1
        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
          files: ./coverage.lcov
          verbose: true
--- a/.gitignore
+++ b/.gitignore
@@ -21,7 +21,4 @@ _markdown_*
 **/result-*
 .direnv

-# Visual studio code
-.vscode
-
-/output
+/output
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,38 +0,0 @@
-**Making a new Release of Rosenpass — Cooking Recipe**
-
-If you have to change a file, do what it takes to get the change as commit on the main branch, then **start from step 0**.
-If any other issue occurs
-
-0. Make sure you are in the root directory of the project
-   - `cd "$(git rev-parse --show-toplevel)"`
-1. Make sure you locally checked out the head of the main branch
-   - `git stash --include-untracked && git checkout main && git pull`
-2. Make sure all tests pass
-   - `cargo test`
-3. Make sure the current version in `rosenpass/Cargo.toml` matches that in the [last release on GitHub](https://github.com/rosenpass/rosenpass/releases)
-   - Only normal releases count, release candidates and draft releases can be ignored
-4. Pick the kind of release that you want to make (`major`, `minor`, `patch`, `rc`, ...)
-   - See `cargo release --help` for more information on the available release types
-   - Pick `rc` if in doubt
-5. Try to release a new version
-   - `cargo release rc --package rosenpass`
-   - An issue was reported? Go fix it, start again with step 0!
-6. Actually make the release
-   - `cargo release rc --package rosenpass --execute`
-   - Tentatively wait for any interactions, such as entering ssh keys etc.
-   - You may be asked for your ssh key multiple times!
-
-**Frequently Asked Questions (FAQ)**
-
- You have untracked files, which `cargo release` complains about?
-  - `git stash --include-untracked`
- You cannot push to crates.io because you are not logged in?
-  - Follow the steps displayed in [`cargo login`](https://doc.rust-lang.org/cargo/commands/cargo-login.html)
- How is the release page added to [GitHub Releases](https://github.com/rosenpass/rosenpass/releases) itself?
-  - Our CI Pipeline will create the release, once `cargo release` pushed the new version tag to the repo. The new release should pop up almost immediately in [GitHub Releases](https://github.com/rosenpass/rosenpass/releases) after the [Actions/Release](https://github.com/rosenpass/rosenpass/actions/workflows/release.yaml) pipeline started.
- No new release pops up in the `Release` sidebar element on the [main page](https://github.com/rosenpass/rosenpass)
-  - Did you push a `rc` release? This view only shows non-draft release, but `rc` releases are considered as draft. See [Releases](https://github.com/rosenpass/rosenpass/releases) page to see all (including draft!) releases.
- The release page was created on GitHub, but there are no assets/artifacts other than the source code tar ball/zip?
-  - The artifacts are generated and pushed automatically to the release, but this takes some time (a couple of minutes). You can check the respective CI pipeline: [Actions/Release](https://github.com/rosenpass/rosenpass/actions/workflows/release.yaml), which should start immediately after `cargo release` pushed the new release tag to the repo. The release artifacts only are added later to the release, once all jobs in bespoke pipeline finished.
- How are the release artifacts generated, and what are they?
-  - The release artifacts are built using one Nix derivation per platform, `nix build .#release-package`. It contains both statically linked versions of `rosenpass` itself and OCI container images.
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -75,9 +75,9 @@ dependencies = [

 [[package]]
 name = "anstyle"
-version = "1.0.8"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
+checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"

 [[package]]
 name = "anstyle-parse"
@@ -142,7 +142,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
 "hermit-abi 0.1.19",
 "libc",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -153,13 +153,13 @@ checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"

 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "17c6a35df3749d2e8bb1b7b21a976d82b15548788d2735b9d82f329268f71a11"
 dependencies = [
 "addr2line",
 "cc",
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "miniz_oxide",
 "object",
@@ -288,6 +288,12 @@ dependencies = [
 "nom",
 ]

+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -300,7 +306,7 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "cipher",
 "cpufeatures",
 ]
@@ -381,9 +387,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.5.16"
+version = "4.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
+checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -391,9 +397,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.15"
+version = "4.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
+checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
 dependencies = [
 "anstream",
 "anstyle",
@@ -403,9 +409,9 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.5.13"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
+checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
 dependencies = [
 "heck",
 "proc-macro2",
@@ -449,16 +455,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"

-[[package]]
-name = "command-fds"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f190f3c954f7bca3c6296d0ec561c739bdbe6c7e990294ed168d415f6e1b5b01"
-dependencies = [
- "nix 0.27.1",
- "thiserror",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -560,6 +556,16 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "ctor"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "ctrlc-async"
 version = "3.2.2"
@@ -568,7 +574,7 @@ checksum = "598e9d68e769aa1283460a3b0ec0d049ccfb6170277aea37089fa3f58fd721a1"
 dependencies = [
 "nix 0.23.2",
 "tokio",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -577,7 +583,7 @@ version = "4.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "cpufeatures",
 "curve25519-dalek-derive",
 "fiat-crypto",
@@ -770,12 +776,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"

-[[package]]
-name = "embedded-io"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
-
 [[package]]
 name = "env_logger"
 version = "0.10.2"
@@ -826,7 +826,7 @@ dependencies = [
 "cc",
 "lazy_static",
 "libc",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -835,6 +835,22 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags 1.3.2",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
 [[package]]
 name = "futures"
 version = "0.3.30"
@@ -950,16 +966,27 @@ dependencies = [
 "tokio",
 ]

+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "js-sys",
 "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
 "wasm-bindgen",
 ]

@@ -981,7 +1008,7 @@ version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "crunchy",
 ]

@@ -1047,12 +1074,6 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

-[[package]]
-name = "hex-literal"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
-
 [[package]]
 name = "home"
 version = "0.5.9"
@@ -1104,22 +1125,31 @@ dependencies = [
 ]

 [[package]]
-name = "ipc-channel"
-version = "0.18.2"
+name = "iovec"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e46231d1db8ea8f874012b1b87efb9e968f763c577220372a9c7caadce1448da"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "ipc-channel"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "342d636452fbc2895574e0b319b23c014fd01c9ed71dcd87f6a4a8e2f948db4b"
 dependencies = [
 "bincode",
 "crossbeam-channel",
 "fnv",
 "lazy_static",
 "libc",
- "mio",
- "rand",
+ "mio 0.6.23",
+ "rand 0.7.3",
 "serde",
 "tempfile",
 "uuid",
- "windows",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1172,6 +1202,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -1186,9 +1226,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"

 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"

 [[package]]
 name = "libcrux"
@@ -1196,11 +1236,11 @@ version = "0.0.2-pre.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "31d9dcd435758db03438089760c55a45e6bcab7e4e299ee261f75225ab29d482"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
 "libcrux-hacl",
 "libcrux-platform",
 "libjade-sys",
- "rand",
+ "rand 0.8.5",
 ]

 [[package]]
@@ -1249,7 +1289,7 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "windows-targets 0.52.5",
 ]

@@ -1304,7 +1344,7 @@ name = "memsec"
 version = "0.6.3"
 source = "git+https://github.com/rosenpass/memsec.git?rev=aceb9baee8aec6844125bd6612f92e9a281373df#aceb9baee8aec6844125bd6612f92e9a281373df"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
 "libc",
 "windows-sys 0.45.0",
 ]
@@ -1326,15 +1366,45 @@ dependencies = [

 [[package]]
 name = "mio"
-version = "1.0.2"
+version = "0.6.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
 dependencies = [
- "hermit-abi 0.3.9",
+ "cfg-if 0.1.10",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
 "libc",
 "log",
- "wasi",
- "windows-sys 0.52.0",
+ "miow",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
 ]

 [[package]]
@@ -1362,6 +1432,17 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "net2"
+version = "0.2.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
+dependencies = [
+ "cfg-if 0.1.10",
+ "libc",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "netlink-packet-core"
 version = "0.7.0"
@@ -1461,7 +1542,7 @@ checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
 "bitflags 1.3.2",
 "cc",
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "memoffset 0.6.5",
 ]
@@ -1473,7 +1554,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
 dependencies = [
 "bitflags 2.5.0",
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 ]

@@ -1497,10 +1578,20 @@ dependencies = [
 ]

 [[package]]
-name = "object"
-version = "0.36.3"
+name = "num_cpus"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8ec7ab813848ba4522158d5517a6093db1ded27575b070f4177b8d12b41db5e"
 dependencies = [
 "memchr",
 ]
@@ -1558,7 +1649,7 @@ version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "redox_syscall",
 "smallvec",
@@ -1642,13 +1733,12 @@ dependencies = [

 [[package]]
 name = "postcard"
-version = "1.0.9"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20ee10b999a00ca189ac2cb99f5db1ca71fb7371e3d5f493b879ca95d2a67220"
+checksum = "a55c51ee6c0db07e68448e336cf8ea4131a620edefebf9893e759b2d793420f8"
 dependencies = [
 "cobs",
- "embedded-io 0.4.0",
- "embedded-io 0.6.1",
+ "embedded-io",
 "heapless",
 "serde",
 ]
@@ -1680,17 +1770,17 @@ dependencies = [

 [[package]]
 name = "procspawn"
-version = "1.0.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d03cb7d264b20167ed4d1df34153aa50d45c3f4a829261d2ad610982cbf25dd"
+checksum = "8d59f115c63b1eed96002d9df8dfe022ba07e0d70b42890d34bc34f4342bae6b"
 dependencies = [
 "backtrace",
+ "ctor",
 "findshlibs",
 "ipc-channel",
 "libc",
 "serde",
- "small_ctor",
- "windows-sys 0.48.0",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1711,6 +1801,19 @@ dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+]
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -1718,8 +1821,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
 "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
 ]

 [[package]]
@@ -1729,7 +1842,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
 "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
 ]

 [[package]]
@@ -1738,7 +1860,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
 ]

 [[package]]
@@ -1804,21 +1935,17 @@ name = "rosenpass"
 version = "0.2.1"
 dependencies = [
 "anyhow",
- "clap 4.5.16",
- "command-fds",
+ "clap 4.5.9",
 "criterion",
 "derive_builder 0.20.0",
 "env_logger",
- "heck",
- "hex",
- "hex-literal",
 "home",
 "log",
 "memoffset 0.9.1",
- "mio",
+ "mio 0.8.11",
 "paste",
 "procspawn",
- "rand",
+ "rand 0.8.5",
 "rosenpass-cipher-traits",
 "rosenpass-ciphers",
 "rosenpass-constant-time",
@@ -1826,18 +1953,14 @@ dependencies = [
 "rosenpass-to",
 "rosenpass-util",
 "rosenpass-wireguard-broker",
- "rustix",
 "serde",
 "serial_test",
 "stacker",
 "static_assertions",
- "tempfile",
 "test_bin",
 "thiserror",
 "toml",
- "uds",
 "zerocopy",
- "zeroize",
 ]

 [[package]]
@@ -1866,7 +1989,7 @@ name = "rosenpass-constant-time"
 version = "0.1.0"
 dependencies = [
 "memsec",
- "rand",
+ "rand 0.8.5",
 "rosenpass-to",
 ]

@@ -1905,7 +2028,7 @@ dependencies = [
 "log",
 "memsec",
 "procspawn",
- "rand",
+ "rand 0.8.5",
 "rosenpass-to",
 "rosenpass-util",
 "tempfile",
@@ -1925,14 +2048,9 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "base64ct",
- "mio",
 "rustix",
 "static_assertions",
- "tempfile",
- "thiserror",
 "typenum",
- "uds",
- "zerocopy",
 "zeroize",
 ]

@@ -1941,19 +2059,17 @@ name = "rosenpass-wireguard-broker"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "clap 4.5.16",
+ "clap 4.5.9",
 "derive_builder 0.20.0",
 "env_logger",
- "libc",
 "log",
- "mio",
+ "mio 0.8.11",
 "postcard",
 "procspawn",
- "rand",
+ "rand 0.8.5",
 "rosenpass-secret-memory",
 "rosenpass-to",
 "rosenpass-util",
- "rustix",
 "thiserror",
 "tokio",
 "wireguard-uapi",
@@ -2083,18 +2199,18 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"

 [[package]]
 name = "serde"
-version = "1.0.208"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
+checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.208"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
+checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2170,12 +2286,6 @@ dependencies = [
 "autocfg",
 ]

-[[package]]
-name = "small_ctor"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88414a5ca1f85d82cc34471e975f0f74f6aa54c40f062efa42c0080e7f763f81"
-
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -2214,10 +2324,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c886bd4480155fd3ef527d45e9ac8dd7118a898a46530b7b94c3e21866259fce"
 dependencies = [
 "cc",
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "psm",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -2274,13 +2384,12 @@ checksum = "b4e17d8598067a8c134af59cd33c1c263470e089924a11ab61cf61690919fe3b"

 [[package]]
 name = "tempfile"
-version = "3.11.0"
+version = "3.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fcd239983515c23a32fb82099f97d0b11b8c72f654ed659363a95c3dad7a53"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "fastrand",
- "once_cell",
 "rustix",
 "windows-sys 0.52.0",
 ]
@@ -2338,27 +2447,28 @@ dependencies = [

 [[package]]
 name = "tokio"
-version = "1.39.3"
+version = "1.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babc99b9923bfa4804bd74722ff02c0381021eafa4db9949217e3be8e84fff5"
+checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
 dependencies = [
 "backtrace",
 "bytes",
 "libc",
- "mio",
+ "mio 0.8.11",
+ "num_cpus",
 "parking_lot",
 "pin-project-lite",
 "signal-hook-registry",
 "socket2",
 "tokio-macros",
- "windows-sys 0.52.0",
+ "windows-sys 0.48.0",
 ]

 [[package]]
 name = "tokio-macros"
-version = "2.4.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
+checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2405,15 +2515,6 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

-[[package]]
-name = "uds"
-version = "0.4.2"
-source = "git+https://github.com/rosenpass/uds#b47934fe52422e559f7278938875f9105f91c5a2"
-dependencies = [
- "libc",
- "mio",
-]
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
@@ -2442,7 +2543,7 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
 ]

 [[package]]
@@ -2461,6 +2562,12 @@ dependencies = [
 "winapi-util",
 ]

+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -2473,7 +2580,7 @@ version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "wasm-bindgen-macro",
 ]

@@ -2543,6 +2650,12 @@ dependencies = [
 "rustix",
 ]

+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -2553,6 +2666,12 @@ dependencies = [
 "winapi-x86_64-pc-windows-gnu",
 ]

+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
@@ -2574,15 +2693,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

-[[package]]
-name = "windows"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
@@ -2811,6 +2921,16 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
 [[package]]
 name = "x25519-dalek"
 version = "2.0.1"
@@ -2818,7 +2938,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
 "curve25519-dalek",
- "rand_core",
+ "rand_core 0.6.4",
 "serde",
 "zeroize",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,31 +45,26 @@ memsec = { git="https://github.com/rosenpass/memsec.git" ,rev="aceb9baee8aec6844
 rand = "0.8.5"
 typenum = "1.17.0"
 log = { version = "0.4.22" }
-clap = { version = "4.5.16", features = ["derive"] }
-serde = { version = "1.0.208", features = ["derive"] }
+clap = { version = "4.5.9", features = ["derive"] }
+serde = { version = "1.0.204", features = ["derive"] }
 arbitrary = { version = "1.3.2", features = ["derive"] }
 anyhow = { version = "1.0.86", features = ["backtrace", "std"] }
-mio = { version = "1.0.2", features = ["net", "os-poll"] }
+mio = { version = "0.8.11", features = ["net", "os-poll"] }
 oqs-sys = { version = "0.9.1", default-features = false, features = [
-  'classic_mceliece',
-  'kyber',
+    'classic_mceliece',
+    'kyber',
 ] }
 blake2 = "0.10.6"
 chacha20poly1305 = { version = "0.10.1", default-features = false, features = [
-  "std",
-  "heapless",
+    "std",
+    "heapless",
 ] }
 zerocopy = { version = "0.7.35", features = ["derive"] }
 home = "0.5.9"
 derive_builder = "0.20.0"
-tokio = { version = "1.39", features = ["macros", "rt-multi-thread"] }
-postcard= {version = "1.0.9", features = ["alloc"]}
+tokio = { version = "1.38", features = ["macros", "rt-multi-thread"] }
+postcard= {version = "1.0.8", features = ["alloc"]}
 libcrux = { version = "0.0.2-pre.2" }
-hex-literal = { version = "0.4.1" }
-hex = { version = "0.4.3" }
-heck = { version = "0.5.0"  }
-libc = { version = "0.2" }
-uds = { git = "https://github.com/rosenpass/uds" }

 #Dev dependencies
 serial_test = "3.1.1"
@@ -79,10 +74,10 @@ libfuzzer-sys = "0.4"
 test_bin = "0.4.0"
 criterion = "0.4.0"
 allocator-api2-tests = "0.2.15"
-procspawn = {version = "1.0.1", features= ["test-support"]}
+procspawn = {version = "1.0.0", features= ["test-support"]}


 #Broker dependencies (might need cleanup or changes)
 wireguard-uapi = { version = "3.0.0", features = ["xplatform"] }
 command-fds = "0.2.3"
-rustix = { version = "0.38.27", features = ["net", "fs"] }
+rustix = { version = "0.38.27", features = ["net"] }
--- a/cipher-traits/src/kem.rs
+++ b/cipher-traits/src/kem.rs
@@ -10,6 +10,8 @@
 //! The [KEM] Trait describes the basic API offered by a Key Encapsulation
 //! Mechanism. Two implementations for it are provided, [StaticKEM] and [EphemeralKEM].

+use std::result::Result;
+
 /// Key Encapsulation Mechanism
 ///
 /// The KEM interface defines three operations: Key generation, key encapsulation and key
--- a/ciphers/src/lib.rs
+++ b/ciphers/src/lib.rs
@@ -9,12 +9,10 @@ const_assert!(KEY_LEN == hash_domain::KEY_LEN);

 /// Authenticated encryption with associated data
 pub mod aead {
-    #[cfg(not(feature = "experiment_libcrux"))]
+    #[cfg(not(feature = "libcrux"))]
+    pub use crate::subtle::chacha20poly1305_ietf::{decrypt, encrypt, KEY_LEN, NONCE_LEN, TAG_LEN};
+    #[cfg(feature = "libcrux")]
    pub use crate::subtle::chacha20poly1305_ietf::{decrypt, encrypt, KEY_LEN, NONCE_LEN, TAG_LEN};
-    #[cfg(feature = "experiment_libcrux")]
-    pub use crate::subtle::chacha20poly1305_ietf_libcrux::{
-        decrypt, encrypt, KEY_LEN, NONCE_LEN, TAG_LEN,
-    };
 }

 /// Authenticated encryption with associated data with a constant nonce
--- a/ciphers/src/subtle/mod.rs
+++ b/ciphers/src/subtle/mod.rs
@@ -1,7 +1,7 @@
 pub mod blake2b;
-#[cfg(not(feature = "experiment_libcrux"))]
+#[cfg(not(feature = "libcrux"))]
 pub mod chacha20poly1305_ietf;
-#[cfg(feature = "experiment_libcrux")]
+#[cfg(feature = "libcrux")]
 pub mod chacha20poly1305_ietf_libcrux;
 pub mod incorrect_hmac_blake2b;
 pub mod xchacha20poly1305_ietf;
--- a/constant-time/src/memcmp.rs
+++ b/constant-time/src/memcmp.rs
@@ -7,16 +7,18 @@
 ///
 /// The execution time of the function grows approx. linear with the length of the input. This is
 /// considered safe.
+///
+/// ## Tests
+/// [`tests::memcmp_runs_in_constant_time`] runs a stasticial test that the equality of the two
+/// input parameters does not correlate with the run time.
+///
+/// For discussion on how to (further) ensure the constant-time execution of this function,
+/// see <https://github.com/rosenpass/rosenpass/issues/232>
 #[inline]
 pub fn memcmp(a: &[u8], b: &[u8]) -> bool {
    a.len() == b.len() && unsafe { memsec::memeq(a.as_ptr(), b.as_ptr(), a.len()) }
 }

-/// [tests::memcmp_runs_in_constant_time] runs a stasticial test that the equality of the two
-/// input parameters does not correlate with the run time.
-///
-/// For discussion on how to (further) ensure the constant-time execution of this function,
-/// see <https://github.com/rosenpass/rosenpass/issues/232>
 #[cfg(all(test, feature = "constant_time_tests"))]
 mod tests {
    use super::*;
--- a/flake.nix
+++ b/flake.nix
@@ -411,12 +411,12 @@
            inherit (packages.proof-proverif) CRYPTOVERIF_LIB;
            inputsFrom = [ packages.default ];
            nativeBuildInputs = with pkgs; [
-              inputs.fenix.packages.${system}.complete.toolchain
              cmake # override the fakecmake from the main step above
              cargo-release
              clippy
              nodePackages.prettier
              nushell # for the .ci/gen-workflow-files.nu script
+              rustfmt
              packages.proverif-patched
            ];
          };
--- a/fuzz/fuzz_targets/aead_enc_into.rs
+++ b/fuzz/fuzz_targets/aead_enc_into.rs
@@ -15,7 +15,8 @@ pub struct Input {
 }

 fuzz_target!(|input: Input| {
-    let mut ciphertext = vec![0u8; input.plaintext.len() + 16];
+    let mut ciphertext: Vec<u8> = Vec::with_capacity(input.plaintext.len() + 16);
+    ciphertext.resize(input.plaintext.len() + 16, 0);

    aead::encrypt(
        ciphertext.as_mut_slice(),
--- a/manual_tests/psk_broker/peer_a.rp.config
+++ b/manual_tests/psk_broker/peer_a.rp.config
@@ -1,13 +0,0 @@
-secret_key = "peer_a.rp.sk"
-public_key = "peer_a.rp.pk"
-listen = ["[::1]:46127"]
-verbosity = "Verbose"
-
-[api]
-listen_path = []
-listen_fd = []
-stream_fd = []
-
-[[peers]]
-public_key = "peer_b.rp.pk"
-device = "rpPskBrkTestA"
--- a/manual_tests/psk_broker/peer_b.rp.config
+++ b/manual_tests/psk_broker/peer_b.rp.config
@@ -1,14 +0,0 @@
-secret_key = "peer_b.rp.sk"
-public_key = "peer_b.rp.pk"
-listen = []
-verbosity = "Verbose"
-
-[api]
-listen_path = []
-listen_fd = []
-stream_fd = []
-
-[[peers]]
-public_key = "peer_a.rp.pk"
-endpoint = "[::1]:46127"
-device = "rpPskBrkTestB"
--- a/manual_tests/psk_broker/run_test.sh
+++ b/manual_tests/psk_broker/run_test.sh
@@ -1,215 +0,0 @@
-#! /bin/bash
-
-set -e -o pipefail
-
-enquote() {
-  while (( "$#" > 1)); do
-    printf "%q " "$1"
-    shift
-  done
-  if (("$#" > 0)); then
-    printf "%q" "$1"
-  fi
-}
-
-CLEANUP_HOOKS=()
-hook_cleanup() {
-  local hook
-  set +e +o pipefail
-  for hook in "${CLEANUP_HOOKS[@]}"; do
-    eval "${hook}"
-  done
-}
-
-cleanup() {
-  CLEANUP_HOOKS=("$(enquote exc_with_ctx cleanup "$@")" "${CLEANUP_HOOKS[@]}")
-}
-
-cleanup_eval() {
-  cleanup eval "$*"
-}
-
-stderr() {
-  echo >&2 "$@"
-}
-
-log() {
-  local level; level="$1"; shift || fatal "USAGE: log LVL MESSAGE.."
-  stderr "[${level}]" "$@"
-}
-
-info() {
-  log "INFO" "$@"
-}
-
-debug() {
-  log "DEBUG" "$@"
-}
-
-fatal() {
-  log "FATAL" "$@"
-  exit 1
-}
-
-assert() {
-  local msg; msg="$1"; shift || fatal "USAGE: assert_cmd MESSAGE COMMAND.."
-  "$@" || fatal "${msg}"
-}
-
-abs_dir() {
-  local dir; dir="$1"; shift || fatal "USAGE: abs_dir DIR"
-  (
-    cd "${dir}"
-    pwd -P
-  )
-}
-
-exc_with_ctx() {
-  local ctx; ctx="$1"; shift || fatal "USAGE: exc_with_ctx CONTEXT COMMAND.."
-  if [[ -z "${ctx}" ]]; then
-    info '$' "$@"
-  else
-    info "${ctx}\$" "$@"
-  fi
-
-  "$@"
-}
-
-exc() {
-  exc_with_ctx "" "$@"
-}
-
-exc_eval() {
-  exc eval "$*"
-} 
-
-exc_eval_with_ctx() {
-  local ctx; ctx="$1"; shift || fatal "USAGE: exc_eval_with_ctx CONTEXT EVAL_COMMAND.."
-  exc_with_ctx "eval:${ctx}" "$*"
-} 
-
-exc_as_user() {
-  exc sudo -u "${SUDO_USER}" "$@"
-}
-
-exc_eval_as_user() {
-  exc_as_user bash -c "$*"
-}
-
-fork_eval_as_user() {
-  exc sudo -u "${SUDO_USER}" bash -c "$*" &
-  local pid; pid="$!"
-  cleanup wait "${pid}"
-  cleanup pkill -2 -P "${pid}" # Reverse ordering
-}
-
-info_success() {
-  stderr
-  stderr
-  if [[ "${SUCCESS}" = 1 ]]; then
-    stderr "  Test was a success!"
-  else
-    stderr "  !!! TEST WAS A FAILURE!!!"
-  fi
-  stderr
-}
-
-main() {
-  assert "Use as root with sudo" [ "$(id -u)" -eq 0 ]
-  assert "Use as root with sudo" [ -n "${SUDO_UID}" ]
-  assert "SUDO_UID is 0; refusing to build as root" [ "${SUDO_UID}" -ne 0 ]
-
-  cleanup info_success
-
-  trap hook_cleanup EXIT
-
-  SCRIPT="$0"
-  CFG_TEMPLATE_DIR="$(abs_dir "$(dirname "${SCRIPT}")")"
-  REPO="$(abs_dir "${CFG_TEMPLATE_DIR}/../..")"
-  BINS="${REPO}/target/debug"
-
-  # Create temp dir
-  TMP_DIR="/tmp/rosenpass-psk-broker-test-$(date +%s)-$(uuidgen)"
-  cleanup rm -rf "${TMP_DIR}"
-  exc_as_user mkdir -p "${TMP_DIR}"
-
-  # Copy config
-  CFG_DIR="${TMP_DIR}/cfg"
-  exc_as_user cp -R "${CFG_TEMPLATE_DIR}" "${CFG_DIR}"
-
-  exc umask 077
-
-  exc cd "${REPO}"
-  local build_cmd; build_cmd=(cargo build --workspace --color=always --all-features --bins --profile dev)
-  if test -e "${BINS}/rosenpass-wireguard-broker-privileged" -a -e "${BINS}/rosenpass"; then
-    info "Found the binaries rosenpass-wireguard-broker-privileged and rosenpass." \
-      "Run following commands as a regular user to recompile the binaries with the right options" \
-      "in case of an error:" '$' "${build_cmd[@]}"
-  else
-    exc_as_user "${build_cmd[@]}"
-  fi
-  exc sudo setcap CAP_NET_ADMIN=+eip "${BINS}/rosenpass-wireguard-broker-privileged"
-
-  exc cd "${CFG_DIR}"
-  exc_eval_as_user "wg genkey > peer_a.wg.sk"
-  exc_eval_as_user "wg pubkey < peer_a.wg.sk > peer_a.wg.pk"
-  exc_eval_as_user "wg genkey > peer_b.wg.sk"
-  exc_eval_as_user "wg pubkey < peer_b.wg.sk > peer_b.wg.pk"
-  exc_eval_as_user "wg genpsk > peer_a_invalid.psk"
-  exc_eval_as_user "wg genpsk > peer_b_invalid.psk"
-  exc_eval_as_user "echo $(enquote "peer = \"$(cat peer_b.wg.pk)\"") >> peer_a.rp.config"
-  exc_eval_as_user "echo $(enquote "peer = \"$(cat peer_a.wg.pk)\"") >> peer_b.rp.config"
-  exc_as_user "${BINS}"/rosenpass gen-keys peer_a.rp.config
-  exc_as_user "${BINS}"/rosenpass gen-keys peer_b.rp.config
-
-  cleanup ip l del dev rpPskBrkTestA
-  cleanup ip l del dev rpPskBrkTestB
-  exc ip l add dev rpPskBrkTestA type wireguard
-  exc ip l add dev rpPskBrkTestB type wireguard
-
-  exc wg set rpPskBrkTestA \
-    listen-port 46125 \
-    private-key peer_a.wg.sk \
-    peer "$(cat peer_b.wg.pk)" \
-      endpoint 'localhost:46126' \
-      preshared-key peer_a_invalid.psk \
-      allowed-ips fe80::2/64
-  exc wg set rpPskBrkTestB \
-    listen-port 46126 \
-    private-key peer_b.wg.sk \
-    peer "$(cat peer_a.wg.pk)" \
-      endpoint 'localhost:46125' \
-      preshared-key peer_b_invalid.psk \
-      allowed-ips fe80::1/64
-
-  exc ip l set rpPskBrkTestA up
-  exc ip l set rpPskBrkTestB up
-
-  exc ip a add fe80::1/64 dev rpPskBrkTestA
-  exc ip a add fe80::2/64 dev rpPskBrkTestB
-
-  fork_eval_as_user "\
-    RUST_LOG='info' \
-    PATH=$(enquote "${REPO}/target/debug:${PATH}") \
-    $(enquote "${BINS}/rosenpass") --psk-broker-spawn \
-      exchange-config peer_a.rp.config"
-  fork_eval_as_user "\
-    RUST_LOG='info' \
-    PATH=$(enquote "${REPO}/target/debug:${PATH}") \
-    $(enquote "${BINS}/rosenpass-wireguard-broker-socket-handler") \
-      --listen-path broker.sock"
-  fork_eval_as_user "\
-    RUST_LOG='info' \
-    PATH=$(enquote "$PWD/target/debug:${PATH}") \
-    $(enquote "${BINS}/rosenpass") --psk-broker-path broker.sock \
-      exchange-config peer_b.rp.config"
-
-  exc_as_user ping -c 2 -w 10 fe80::1%rpPskBrkTestA
-  exc_as_user ping -c 2 -w 10 fe80::2%rpPskBrkTestB
-  exc_as_user ping -c 2 -w 10 fe80::2%rpPskBrkTestA
-  exc_as_user ping -c 2 -w 10 fe80::1%rpPskBrkTestB
-
-  SUCCESS=1
-}
-
-main "$@"
--- a/readme.md
+++ b/readme.md
@@ -66,8 +66,6 @@ A wrapper script provides instant feedback about which queries execute as expect

 # Getting Rosenpass

-Documentation and installation guides can be found at the [Rosenpass website](https://rosenpass.eu/docs).
-
 Rosenpass is packaged for more and more distributions, maybe also for the distribution of your choice?

 [![Packaging status](https://repology.org/badge/vertical-allrepos/rosenpass.svg)](https://repology.org/project/rosenpass/versions)
--- a/rosenpass/Cargo.toml
+++ b/rosenpass/Cargo.toml
@@ -13,19 +13,6 @@ readme = "readme.md"
 name = "rosenpass"
 path = "src/main.rs"

-[[bin]]
-name = "rosenpass-gen-ipc-msg-types"
-path = "src/bin/gen-ipc-msg-types.rs"
-required-features = ["experiment_api", "internal_bin_gen_ipc_msg_types"]
-
-[[test]]
-name = "api-integration-tests"
-required-features = ["experiment_api", "internal_testing"]
-
-[[test]]
-name = "api-integration-tests-api-setup"
-required-features = ["experiment_api", "internal_testing"]
-
 [[bench]]
 name = "handshake"
 harness = false
@@ -53,13 +40,6 @@ zerocopy = { workspace = true }
 home = { workspace = true }
 derive_builder = {workspace = true}
 rosenpass-wireguard-broker = {workspace = true}
-zeroize = { workspace = true }
-hex-literal = { workspace = true, optional = true }
-hex = { workspace = true, optional = true }
-heck = { workspace = true, optional = true }
-command-fds = { workspace = true, optional = true }
-rustix = { workspace = true }
-uds = { workspace = true, optional = true, features = ["mio_1xx"] }

 [build-dependencies]
 anyhow = { workspace = true }
@@ -70,13 +50,8 @@ test_bin = { workspace = true }
 stacker = { workspace = true }
 serial_test = {workspace = true}
 procspawn = {workspace = true}
-tempfile = { workspace = true }
-rustix = {workspace = true}

 [features]
-default = ["experiment_api"]
-experiment_memfd_secret = ["rosenpass-wireguard-broker/experiment_memfd_secret"]
+enable_broker_api = ["rosenpass-wireguard-broker/enable_broker_api"]
+enable_memfd_alloc = []
 experiment_libcrux = ["rosenpass-ciphers/experiment_libcrux"]
-experiment_api = ["hex-literal", "uds", "command-fds", "rosenpass-util/experiment_file_descriptor_passing", "rosenpass-wireguard-broker/experiment_api"]
-internal_testing  = []
-internal_bin_gen_ipc_msg_types = ["hex", "heck"]
--- a/rosenpass/src/api/api_handler.rs
+++ b/rosenpass/src/api/api_handler.rs
@@ -1,295 +0,0 @@
-use std::{borrow::BorrowMut, collections::VecDeque, os::fd::OwnedFd};
-
-use anyhow::Context;
-use rosenpass_to::{ops::copy_slice, To};
-use rosenpass_util::{
-    fd::FdIo,
-    functional::{run, ApplyExt},
-    io::ReadExt,
-    mem::DiscardResultExt,
-    mio::UnixStreamExt,
-    result::OkExt,
-};
-use rosenpass_wireguard_broker::brokers::mio_client::MioBrokerClient;
-
-use crate::{
-    api::{add_listen_socket_response_status, add_psk_broker_response_status},
-    app_server::AppServer,
-    protocol::BuildCryptoServer,
-};
-
-use super::{supply_keypair_response_status, Server as ApiServer};
-
-#[derive(Debug)]
-pub struct ApiHandler {
-    _dummy: (),
-}
-
-impl ApiHandler {
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        Self { _dummy: () }
-    }
-}
-
-pub trait ApiHandlerContext {
-    fn api_handler(&self) -> &ApiHandler;
-    fn app_server(&self) -> &AppServer;
-    fn api_handler_mut(&mut self) -> &mut ApiHandler;
-    fn app_server_mut(&mut self) -> &mut AppServer;
-}
-
-#[derive(thiserror::Error, Debug)]
-#[error("Error in SupplyKeypair")]
-struct SupplyKeypairError {
-    status: u128,
-    #[source]
-    cause: anyhow::Error,
-}
-
-trait SupplyKeypairErrorExt<T> {
-    fn e_custom(self, status: u128) -> Result<T, SupplyKeypairError>;
-    fn einternal(self) -> Result<T, SupplyKeypairError>;
-    fn ealready_supplied(self) -> Result<T, SupplyKeypairError>;
-    fn einvalid_req(self) -> Result<T, SupplyKeypairError>;
-}
-
-impl<T, E: Into<anyhow::Error>> SupplyKeypairErrorExt<T> for Result<T, E> {
-    fn e_custom(self, status: u128) -> Result<T, SupplyKeypairError> {
-        self.map_err(|e| SupplyKeypairError {
-            status,
-            cause: e.into(),
-        })
-    }
-
-    fn einternal(self) -> Result<T, SupplyKeypairError> {
-        self.e_custom(supply_keypair_response_status::INTERNAL_ERROR)
-    }
-
-    fn ealready_supplied(self) -> Result<T, SupplyKeypairError> {
-        self.e_custom(supply_keypair_response_status::KEYPAIR_ALREADY_SUPPLIED)
-    }
-
-    fn einvalid_req(self) -> Result<T, SupplyKeypairError> {
-        self.e_custom(supply_keypair_response_status::INVALID_REQUEST)
-    }
-}
-
-impl<T> ApiServer for T
-where
-    T: ?Sized + ApiHandlerContext,
-{
-    fn ping(
-        &mut self,
-        req: &super::PingRequest,
-        _req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::PingResponse,
-    ) -> anyhow::Result<()> {
-        let (req, res) = (&req.payload, &mut res.payload);
-        copy_slice(&req.echo).to(&mut res.echo);
-        Ok(())
-    }
-
-    fn supply_keypair(
-        &mut self,
-        req: &super::SupplyKeypairRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::SupplyKeypairResponse,
-    ) -> anyhow::Result<()> {
-        let outcome: Result<(), SupplyKeypairError> = run(|| {
-            // Acquire the file descriptors
-            let mut sk_io = FdIo(
-                req_fds
-                    .front()
-                    .context("First file descriptor, secret key, missing.")
-                    .einvalid_req()?,
-            );
-            let mut pk_io = FdIo(
-                req_fds
-                    .get(1)
-                    .context("Second file descriptor, public key, missing.")
-                    .einvalid_req()?,
-            );
-
-            // Actually read the secrets
-            let mut sk = crate::protocol::SSk::zero();
-            sk_io.read_exact_til_end(sk.secret_mut()).einvalid_req()?;
-
-            let mut pk = crate::protocol::SPk::zero();
-            pk_io.read_exact_til_end(pk.borrow_mut()).einvalid_req()?;
-
-            // Retrieve the construction site
-            let construction_site = self.app_server_mut().crypto_site.borrow_mut();
-
-            // Retrieve the builder
-            use rosenpass_util::build::ConstructionSite as C;
-            let maybe_builder = match construction_site {
-                C::Builder(builder) => Some(builder),
-                C::Product(_) => None,
-                C::Void => {
-                    return Err(anyhow::Error::msg("CryptoServer construction side is void"))
-                        .einternal();
-                }
-            };
-
-            // Retrieve a reference to the keypair
-            let Some(BuildCryptoServer {
-                ref mut keypair, ..
-            }) = maybe_builder
-            else {
-                return Err(anyhow::Error::msg("CryptoServer already built")).ealready_supplied();
-            };
-
-            // Supply the keypair to the CryptoServer
-            keypair
-                .insert(crate::protocol::Keypair { sk, pk })
-                .discard_result();
-
-            // Actually construct the CryptoServer
-            construction_site
-                .erect()
-                .map_err(|e| anyhow::Error::msg(format!("Error erecting the CryptoServer {e:?}")))
-                .einternal()?;
-
-            Ok(())
-        });
-
-        // Handle errors
-        use supply_keypair_response_status as status;
-        let status = match outcome {
-            Ok(()) => status::OK,
-            Err(e) => {
-                let lvl = match e.status {
-                    status::INTERNAL_ERROR => log::Level::Warn,
-                    _ => log::Level::Debug,
-                };
-
-                log::log!(
-                    lvl,
-                    "Error while processing API Request.\n    Request: {:?}\n    Error: {:?}",
-                    req,
-                    e.cause
-                );
-
-                if e.status == status::INTERNAL_ERROR {
-                    return Err(e.cause);
-                }
-
-                e.status
-            }
-        };
-
-        res.payload.status = status;
-
-        Ok(())
-    }
-
-    fn add_listen_socket(
-        &mut self,
-        _req: &super::boilerplate::AddListenSocketRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::boilerplate::AddListenSocketResponse,
-    ) -> anyhow::Result<()> {
-        // Retrieve file descriptor
-        let sock_res = run(|| -> anyhow::Result<mio::net::UdpSocket> {
-            let sock = req_fds
-                .pop_front()
-                .context("Invalid request – socket missing.")?;
-            // TODO: We need to have this outside linux
-            #[cfg(target_os = "linux")]
-            rosenpass_util::fd::GetSocketProtocol::demand_udp_socket(&sock)?;
-            let sock = std::net::UdpSocket::from(sock);
-            sock.set_nonblocking(true)?;
-            mio::net::UdpSocket::from_std(sock).ok()
-        });
-
-        let sock = match sock_res {
-            Ok(sock) => sock,
-            Err(e) => {
-                log::debug!("Error processing AddListenSocket API request: {e:?}");
-                res.payload.status = add_listen_socket_response_status::INVALID_REQUEST;
-                return Ok(());
-            }
-        };
-
-        // Register socket
-        let reg_result = self.app_server_mut().register_listen_socket(sock);
-
-        if let Err(internal_error) = reg_result {
-            log::warn!("Internal error processing AddListenSocket API request: {internal_error:?}");
-            res.payload.status = add_listen_socket_response_status::INTERNAL_ERROR;
-            return Ok(());
-        };
-
-        res.payload.status = add_listen_socket_response_status::OK;
-        Ok(())
-    }
-
-    fn add_psk_broker(
-        &mut self,
-        _req: &super::boilerplate::AddPskBrokerRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::boilerplate::AddPskBrokerResponse,
-    ) -> anyhow::Result<()> {
-        // Retrieve file descriptor
-        let sock_res = run(|| {
-            let sock = req_fds
-                .pop_front()
-                .context("Invalid request – socket missing.")?;
-            mio::net::UnixStream::from_fd(sock)
-        });
-
-        // Handle errors
-        let sock = match sock_res {
-            Ok(sock) => sock,
-            Err(e) => {
-                log::debug!(
-                    "Request found to be invalid while processing AddPskBroker API request: {e:?}"
-                );
-                res.payload.status = add_psk_broker_response_status::INVALID_REQUEST;
-                return Ok(());
-            }
-        };
-
-        // Register Socket
-        let client = Box::new(MioBrokerClient::new(sock));
-
-        // Workaround: The broker code is currently impressively overcomplicated. Brokers are
-        // stored in a hash map but the hash map key used is just a counter so a vector could
-        // have been used. Broker configuration is abstracted, different peers can have different
-        // brokers but there is no facility to add multiple brokers in practice. The broker index
-        // uses a `Public` wrapper without actually holding any cryptographic data. Even the broker
-        // configuration uses a trait abstraction for no discernible reason and a lot of the code
-        // introduces pointless, single-field wrapper structs.
-        // We should use an implement-what-is-actually-needed strategy next time.
-        // The Broker code needs to be slimmed down, the right direction to go is probably to
-        // just add event and capability support to the API and use the API to deliver OSK events.
-        //
-        // For now, we just replace the latest broker.
-        let erase_ptr = {
-            use crate::app_server::BrokerStorePtr;
-            //
-            use rosenpass_secret_memory::Public;
-            use zerocopy::AsBytes;
-            (self.app_server().brokers.store.len() - 1)
-                .apply(|x| x as u64)
-                .apply(|x| Public::from_slice(x.as_bytes()))
-                .apply(BrokerStorePtr)
-        };
-
-        let register_result = run(|| {
-            let srv = self.app_server_mut();
-            srv.unregister_broker(erase_ptr)?;
-            srv.register_broker(client)
-        });
-
-        if let Err(e) = register_result {
-            log::warn!("Internal error while processing AddPskBroker API request: {e:?}");
-            res.payload.status = add_psk_broker_response_status::INTERNAL_ERROR;
-            return Ok(());
-        }
-
-        res.payload.status = add_psk_broker_response_status::OK;
-        Ok(())
-    }
-}
--- a/rosenpass/src/api/boilerplate/byte_slice_ext.rs
+++ b/rosenpass/src/api/boilerplate/byte_slice_ext.rs
@@ -1,222 +0,0 @@
-use zerocopy::{ByteSlice, Ref};
-
-use rosenpass_util::zerocopy::{RefMaker, ZerocopySliceExt};
-
-use super::{
-    PingRequest, PingResponse, RawMsgType, RefMakerRawMsgTypeExt, RequestMsgType, RequestRef,
-    ResponseMsgType, ResponseRef, SupplyKeypairRequest, SupplyKeypairResponse,
-};
-
-pub trait ByteSliceRefExt: ByteSlice {
-    fn msg_type_maker(self) -> RefMaker<Self, RawMsgType> {
-        self.zk_ref_maker()
-    }
-
-    fn msg_type(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse()
-    }
-
-    fn msg_type_from_prefix(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse_prefix()
-    }
-
-    fn msg_type_from_suffix(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse_suffix()
-    }
-
-    fn request_msg_type(self) -> anyhow::Result<RequestMsgType> {
-        self.msg_type_maker().parse_request_msg_type()
-    }
-
-    fn request_msg_type_from_prefix(self) -> anyhow::Result<RequestMsgType> {
-        self.msg_type_maker()
-            .from_prefix()?
-            .parse_request_msg_type()
-    }
-
-    fn request_msg_type_from_suffix(self) -> anyhow::Result<RequestMsgType> {
-        self.msg_type_maker()
-            .from_suffix()?
-            .parse_request_msg_type()
-    }
-
-    fn response_msg_type(self) -> anyhow::Result<ResponseMsgType> {
-        self.msg_type_maker().parse_response_msg_type()
-    }
-
-    fn response_msg_type_from_prefix(self) -> anyhow::Result<ResponseMsgType> {
-        self.msg_type_maker()
-            .from_prefix()?
-            .parse_response_msg_type()
-    }
-
-    fn response_msg_type_from_suffix(self) -> anyhow::Result<ResponseMsgType> {
-        self.msg_type_maker()
-            .from_suffix()?
-            .parse_response_msg_type()
-    }
-
-    fn parse_request(self) -> anyhow::Result<RequestRef<Self>> {
-        RequestRef::parse(self)
-    }
-
-    fn parse_request_from_prefix(self) -> anyhow::Result<RequestRef<Self>> {
-        RequestRef::parse_from_prefix(self)
-    }
-
-    fn parse_request_from_suffix(self) -> anyhow::Result<RequestRef<Self>> {
-        RequestRef::parse_from_suffix(self)
-    }
-
-    fn parse_response(self) -> anyhow::Result<ResponseRef<Self>> {
-        ResponseRef::parse(self)
-    }
-
-    fn parse_response_from_prefix(self) -> anyhow::Result<ResponseRef<Self>> {
-        ResponseRef::parse_from_prefix(self)
-    }
-
-    fn parse_response_from_suffix(self) -> anyhow::Result<ResponseRef<Self>> {
-        ResponseRef::parse_from_suffix(self)
-    }
-
-    fn ping_request_maker(self) -> RefMaker<Self, PingRequest> {
-        self.zk_ref_maker()
-    }
-
-    fn ping_request(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse()
-    }
-
-    fn ping_request_from_prefix(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse_prefix()
-    }
-
-    fn ping_request_from_suffix(self) -> anyhow::Result<Ref<Self, PingRequest>> {
-        self.zk_parse_suffix()
-    }
-
-    fn ping_response_maker(self) -> RefMaker<Self, PingResponse> {
-        self.zk_ref_maker()
-    }
-
-    fn ping_response(self) -> anyhow::Result<Ref<Self, PingResponse>> {
-        self.zk_parse()
-    }
-
-    fn ping_response_from_prefix(self) -> anyhow::Result<Ref<Self, PingResponse>> {
-        self.zk_parse_prefix()
-    }
-
-    fn ping_response_from_suffix(self) -> anyhow::Result<Ref<Self, PingResponse>> {
-        self.zk_parse_suffix()
-    }
-
-    fn supply_keypair_request(self) -> anyhow::Result<Ref<Self, SupplyKeypairRequest>> {
-        self.zk_parse()
-    }
-
-    fn supply_keypair_request_from_prefix(self) -> anyhow::Result<Ref<Self, SupplyKeypairRequest>> {
-        self.zk_parse_prefix()
-    }
-
-    fn supply_keypair_request_from_suffix(self) -> anyhow::Result<Ref<Self, SupplyKeypairRequest>> {
-        self.zk_parse_suffix()
-    }
-
-    fn supply_keypair_response_maker(self) -> RefMaker<Self, SupplyKeypairResponse> {
-        self.zk_ref_maker()
-    }
-
-    fn supply_keypair_response(self) -> anyhow::Result<Ref<Self, SupplyKeypairResponse>> {
-        self.zk_parse()
-    }
-
-    fn supply_keypair_response_from_prefix(
-        self,
-    ) -> anyhow::Result<Ref<Self, SupplyKeypairResponse>> {
-        self.zk_parse_prefix()
-    }
-
-    fn supply_keypair_response_from_suffix(
-        self,
-    ) -> anyhow::Result<Ref<Self, SupplyKeypairResponse>> {
-        self.zk_parse_suffix()
-    }
-
-    fn add_listen_socket_request(self) -> anyhow::Result<Ref<Self, super::AddListenSocketRequest>> {
-        self.zk_parse()
-    }
-
-    fn add_listen_socket_request_from_prefix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddListenSocketRequest>> {
-        self.zk_parse_prefix()
-    }
-
-    fn add_listen_socket_request_from_suffix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddListenSocketRequest>> {
-        self.zk_parse_suffix()
-    }
-
-    fn add_listen_socket_response_maker(self) -> RefMaker<Self, super::AddListenSocketResponse> {
-        self.zk_ref_maker()
-    }
-
-    fn add_listen_socket_response(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddListenSocketResponse>> {
-        self.zk_parse()
-    }
-
-    fn add_listen_socket_response_from_prefix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddListenSocketResponse>> {
-        self.zk_parse_prefix()
-    }
-
-    fn add_listen_socket_response_from_suffix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddListenSocketResponse>> {
-        self.zk_parse_suffix()
-    }
-
-    fn add_psk_broker_request(self) -> anyhow::Result<Ref<Self, super::AddPskBrokerRequest>> {
-        self.zk_parse()
-    }
-
-    fn add_psk_broker_request_from_prefix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddPskBrokerRequest>> {
-        self.zk_parse_prefix()
-    }
-
-    fn add_psk_broker_request_from_suffix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddPskBrokerRequest>> {
-        self.zk_parse_suffix()
-    }
-
-    fn add_psk_broker_response_maker(self) -> RefMaker<Self, super::AddPskBrokerResponse> {
-        self.zk_ref_maker()
-    }
-
-    fn add_psk_broker_response(self) -> anyhow::Result<Ref<Self, super::AddPskBrokerResponse>> {
-        self.zk_parse()
-    }
-
-    fn add_psk_broker_response_from_prefix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddPskBrokerResponse>> {
-        self.zk_parse_prefix()
-    }
-
-    fn add_psk_broker_response_from_suffix(
-        self,
-    ) -> anyhow::Result<Ref<Self, super::AddPskBrokerResponse>> {
-        self.zk_parse_suffix()
-    }
-}
-
-impl<B: ByteSlice> ByteSliceRefExt for B {}
--- a/rosenpass/src/api/boilerplate/message_trait.rs
+++ b/rosenpass/src/api/boilerplate/message_trait.rs
@@ -1,29 +0,0 @@
-use zerocopy::{ByteSliceMut, Ref};
-
-use rosenpass_util::zerocopy::RefMaker;
-
-use super::RawMsgType;
-
-pub trait Message {
-    type Payload;
-    type MessageClass: Into<RawMsgType>;
-    const MESSAGE_TYPE: Self::MessageClass;
-
-    fn from_payload(payload: Self::Payload) -> Self;
-    fn init(&mut self);
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>>;
-}
-
-pub trait ZerocopyResponseMakerSetupMessageExt<B, T> {
-    fn setup_msg(self) -> anyhow::Result<Ref<B, T>>;
-}
-
-impl<B, T> ZerocopyResponseMakerSetupMessageExt<B, T> for RefMaker<B, T>
-where
-    B: ByteSliceMut,
-    T: Message,
-{
-    fn setup_msg(self) -> anyhow::Result<Ref<B, T>> {
-        T::setup(self.into_buf())
-    }
-}
--- a/rosenpass/src/api/boilerplate/message_type.rs
+++ b/rosenpass/src/api/boilerplate/message_type.rs
@@ -1,162 +0,0 @@
-use hex_literal::hex;
-use rosenpass_util::zerocopy::RefMaker;
-use zerocopy::ByteSlice;
-
-use crate::RosenpassError::{self, InvalidApiMessageType};
-
-pub type RawMsgType = u128;
-
-// constants generated by gen-ipc-msg-types:
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Ping Request
-pub const PING_REQUEST: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("2397 3ecc c441 704d    0b02 ea31 45d3 4999"));
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Ping Response
-pub const PING_RESPONSE: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("4ec7 f6f0 2bbc ba64    48f1 da14 c7cf 0260"));
-
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Supply Keypair Request
-const SUPPLY_KEYPAIR_REQUEST: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("ac91 a5a6 4f4b 21d0    ac7f 9b55 74f7 3529"));
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Supply Keypair Response
-const SUPPLY_KEYPAIR_RESPONSE: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("f2dc 49bd e261 5f10    40b7 3c16 ec61 edb9"));
-
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Add Listen Socket Request
-const ADD_LISTEN_SOCKET_REQUEST: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("3f21 434f 87cc a08c    02c4 61e4 0816 c7da"));
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Add Listen Socket Response
-const ADD_LISTEN_SOCKET_RESPONSE: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("45d5 0f0d 93f0 6105    98f2 9469 5dfd 5f36"));
-
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Add Psk Broker Request
-const ADD_PSK_BROKER_REQUEST: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("d798 b8dc bd61 5cab    8df1 c63d e4eb a2d1"));
-// hash domain hash of: Rosenpass IPC API -> Rosenpass Protocol Server -> Add Psk Broker Response
-const ADD_PSK_BROKER_RESPONSE: RawMsgType =
-    RawMsgType::from_le_bytes(hex!("bd25 e418 ffb0 6930    248b 217e 2fae e353"));
-
-pub trait MessageAttributes {
-    fn message_size(&self) -> usize;
-}
-
-#[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
-pub enum RequestMsgType {
-    Ping,
-    SupplyKeypair,
-    AddListenSocket,
-    AddPskBroker,
-}
-
-#[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)]
-pub enum ResponseMsgType {
-    Ping,
-    SupplyKeypair,
-    AddListenSocket,
-    AddPskBroker,
-}
-
-impl MessageAttributes for RequestMsgType {
-    fn message_size(&self) -> usize {
-        match self {
-            Self::Ping => std::mem::size_of::<super::PingRequest>(),
-            Self::SupplyKeypair => std::mem::size_of::<super::SupplyKeypairRequest>(),
-            Self::AddListenSocket => std::mem::size_of::<super::AddListenSocketRequest>(),
-            Self::AddPskBroker => std::mem::size_of::<super::AddPskBrokerRequest>(),
-        }
-    }
-}
-
-impl MessageAttributes for ResponseMsgType {
-    fn message_size(&self) -> usize {
-        match self {
-            Self::Ping => std::mem::size_of::<super::PingResponse>(),
-            Self::SupplyKeypair => std::mem::size_of::<super::SupplyKeypairResponse>(),
-            Self::AddListenSocket => std::mem::size_of::<super::AddListenSocketResponse>(),
-            Self::AddPskBroker => std::mem::size_of::<super::AddPskBrokerResponse>(),
-        }
-    }
-}
-
-impl TryFrom<RawMsgType> for RequestMsgType {
-    type Error = RosenpassError;
-
-    fn try_from(value: RawMsgType) -> Result<Self, Self::Error> {
-        use RequestMsgType as E;
-        Ok(match value {
-            self::PING_REQUEST => E::Ping,
-            self::SUPPLY_KEYPAIR_REQUEST => E::SupplyKeypair,
-            self::ADD_LISTEN_SOCKET_REQUEST => E::AddListenSocket,
-            self::ADD_PSK_BROKER_REQUEST => E::AddPskBroker,
-            _ => return Err(InvalidApiMessageType(value)),
-        })
-    }
-}
-
-impl From<RequestMsgType> for RawMsgType {
-    fn from(val: RequestMsgType) -> Self {
-        use RequestMsgType as E;
-        match val {
-            E::Ping => self::PING_REQUEST,
-            E::SupplyKeypair => self::SUPPLY_KEYPAIR_REQUEST,
-            E::AddListenSocket => self::ADD_LISTEN_SOCKET_REQUEST,
-            E::AddPskBroker => self::ADD_PSK_BROKER_REQUEST,
-        }
-    }
-}
-
-impl TryFrom<RawMsgType> for ResponseMsgType {
-    type Error = RosenpassError;
-
-    fn try_from(value: RawMsgType) -> Result<Self, Self::Error> {
-        use ResponseMsgType as E;
-        Ok(match value {
-            self::PING_RESPONSE => E::Ping,
-            self::SUPPLY_KEYPAIR_RESPONSE => E::SupplyKeypair,
-            self::ADD_LISTEN_SOCKET_RESPONSE => E::AddListenSocket,
-            self::ADD_PSK_BROKER_RESPONSE => E::AddPskBroker,
-            _ => return Err(InvalidApiMessageType(value)),
-        })
-    }
-}
-
-impl From<ResponseMsgType> for RawMsgType {
-    fn from(val: ResponseMsgType) -> Self {
-        use ResponseMsgType as E;
-        match val {
-            E::Ping => self::PING_RESPONSE,
-            E::SupplyKeypair => self::SUPPLY_KEYPAIR_RESPONSE,
-            E::AddListenSocket => self::ADD_LISTEN_SOCKET_RESPONSE,
-            E::AddPskBroker => self::ADD_PSK_BROKER_RESPONSE,
-        }
-    }
-}
-
-pub trait RawMsgTypeExt {
-    fn into_request_msg_type(self) -> Result<RequestMsgType, RosenpassError>;
-    fn into_response_msg_type(self) -> Result<ResponseMsgType, RosenpassError>;
-}
-
-impl RawMsgTypeExt for RawMsgType {
-    fn into_request_msg_type(self) -> Result<RequestMsgType, RosenpassError> {
-        self.try_into()
-    }
-
-    fn into_response_msg_type(self) -> Result<ResponseMsgType, RosenpassError> {
-        self.try_into()
-    }
-}
-
-pub trait RefMakerRawMsgTypeExt {
-    fn parse_request_msg_type(self) -> anyhow::Result<RequestMsgType>;
-    fn parse_response_msg_type(self) -> anyhow::Result<ResponseMsgType>;
-}
-
-impl<B: ByteSlice> RefMakerRawMsgTypeExt for RefMaker<B, RawMsgType> {
-    fn parse_request_msg_type(self) -> anyhow::Result<RequestMsgType> {
-        Ok(self.parse()?.read().try_into()?)
-    }
-
-    fn parse_response_msg_type(self) -> anyhow::Result<ResponseMsgType> {
-        Ok(self.parse()?.read().try_into()?)
-    }
-}
--- a/rosenpass/src/api/boilerplate/mod.rs
+++ b/rosenpass/src/api/boilerplate/mod.rs
@@ -1,17 +0,0 @@
-mod byte_slice_ext;
-mod message_trait;
-mod message_type;
-mod payload;
-mod request_ref;
-mod request_response;
-mod response_ref;
-mod server;
-
-pub use byte_slice_ext::*;
-pub use message_trait::*;
-pub use message_type::*;
-pub use payload::*;
-pub use request_ref::*;
-pub use request_response::*;
-pub use response_ref::*;
-pub use server::*;
--- a/rosenpass/src/api/boilerplate/payload.rs
+++ b/rosenpass/src/api/boilerplate/payload.rs
@@ -1,351 +0,0 @@
-use rosenpass_util::zerocopy::ZerocopyMutSliceExt;
-use zerocopy::{AsBytes, ByteSliceMut, FromBytes, FromZeroes, Ref};
-
-use super::{Message, RawMsgType, RequestMsgType, ResponseMsgType};
-
-/// Size required to fit any message in binary form
-pub const MAX_REQUEST_LEN: usize = 2500; // TODO fix this
-pub const MAX_RESPONSE_LEN: usize = 2500; // TODO fix this
-pub const MAX_REQUEST_FDS: usize = 2;
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct Envelope<M: AsBytes + FromBytes> {
-    /// Which message this is
-    pub msg_type: RawMsgType,
-    /// The actual Paylod
-    pub payload: M,
-}
-
-pub type RequestEnvelope<M> = Envelope<M>;
-pub type ResponseEnvelope<M> = Envelope<M>;
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct PingRequestPayload {
-    /// Randomly generated connection id
-    pub echo: [u8; 256],
-}
-
-pub type PingRequest = RequestEnvelope<PingRequestPayload>;
-
-impl PingRequest {
-    pub fn new(echo: [u8; 256]) -> Self {
-        Self::from_payload(PingRequestPayload { echo })
-    }
-}
-
-impl Message for PingRequest {
-    type Payload = PingRequestPayload;
-    type MessageClass = RequestMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = RequestMsgType::Ping;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct PingResponsePayload {
-    /// Randomly generated connection id
-    pub echo: [u8; 256],
-}
-
-pub type PingResponse = ResponseEnvelope<PingResponsePayload>;
-
-impl PingResponse {
-    pub fn new(echo: [u8; 256]) -> Self {
-        Self::from_payload(PingResponsePayload { echo })
-    }
-}
-
-impl Message for PingResponse {
-    type Payload = PingResponsePayload;
-    type MessageClass = ResponseMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = ResponseMsgType::Ping;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct SupplyKeypairRequestPayload {}
-
-pub type SupplyKeypairRequest = RequestEnvelope<SupplyKeypairRequestPayload>;
-
-impl Default for SupplyKeypairRequest {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl SupplyKeypairRequest {
-    pub fn new() -> Self {
-        Self::from_payload(SupplyKeypairRequestPayload {})
-    }
-}
-
-impl Message for SupplyKeypairRequest {
-    type Payload = SupplyKeypairRequestPayload;
-    type MessageClass = RequestMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = RequestMsgType::SupplyKeypair;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-pub mod supply_keypair_response_status {
-    pub const OK: u128 = 0;
-    pub const KEYPAIR_ALREADY_SUPPLIED: u128 = 1;
-    pub const INTERNAL_ERROR: u128 = 2;
-    pub const INVALID_REQUEST: u128 = 3;
-    pub const IO_ERROR: u128 = 4;
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct SupplyKeypairResponsePayload {
-    pub status: u128,
-}
-
-pub type SupplyKeypairResponse = ResponseEnvelope<SupplyKeypairResponsePayload>;
-
-impl SupplyKeypairResponse {
-    pub fn new(status: u128) -> Self {
-        Self::from_payload(SupplyKeypairResponsePayload { status })
-    }
-}
-
-impl Message for SupplyKeypairResponse {
-    type Payload = SupplyKeypairResponsePayload;
-    type MessageClass = ResponseMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = ResponseMsgType::SupplyKeypair;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct AddListenSocketRequestPayload {}
-
-pub type AddListenSocketRequest = RequestEnvelope<AddListenSocketRequestPayload>;
-
-impl Default for AddListenSocketRequest {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AddListenSocketRequest {
-    pub fn new() -> Self {
-        Self::from_payload(AddListenSocketRequestPayload {})
-    }
-}
-
-impl Message for AddListenSocketRequest {
-    type Payload = AddListenSocketRequestPayload;
-    type MessageClass = RequestMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = RequestMsgType::AddListenSocket;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-pub mod add_listen_socket_response_status {
-    pub const OK: u128 = 0;
-    pub const INVALID_REQUEST: u128 = 1;
-    pub const INTERNAL_ERROR: u128 = 2;
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct AddListenSocketResponsePayload {
-    pub status: u128,
-}
-
-pub type AddListenSocketResponse = ResponseEnvelope<AddListenSocketResponsePayload>;
-
-impl AddListenSocketResponse {
-    pub fn new(status: u128) -> Self {
-        Self::from_payload(AddListenSocketResponsePayload { status })
-    }
-}
-
-impl Message for AddListenSocketResponse {
-    type Payload = AddListenSocketResponsePayload;
-    type MessageClass = ResponseMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = ResponseMsgType::AddListenSocket;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct AddPskBrokerRequestPayload {}
-
-pub type AddPskBrokerRequest = RequestEnvelope<AddPskBrokerRequestPayload>;
-
-impl Default for AddPskBrokerRequest {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AddPskBrokerRequest {
-    pub fn new() -> Self {
-        Self::from_payload(AddPskBrokerRequestPayload {})
-    }
-}
-
-impl Message for AddPskBrokerRequest {
-    type Payload = AddPskBrokerRequestPayload;
-    type MessageClass = RequestMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = RequestMsgType::AddPskBroker;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
-
-pub mod add_psk_broker_response_status {
-    pub const OK: u128 = 0;
-    pub const INVALID_REQUEST: u128 = 1;
-    pub const INTERNAL_ERROR: u128 = 2;
-}
-
-#[repr(packed)]
-#[derive(Debug, Copy, Clone, Hash, AsBytes, FromBytes, FromZeroes, PartialEq, Eq)]
-pub struct AddPskBrokerResponsePayload {
-    pub status: u128,
-}
-
-pub type AddPskBrokerResponse = ResponseEnvelope<AddPskBrokerResponsePayload>;
-
-impl AddPskBrokerResponse {
-    pub fn new(status: u128) -> Self {
-        Self::from_payload(AddPskBrokerResponsePayload { status })
-    }
-}
-
-impl Message for AddPskBrokerResponse {
-    type Payload = AddPskBrokerResponsePayload;
-    type MessageClass = ResponseMsgType;
-    const MESSAGE_TYPE: Self::MessageClass = ResponseMsgType::AddPskBroker;
-
-    fn from_payload(payload: Self::Payload) -> Self {
-        Self {
-            msg_type: Self::MESSAGE_TYPE.into(),
-            payload,
-        }
-    }
-
-    fn setup<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self>> {
-        let mut r: Ref<B, Self> = buf.zk_zeroized()?;
-        r.init();
-        Ok(r)
-    }
-
-    fn init(&mut self) {
-        self.msg_type = Self::MESSAGE_TYPE.into();
-    }
-}
--- a/rosenpass/src/api/boilerplate/request_ref.rs
+++ b/rosenpass/src/api/boilerplate/request_ref.rs
@@ -1,146 +0,0 @@
-use anyhow::ensure;
-
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-
-use super::{ByteSliceRefExt, MessageAttributes, PingRequest, RequestMsgType};
-
-struct RequestRefMaker<B> {
-    buf: B,
-    msg_type: RequestMsgType,
-}
-
-impl<B: ByteSlice> RequestRef<B> {
-    pub fn parse(buf: B) -> anyhow::Result<Self> {
-        RequestRefMaker::new(buf)?.parse()
-    }
-
-    pub fn parse_from_prefix(buf: B) -> anyhow::Result<Self> {
-        RequestRefMaker::new(buf)?.from_prefix()?.parse()
-    }
-
-    pub fn parse_from_suffix(buf: B) -> anyhow::Result<Self> {
-        RequestRefMaker::new(buf)?.from_suffix()?.parse()
-    }
-
-    pub fn message_type(&self) -> RequestMsgType {
-        match self {
-            Self::Ping(_) => RequestMsgType::Ping,
-            Self::SupplyKeypair(_) => RequestMsgType::SupplyKeypair,
-            Self::AddListenSocket(_) => RequestMsgType::AddListenSocket,
-            Self::AddPskBroker(_) => RequestMsgType::AddPskBroker,
-        }
-    }
-}
-
-impl<B> From<Ref<B, PingRequest>> for RequestRef<B> {
-    fn from(v: Ref<B, PingRequest>) -> Self {
-        Self::Ping(v)
-    }
-}
-
-impl<B> From<Ref<B, super::SupplyKeypairRequest>> for RequestRef<B> {
-    fn from(v: Ref<B, super::SupplyKeypairRequest>) -> Self {
-        Self::SupplyKeypair(v)
-    }
-}
-
-impl<B> From<Ref<B, super::AddListenSocketRequest>> for RequestRef<B> {
-    fn from(v: Ref<B, super::AddListenSocketRequest>) -> Self {
-        Self::AddListenSocket(v)
-    }
-}
-
-impl<B> From<Ref<B, super::AddPskBrokerRequest>> for RequestRef<B> {
-    fn from(v: Ref<B, super::AddPskBrokerRequest>) -> Self {
-        Self::AddPskBroker(v)
-    }
-}
-
-impl<B: ByteSlice> RequestRefMaker<B> {
-    fn new(buf: B) -> anyhow::Result<Self> {
-        let msg_type = buf.deref().request_msg_type_from_prefix()?;
-        Ok(Self { buf, msg_type })
-    }
-
-    fn target_size(&self) -> usize {
-        self.msg_type.message_size()
-    }
-
-    fn parse(self) -> anyhow::Result<RequestRef<B>> {
-        Ok(match self.msg_type {
-            RequestMsgType::Ping => RequestRef::Ping(self.buf.ping_request()?),
-            RequestMsgType::SupplyKeypair => {
-                RequestRef::SupplyKeypair(self.buf.supply_keypair_request()?)
-            }
-            RequestMsgType::AddListenSocket => {
-                RequestRef::AddListenSocket(self.buf.add_listen_socket_request()?)
-            }
-            RequestMsgType::AddPskBroker => {
-                RequestRef::AddPskBroker(self.buf.add_psk_broker_request()?)
-            }
-        })
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    fn from_prefix(self) -> anyhow::Result<Self> {
-        self.ensure_fit()?;
-        let point = self.target_size();
-        let Self { buf, msg_type } = self;
-        let (buf, _) = buf.split_at(point);
-        Ok(Self { buf, msg_type })
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    fn from_suffix(self) -> anyhow::Result<Self> {
-        self.ensure_fit()?;
-        let point = self.buf.len() - self.target_size();
-        let Self { buf, msg_type } = self;
-        let (buf, _) = buf.split_at(point);
-        Ok(Self { buf, msg_type })
-    }
-
-    pub fn ensure_fit(&self) -> anyhow::Result<()> {
-        let have = self.buf.len();
-        let need = self.target_size();
-        ensure!(
-            need <= have,
-            "Buffer is undersized at {have} bytes (need {need} bytes)!"
-        );
-        Ok(())
-    }
-}
-
-pub enum RequestRef<B> {
-    Ping(Ref<B, PingRequest>),
-    SupplyKeypair(Ref<B, super::SupplyKeypairRequest>),
-    AddListenSocket(Ref<B, super::AddListenSocketRequest>),
-    AddPskBroker(Ref<B, super::AddPskBrokerRequest>),
-}
-
-impl<B> RequestRef<B>
-where
-    B: ByteSlice,
-{
-    pub fn bytes(&self) -> &[u8] {
-        match self {
-            Self::Ping(r) => r.bytes(),
-            Self::SupplyKeypair(r) => r.bytes(),
-            Self::AddListenSocket(r) => r.bytes(),
-            Self::AddPskBroker(r) => r.bytes(),
-        }
-    }
-}
-
-impl<B> RequestRef<B>
-where
-    B: ByteSliceMut,
-{
-    pub fn bytes_mut(&mut self) -> &[u8] {
-        match self {
-            Self::Ping(r) => r.bytes_mut(),
-            Self::SupplyKeypair(r) => r.bytes_mut(),
-            Self::AddListenSocket(r) => r.bytes_mut(),
-            Self::AddPskBroker(r) => r.bytes_mut(),
-        }
-    }
-}
--- a/rosenpass/src/api/boilerplate/request_response.rs
+++ b/rosenpass/src/api/boilerplate/request_response.rs
@@ -1,190 +0,0 @@
-use rosenpass_util::zerocopy::{
-    RefMaker, ZerocopyEmancipateExt, ZerocopyEmancipateMutExt, ZerocopySliceExt,
-};
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-
-use super::{Message, PingRequest, PingResponse};
-use super::{RequestRef, ResponseRef, ZerocopyResponseMakerSetupMessageExt};
-
-pub trait RequestMsg: Sized + Message {
-    type ResponseMsg: ResponseMsg;
-
-    fn zk_response_maker<B: ByteSlice>(buf: B) -> RefMaker<B, Self::ResponseMsg> {
-        buf.zk_ref_maker()
-    }
-
-    fn setup_response<B: ByteSliceMut>(buf: B) -> anyhow::Result<Ref<B, Self::ResponseMsg>> {
-        Self::zk_response_maker(buf).setup_msg()
-    }
-
-    fn setup_response_from_prefix<B: ByteSliceMut>(
-        buf: B,
-    ) -> anyhow::Result<Ref<B, Self::ResponseMsg>> {
-        Self::zk_response_maker(buf).from_prefix()?.setup_msg()
-    }
-
-    fn setup_response_from_suffix<B: ByteSliceMut>(
-        buf: B,
-    ) -> anyhow::Result<Ref<B, Self::ResponseMsg>> {
-        Self::zk_response_maker(buf).from_prefix()?.setup_msg()
-    }
-}
-
-pub trait ResponseMsg: Message {
-    type RequestMsg: RequestMsg;
-}
-
-impl RequestMsg for PingRequest {
-    type ResponseMsg = PingResponse;
-}
-
-impl ResponseMsg for PingResponse {
-    type RequestMsg = PingRequest;
-}
-
-impl RequestMsg for super::SupplyKeypairRequest {
-    type ResponseMsg = super::SupplyKeypairResponse;
-}
-
-impl ResponseMsg for super::SupplyKeypairResponse {
-    type RequestMsg = super::SupplyKeypairRequest;
-}
-
-impl RequestMsg for super::AddListenSocketRequest {
-    type ResponseMsg = super::AddListenSocketResponse;
-}
-
-impl ResponseMsg for super::AddListenSocketResponse {
-    type RequestMsg = super::AddListenSocketRequest;
-}
-
-impl RequestMsg for super::AddPskBrokerRequest {
-    type ResponseMsg = super::AddPskBrokerResponse;
-}
-
-impl ResponseMsg for super::AddPskBrokerResponse {
-    type RequestMsg = super::AddPskBrokerRequest;
-}
-
-pub type PingPair<B1, B2> = (Ref<B1, PingRequest>, Ref<B2, PingResponse>);
-pub type SupplyKeypairPair<B1, B2> = (
-    Ref<B1, super::SupplyKeypairRequest>,
-    Ref<B2, super::SupplyKeypairResponse>,
-);
-pub type AddListenSocketPair<B1, B2> = (
-    Ref<B1, super::AddListenSocketRequest>,
-    Ref<B2, super::AddListenSocketResponse>,
-);
-pub type AddPskBrokerPair<B1, B2> = (
-    Ref<B1, super::AddPskBrokerRequest>,
-    Ref<B2, super::AddPskBrokerResponse>,
-);
-
-pub enum RequestResponsePair<B1, B2> {
-    Ping(PingPair<B1, B2>),
-    SupplyKeypair(SupplyKeypairPair<B1, B2>),
-    AddListenSocket(AddListenSocketPair<B1, B2>),
-    AddPskBroker(AddPskBrokerPair<B1, B2>),
-}
-
-impl<B1, B2> From<PingPair<B1, B2>> for RequestResponsePair<B1, B2> {
-    fn from(v: PingPair<B1, B2>) -> Self {
-        RequestResponsePair::Ping(v)
-    }
-}
-
-impl<B1, B2> From<SupplyKeypairPair<B1, B2>> for RequestResponsePair<B1, B2> {
-    fn from(v: SupplyKeypairPair<B1, B2>) -> Self {
-        RequestResponsePair::SupplyKeypair(v)
-    }
-}
-
-impl<B1, B2> From<AddListenSocketPair<B1, B2>> for RequestResponsePair<B1, B2> {
-    fn from(v: AddListenSocketPair<B1, B2>) -> Self {
-        RequestResponsePair::AddListenSocket(v)
-    }
-}
-
-impl<B1, B2> From<AddPskBrokerPair<B1, B2>> for RequestResponsePair<B1, B2> {
-    fn from(v: AddPskBrokerPair<B1, B2>) -> Self {
-        RequestResponsePair::AddPskBroker(v)
-    }
-}
-
-impl<B1, B2> RequestResponsePair<B1, B2>
-where
-    B1: ByteSlice,
-    B2: ByteSlice,
-{
-    pub fn both(&self) -> (RequestRef<&[u8]>, ResponseRef<&[u8]>) {
-        match self {
-            Self::Ping((req, res)) => {
-                let req = RequestRef::Ping(req.emancipate());
-                let res = ResponseRef::Ping(res.emancipate());
-                (req, res)
-            }
-            Self::SupplyKeypair((req, res)) => {
-                let req = RequestRef::SupplyKeypair(req.emancipate());
-                let res = ResponseRef::SupplyKeypair(res.emancipate());
-                (req, res)
-            }
-            Self::AddListenSocket((req, res)) => {
-                let req = RequestRef::AddListenSocket(req.emancipate());
-                let res = ResponseRef::AddListenSocket(res.emancipate());
-                (req, res)
-            }
-            Self::AddPskBroker((req, res)) => {
-                let req = RequestRef::AddPskBroker(req.emancipate());
-                let res = ResponseRef::AddPskBroker(res.emancipate());
-                (req, res)
-            }
-        }
-    }
-
-    pub fn request(&self) -> RequestRef<&[u8]> {
-        self.both().0
-    }
-
-    pub fn response(&self) -> ResponseRef<&[u8]> {
-        self.both().1
-    }
-}
-
-impl<B1, B2> RequestResponsePair<B1, B2>
-where
-    B1: ByteSliceMut,
-    B2: ByteSliceMut,
-{
-    pub fn both_mut(&mut self) -> (RequestRef<&mut [u8]>, ResponseRef<&mut [u8]>) {
-        match self {
-            Self::Ping((req, res)) => {
-                let req = RequestRef::Ping(req.emancipate_mut());
-                let res = ResponseRef::Ping(res.emancipate_mut());
-                (req, res)
-            }
-            Self::SupplyKeypair((req, res)) => {
-                let req = RequestRef::SupplyKeypair(req.emancipate_mut());
-                let res = ResponseRef::SupplyKeypair(res.emancipate_mut());
-                (req, res)
-            }
-            Self::AddListenSocket((req, res)) => {
-                let req = RequestRef::AddListenSocket(req.emancipate_mut());
-                let res = ResponseRef::AddListenSocket(res.emancipate_mut());
-                (req, res)
-            }
-            Self::AddPskBroker((req, res)) => {
-                let req = RequestRef::AddPskBroker(req.emancipate_mut());
-                let res = ResponseRef::AddPskBroker(res.emancipate_mut());
-                (req, res)
-            }
-        }
-    }
-
-    pub fn request_mut(&mut self) -> RequestRef<&mut [u8]> {
-        self.both_mut().0
-    }
-
-    pub fn response_mut(&mut self) -> ResponseRef<&mut [u8]> {
-        self.both_mut().1
-    }
-}
--- a/rosenpass/src/api/boilerplate/response_ref.rs
+++ b/rosenpass/src/api/boilerplate/response_ref.rs
@@ -1,147 +0,0 @@
-// TODO: This is copied verbatim from ResponseRef…not pretty
-use anyhow::ensure;
-
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-
-use super::{ByteSliceRefExt, MessageAttributes, PingResponse, ResponseMsgType};
-
-struct ResponseRefMaker<B> {
-    buf: B,
-    msg_type: ResponseMsgType,
-}
-
-impl<B: ByteSlice> ResponseRef<B> {
-    pub fn parse(buf: B) -> anyhow::Result<Self> {
-        ResponseRefMaker::new(buf)?.parse()
-    }
-
-    pub fn parse_from_prefix(buf: B) -> anyhow::Result<Self> {
-        ResponseRefMaker::new(buf)?.from_prefix()?.parse()
-    }
-
-    pub fn parse_from_suffix(buf: B) -> anyhow::Result<Self> {
-        ResponseRefMaker::new(buf)?.from_suffix()?.parse()
-    }
-
-    pub fn message_type(&self) -> ResponseMsgType {
-        match self {
-            Self::Ping(_) => ResponseMsgType::Ping,
-            Self::SupplyKeypair(_) => ResponseMsgType::SupplyKeypair,
-            Self::AddListenSocket(_) => ResponseMsgType::AddListenSocket,
-            Self::AddPskBroker(_) => ResponseMsgType::AddPskBroker,
-        }
-    }
-}
-
-impl<B> From<Ref<B, PingResponse>> for ResponseRef<B> {
-    fn from(v: Ref<B, PingResponse>) -> Self {
-        Self::Ping(v)
-    }
-}
-
-impl<B> From<Ref<B, super::SupplyKeypairResponse>> for ResponseRef<B> {
-    fn from(v: Ref<B, super::SupplyKeypairResponse>) -> Self {
-        Self::SupplyKeypair(v)
-    }
-}
-
-impl<B> From<Ref<B, super::AddListenSocketResponse>> for ResponseRef<B> {
-    fn from(v: Ref<B, super::AddListenSocketResponse>) -> Self {
-        Self::AddListenSocket(v)
-    }
-}
-
-impl<B> From<Ref<B, super::AddPskBrokerResponse>> for ResponseRef<B> {
-    fn from(v: Ref<B, super::AddPskBrokerResponse>) -> Self {
-        Self::AddPskBroker(v)
-    }
-}
-
-impl<B: ByteSlice> ResponseRefMaker<B> {
-    fn new(buf: B) -> anyhow::Result<Self> {
-        let msg_type = buf.deref().response_msg_type_from_prefix()?;
-        Ok(Self { buf, msg_type })
-    }
-
-    fn target_size(&self) -> usize {
-        self.msg_type.message_size()
-    }
-
-    fn parse(self) -> anyhow::Result<ResponseRef<B>> {
-        Ok(match self.msg_type {
-            ResponseMsgType::Ping => ResponseRef::Ping(self.buf.ping_response()?),
-            ResponseMsgType::SupplyKeypair => {
-                ResponseRef::SupplyKeypair(self.buf.supply_keypair_response()?)
-            }
-            ResponseMsgType::AddListenSocket => {
-                ResponseRef::AddListenSocket(self.buf.add_listen_socket_response()?)
-            }
-            ResponseMsgType::AddPskBroker => {
-                ResponseRef::AddPskBroker(self.buf.add_psk_broker_response()?)
-            }
-        })
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    fn from_prefix(self) -> anyhow::Result<Self> {
-        self.ensure_fit()?;
-        let point = self.target_size();
-        let Self { buf, msg_type } = self;
-        let (buf, _) = buf.split_at(point);
-        Ok(Self { buf, msg_type })
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    fn from_suffix(self) -> anyhow::Result<Self> {
-        self.ensure_fit()?;
-        let point = self.buf.len() - self.target_size();
-        let Self { buf, msg_type } = self;
-        let (buf, _) = buf.split_at(point);
-        Ok(Self { buf, msg_type })
-    }
-
-    pub fn ensure_fit(&self) -> anyhow::Result<()> {
-        let have = self.buf.len();
-        let need = self.target_size();
-        ensure!(
-            need <= have,
-            "Buffer is undersized at {have} bytes (need {need} bytes)!"
-        );
-        Ok(())
-    }
-}
-
-pub enum ResponseRef<B> {
-    Ping(Ref<B, PingResponse>),
-    SupplyKeypair(Ref<B, super::SupplyKeypairResponse>),
-    AddListenSocket(Ref<B, super::AddListenSocketResponse>),
-    AddPskBroker(Ref<B, super::AddPskBrokerResponse>),
-}
-
-impl<B> ResponseRef<B>
-where
-    B: ByteSlice,
-{
-    pub fn bytes(&self) -> &[u8] {
-        match self {
-            Self::Ping(r) => r.bytes(),
-            Self::SupplyKeypair(r) => r.bytes(),
-            Self::AddListenSocket(r) => r.bytes(),
-            Self::AddPskBroker(r) => r.bytes(),
-        }
-    }
-}
-
-impl<B> ResponseRef<B>
-where
-    B: ByteSliceMut,
-{
-    pub fn bytes_mut(&mut self) -> &[u8] {
-        match self {
-            Self::Ping(r) => r.bytes_mut(),
-            Self::SupplyKeypair(r) => r.bytes_mut(),
-            Self::AddListenSocket(r) => r.bytes_mut(),
-            Self::AddPskBroker(r) => r.bytes_mut(),
-        }
-    }
-}
--- a/rosenpass/src/api/boilerplate/server.rs
+++ b/rosenpass/src/api/boilerplate/server.rs
@@ -1,94 +0,0 @@
-use super::{ByteSliceRefExt, Message, PingRequest, PingResponse, RequestRef, RequestResponsePair};
-use std::{collections::VecDeque, os::fd::OwnedFd};
-use zerocopy::{ByteSlice, ByteSliceMut};
-
-pub trait Server {
-    fn ping(
-        &mut self,
-        req: &PingRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut PingResponse,
-    ) -> anyhow::Result<()>;
-
-    fn supply_keypair(
-        &mut self,
-        req: &super::SupplyKeypairRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::SupplyKeypairResponse,
-    ) -> anyhow::Result<()>;
-
-    fn add_listen_socket(
-        &mut self,
-        req: &super::AddListenSocketRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::AddListenSocketResponse,
-    ) -> anyhow::Result<()>;
-
-    fn add_psk_broker(
-        &mut self,
-        req: &super::AddPskBrokerRequest,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: &mut super::AddPskBrokerResponse,
-    ) -> anyhow::Result<()>;
-
-    fn dispatch<ReqBuf, ResBuf>(
-        &mut self,
-        p: &mut RequestResponsePair<ReqBuf, ResBuf>,
-        req_fds: &mut VecDeque<OwnedFd>,
-    ) -> anyhow::Result<()>
-    where
-        ReqBuf: ByteSlice,
-        ResBuf: ByteSliceMut,
-    {
-        match p {
-            RequestResponsePair::Ping((req, res)) => self.ping(req, req_fds, res),
-            RequestResponsePair::SupplyKeypair((req, res)) => {
-                self.supply_keypair(req, req_fds, res)
-            }
-            RequestResponsePair::AddListenSocket((req, res)) => {
-                self.add_listen_socket(req, req_fds, res)
-            }
-            RequestResponsePair::AddPskBroker((req, res)) => self.add_psk_broker(req, req_fds, res),
-        }
-    }
-
-    fn handle_message<ReqBuf, ResBuf>(
-        &mut self,
-        req: ReqBuf,
-        req_fds: &mut VecDeque<OwnedFd>,
-        res: ResBuf,
-    ) -> anyhow::Result<usize>
-    where
-        ReqBuf: ByteSlice,
-        ResBuf: ByteSliceMut,
-    {
-        let req = req.parse_request_from_prefix()?;
-        // TODO: This is not pretty; This match should be moved into RequestRef
-        let mut pair = match req {
-            RequestRef::Ping(req) => {
-                let mut res = res.ping_response_from_prefix()?;
-                res.init();
-                RequestResponsePair::Ping((req, res))
-            }
-            RequestRef::SupplyKeypair(req) => {
-                let mut res = res.supply_keypair_response_from_prefix()?;
-                res.init();
-                RequestResponsePair::SupplyKeypair((req, res))
-            }
-            RequestRef::AddListenSocket(req) => {
-                let mut res = res.add_listen_socket_response_from_prefix()?;
-                res.init();
-                RequestResponsePair::AddListenSocket((req, res))
-            }
-            RequestRef::AddPskBroker(req) => {
-                let mut res = res.add_psk_broker_response_from_prefix()?;
-                res.init();
-                RequestResponsePair::AddPskBroker((req, res))
-            }
-        };
-        self.dispatch(&mut pair, req_fds)?;
-
-        let res_len = pair.response().bytes().len();
-        Ok(res_len)
-    }
-}
--- a/rosenpass/src/api/cli.rs
+++ b/rosenpass/src/api/cli.rs
@@ -1,40 +0,0 @@
-use std::path::PathBuf;
-
-use clap::Args;
-
-use crate::config::Rosenpass as RosenpassConfig;
-
-use super::config::ApiConfig;
-
-#[cfg(feature = "experiment_api")]
-#[derive(Args, Debug)]
-pub struct ApiCli {
-    /// Where in the file-system to create the unix socket the rosenpass API will be listening for
-    /// connections on.
-    #[arg(long)]
-    api_listen_path: Vec<PathBuf>,
-
-    /// When rosenpass is called from another process, the other process can open and bind the
-    /// unix socket for the Rosenpass API to use themselves, passing it to this process. In Rust this can be achieved
-    /// using the [command-fds](https://docs.rs/command-fds/latest/command_fds/) crate.
-    #[arg(long)]
-    api_listen_fd: Vec<i32>,
-
-    /// When rosenpass is called from another process, the other process can connect the unix socket for the API
-    /// themselves, for instance using the `socketpair(2)` system call.
-    #[arg(long)]
-    api_stream_fd: Vec<i32>,
-}
-
-impl ApiCli {
-    pub fn apply_to_config(&self, cfg: &mut RosenpassConfig) -> anyhow::Result<()> {
-        self.apply_to_api_config(&mut cfg.api)
-    }
-
-    pub fn apply_to_api_config(&self, cfg: &mut ApiConfig) -> anyhow::Result<()> {
-        cfg.listen_path.extend_from_slice(&self.api_listen_path);
-        cfg.listen_fd.extend_from_slice(&self.api_listen_fd);
-        cfg.stream_fd.extend_from_slice(&self.api_stream_fd);
-        Ok(())
-    }
-}
--- a/rosenpass/src/api/config.rs
+++ b/rosenpass/src/api/config.rs
@@ -1,49 +0,0 @@
-use std::path::PathBuf;
-
-use mio::net::UnixListener;
-use rosenpass_util::mio::{UnixListenerExt, UnixStreamExt};
-use serde::{Deserialize, Serialize};
-
-use crate::app_server::AppServer;
-
-#[derive(Debug, Serialize, Deserialize, Default, Clone)]
-pub struct ApiConfig {
-    /// Where in the file-system to create the unix socket the rosenpass API will be listening for
-    /// connections on
-    pub listen_path: Vec<PathBuf>,
-
-    /// When rosenpass is called from another process, the other process can open and bind the
-    /// unix socket for the Rosenpass API to use themselves, passing it to this process. In Rust this can be achieved
-    /// using the [command-fds](https://docs.rs/command-fds/latest/command_fds/) crate.
-    pub listen_fd: Vec<i32>,
-
-    /// When rosenpass is called from another process, the other process can connect the unix socket for the API
-    /// themselves, for instance using the `socketpair(2)` system call.
-    pub stream_fd: Vec<i32>,
-}
-
-impl ApiConfig {
-    pub fn apply_to_app_server(&self, srv: &mut AppServer) -> anyhow::Result<()> {
-        for path in self.listen_path.iter() {
-            srv.add_api_listener(UnixListener::bind(path)?)?;
-        }
-
-        for fd in self.listen_fd.iter() {
-            srv.add_api_listener(UnixListenerExt::claim_fd(*fd)?)?;
-        }
-
-        for fd in self.stream_fd.iter() {
-            srv.add_api_connection(UnixStreamExt::claim_fd(*fd)?)?;
-        }
-
-        Ok(())
-    }
-
-    pub fn count_api_sources(&self) -> usize {
-        self.listen_path.len() + self.listen_fd.len() + self.stream_fd.len()
-    }
-
-    pub fn has_api_sources(&self) -> bool {
-        self.count_api_sources() > 0
-    }
-}
--- a/rosenpass/src/api/mio/connection.rs
+++ b/rosenpass/src/api/mio/connection.rs
@@ -1,321 +0,0 @@
-use std::borrow::{Borrow, BorrowMut};
-use std::collections::VecDeque;
-use std::os::fd::OwnedFd;
-
-use mio::net::UnixStream;
-use rosenpass_secret_memory::Secret;
-use rosenpass_util::mio::ReadWithFileDescriptors;
-use rosenpass_util::{
-    io::{IoResultKindHintExt, TryIoResultKindHintExt},
-    length_prefix_encoding::{
-        decoder::{self as lpe_decoder, LengthPrefixDecoder},
-        encoder::{self as lpe_encoder, LengthPrefixEncoder},
-    },
-    mio::interest::RW as MIO_RW,
-};
-use zeroize::Zeroize;
-
-use crate::api::MAX_REQUEST_FDS;
-use crate::{api::Server, app_server::AppServer};
-
-use super::super::{ApiHandler, ApiHandlerContext};
-
-#[derive(Debug)]
-struct SecretBuffer<const N: usize>(pub Secret<N>);
-
-impl<const N: usize> SecretBuffer<N> {
-    fn new() -> Self {
-        Self(Secret::zero())
-    }
-}
-
-impl<const N: usize> Borrow<[u8]> for SecretBuffer<N> {
-    fn borrow(&self) -> &[u8] {
-        self.0.secret()
-    }
-}
-
-impl<const N: usize> BorrowMut<[u8]> for SecretBuffer<N> {
-    fn borrow_mut(&mut self) -> &mut [u8] {
-        self.0.secret_mut()
-    }
-}
-// TODO: Unfortunately, zerocopy is quite particular about alignment, hence the 4096
-type ReadBuffer = LengthPrefixDecoder<SecretBuffer<4096>>;
-type WriteBuffer = LengthPrefixEncoder<SecretBuffer<4096>>;
-type ReadFdBuffer = VecDeque<OwnedFd>;
-
-#[derive(Debug)]
-struct MioConnectionBuffers {
-    read_buffer: ReadBuffer,
-    write_buffer: WriteBuffer,
-    read_fd_buffer: ReadFdBuffer,
-}
-
-#[derive(Debug)]
-pub struct MioConnection {
-    io: UnixStream,
-    mio_token: mio::Token,
-    invalid_read: bool,
-    buffers: Option<MioConnectionBuffers>,
-    api_handler: ApiHandler,
-}
-
-impl MioConnection {
-    pub fn new(app_server: &mut AppServer, mut io: UnixStream) -> std::io::Result<Self> {
-        let mio_token = app_server.mio_token_dispenser.dispense();
-        app_server
-            .mio_poll
-            .registry()
-            .register(&mut io, mio_token, MIO_RW)?;
-
-        let invalid_read = false;
-        let read_buffer = LengthPrefixDecoder::new(SecretBuffer::new());
-        let write_buffer = LengthPrefixEncoder::from_buffer(SecretBuffer::new());
-        let read_fd_buffer = VecDeque::new();
-        let buffers = Some(MioConnectionBuffers {
-            read_buffer,
-            write_buffer,
-            read_fd_buffer,
-        });
-        let api_state = ApiHandler::new();
-        Ok(Self {
-            io,
-            mio_token,
-            invalid_read,
-            buffers,
-            api_handler: api_state,
-        })
-    }
-
-    pub fn shoud_close(&self) -> bool {
-        let exhausted = self
-            .buffers
-            .as_ref()
-            .map(|b| b.write_buffer.exhausted())
-            .unwrap_or(false);
-        self.invalid_read && exhausted
-    }
-
-    pub fn close(mut self, app_server: &mut AppServer) -> anyhow::Result<()> {
-        app_server.mio_poll.registry().deregister(&mut self.io)?;
-        Ok(())
-    }
-
-    pub fn mio_token(&self) -> mio::Token {
-        self.mio_token
-    }
-}
-
-pub trait MioConnectionContext {
-    fn mio_connection(&self) -> &MioConnection;
-    fn app_server(&self) -> &AppServer;
-    fn mio_connection_mut(&mut self) -> &mut MioConnection;
-    fn app_server_mut(&mut self) -> &mut AppServer;
-
-    fn poll(&mut self) -> anyhow::Result<()> {
-        macro_rules! short {
-            ($e:expr) => {
-                match $e {
-                    None => return Ok(()),
-                    Some(()) => {}
-                }
-            };
-        }
-
-        // All of these functions return an error, None ("operation incomplete")
-        // or some ("operation complete, keep processing")
-        short!(self.flush_write_buffer()?); // Flush last message
-        short!(self.recv()?); // Receive new message
-        short!(self.handle_incoming_message()?); // Process new message with API
-        short!(self.flush_write_buffer()?); // Begin flushing response
-
-        Ok(())
-    }
-
-    fn handle_incoming_message(&mut self) -> anyhow::Result<Option<()>> {
-        self.with_buffers_stolen(|this, bufs| {
-            // Acquire request & response. Caller is responsible to make sure
-            // that read buffer holds a message and that write buffer is cleared.
-            // Hence the unwraps and assertions
-            assert!(bufs.write_buffer.exhausted());
-            let req = bufs.read_buffer.message().unwrap().unwrap();
-            let req_fds = &mut bufs.read_fd_buffer;
-            let res = bufs.write_buffer.buffer_bytes_mut();
-
-            // Call API handler
-            // Transitive trait implementations: MioConnectionContext -> ApiHandlerContext -> as ApiServer
-            let response_len = this.handle_message(req, req_fds, res)?;
-
-            bufs.write_buffer
-                .restart_write_with_new_message(response_len)?;
-            bufs.read_buffer.zeroize(); // clear for new message to read
-            bufs.read_fd_buffer.clear();
-
-            Ok(Some(()))
-        })
-    }
-
-    fn flush_write_buffer(&mut self) -> anyhow::Result<Option<()>> {
-        if self.write_buf_mut().exhausted() {
-            return Ok(Some(()));
-        }
-
-        use lpe_encoder::WriteToIoReturn as Ret;
-        use std::io::ErrorKind as K;
-
-        loop {
-            let conn = self.mio_connection_mut();
-            let bufs = conn.buffers.as_mut().unwrap();
-
-            let sock = &conn.io;
-            let write_buf = &mut bufs.write_buffer;
-
-            match write_buf.write_to_stdio(sock).io_err_kind_hint() {
-                // Done
-                Ok(Ret { done: true, .. }) => {
-                    write_buf.zeroize(); // clear for new message to write
-                    break Ok(Some(()));
-                }
-
-                // Would block
-                Ok(Ret {
-                    bytes_written: 0, ..
-                }) => break Ok(None),
-                Err((_e, K::WouldBlock)) => break Ok(None),
-
-                // Just continue
-                Ok(_) => continue, /* Ret { bytes_written > 0, done = false } acc. to previous cases*/
-                Err((_e, K::Interrupted)) => continue,
-
-                // Other errors
-                Err((e, _ek)) => Err(e)?,
-            }
-        }
-    }
-
-    fn recv(&mut self) -> anyhow::Result<Option<()>> {
-        if !self.write_buf_mut().exhausted() || self.mio_connection().invalid_read {
-            return Ok(None);
-        }
-
-        use lpe_decoder::{ReadFromIoError as E, ReadFromIoReturn as Ret};
-        use std::io::ErrorKind as K;
-
-        loop {
-            let conn = self.mio_connection_mut();
-            let bufs = conn.buffers.as_mut().unwrap();
-
-            let read_buf = &mut bufs.read_buffer;
-            let read_fd_buf = &mut bufs.read_fd_buffer;
-
-            let sock = &conn.io;
-            let fd_passing_sock = ReadWithFileDescriptors::<MAX_REQUEST_FDS, UnixStream, _, _>::new(
-                sock,
-                read_fd_buf,
-            );
-
-            match read_buf
-                .read_from_stdio(fd_passing_sock)
-                .try_io_err_kind_hint()
-            {
-                // We actually received a proper message
-                // (Impl below match to appease borrow checker)
-                Ok(Ret {
-                    message: Some(_msg),
-                    ..
-                }) => break Ok(Some(())),
-
-                // Message does not fit in buffer
-                Err((e @ E::MessageTooLargeError { .. }, _)) => {
-                    log::warn!("Received message on API that was too big to fit in our buffers; \
-                            looks like the client is broken. Stopping to process messages of the client.\n\
-                            Error: {e:?}");
-                    conn.invalid_read = true; // Closed mio_manager
-                    break Ok(None);
-                }
-
-                // Would block
-                Ok(Ret { bytes_read: 0, .. }) => break Ok(None),
-                Err((_, Some(K::WouldBlock))) => break Ok(None),
-
-                // Just keep going
-                Ok(Ret { bytes_read: _, .. }) => continue,
-                Err((_, Some(K::Interrupted))) => continue,
-
-                // Other IO Error (just pass on to the caller)
-                Err((E::IoError(e), _)) => {
-                    log::warn!(
-                        "IO error while trying to read message from API socket. \
-                            The connection is broken. Stopping to process messages of the client.\n\
-                            Error: {e:?}"
-                    );
-                    conn.invalid_read = true; // closed later by mio_manager
-                    break Err(e.into());
-                }
-            };
-        }
-    }
-
-    fn mio_token(&self) -> mio::Token {
-        self.mio_connection().mio_token()
-    }
-
-    fn should_close(&self) -> bool {
-        self.mio_connection().shoud_close()
-    }
-}
-
-trait MioConnectionContextPrivate: MioConnectionContext {
-    fn steal_buffers(&mut self) -> MioConnectionBuffers {
-        self.mio_connection_mut().buffers.take().unwrap()
-    }
-
-    fn return_buffers(&mut self, buffers: MioConnectionBuffers) {
-        let opt = &mut self.mio_connection_mut().buffers;
-        assert!(opt.is_none());
-        let _ = opt.insert(buffers);
-    }
-
-    fn with_buffers_stolen<R, F: FnOnce(&mut Self, &mut MioConnectionBuffers) -> R>(
-        &mut self,
-        f: F,
-    ) -> R {
-        let mut bufs = self.steal_buffers();
-        let res = f(self, &mut bufs);
-        self.return_buffers(bufs);
-        res
-    }
-
-    fn write_buf_mut(&mut self) -> &mut WriteBuffer {
-        self.mio_connection_mut()
-            .buffers
-            .as_mut()
-            .unwrap()
-            .write_buffer
-            .borrow_mut()
-    }
-}
-
-impl<T> MioConnectionContextPrivate for T where T: ?Sized + MioConnectionContext {}
-
-impl<T> ApiHandlerContext for T
-where
-    T: ?Sized + MioConnectionContext,
-{
-    fn api_handler(&self) -> &ApiHandler {
-        &self.mio_connection().api_handler
-    }
-
-    fn app_server(&self) -> &AppServer {
-        MioConnectionContext::app_server(self)
-    }
-
-    fn api_handler_mut(&mut self) -> &mut ApiHandler {
-        &mut self.mio_connection_mut().api_handler
-    }
-
-    fn app_server_mut(&mut self) -> &mut AppServer {
-        MioConnectionContext::app_server_mut(self)
-    }
-}
--- a/rosenpass/src/api/mio/manager.rs
+++ b/rosenpass/src/api/mio/manager.rs
@@ -1,173 +0,0 @@
-use std::{borrow::BorrowMut, io};
-
-use mio::net::{UnixListener, UnixStream};
-
-use rosenpass_util::{
-    functional::ApplyExt, io::nonblocking_handle_io_errors, mio::interest::RW as MIO_RW,
-};
-
-use crate::app_server::{AppServer, AppServerIoSource};
-
-use super::{MioConnection, MioConnectionContext};
-
-#[derive(Default, Debug)]
-pub struct MioManager {
-    listeners: Vec<UnixListener>,
-    connections: Vec<Option<MioConnection>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum MioManagerIoSource {
-    Listener(usize),
-    Connection(usize),
-}
-
-impl MioManager {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-struct MioConnectionFocus<'a, T: ?Sized + MioManagerContext> {
-    ctx: &'a mut T,
-    conn_idx: usize,
-}
-
-impl<'a, T: ?Sized + MioManagerContext> MioConnectionFocus<'a, T> {
-    fn new(ctx: &'a mut T, conn_idx: usize) -> Self {
-        Self { ctx, conn_idx }
-    }
-}
-
-pub trait MioManagerContext {
-    fn mio_manager(&self) -> &MioManager;
-    fn mio_manager_mut(&mut self) -> &mut MioManager;
-    fn app_server(&self) -> &AppServer;
-    fn app_server_mut(&mut self) -> &mut AppServer;
-
-    fn add_listener(&mut self, mut listener: UnixListener) -> io::Result<()> {
-        let srv = self.app_server_mut();
-        let mio_token = srv.mio_token_dispenser.dispense();
-        srv.mio_poll
-            .registry()
-            .register(&mut listener, mio_token, MIO_RW)?;
-        let io_source = self
-            .mio_manager()
-            .listeners
-            .len()
-            .apply(MioManagerIoSource::Listener)
-            .apply(AppServerIoSource::MioManager);
-        self.mio_manager_mut().listeners.push(listener);
-        self.app_server_mut()
-            .register_io_source(mio_token, io_source);
-
-        Ok(())
-    }
-
-    fn add_connection(&mut self, connection: UnixStream) -> io::Result<()> {
-        let connection = MioConnection::new(self.app_server_mut(), connection)?;
-        let mio_token = connection.mio_token();
-        let conns: &mut Vec<Option<MioConnection>> =
-            self.mio_manager_mut().connections.borrow_mut();
-        let idx = conns
-            .iter_mut()
-            .enumerate()
-            .find(|(_, slot)| slot.is_some())
-            .map(|(idx, _)| idx)
-            .unwrap_or(conns.len());
-        conns.insert(idx, Some(connection));
-        let io_source = idx
-            .apply(MioManagerIoSource::Listener)
-            .apply(AppServerIoSource::MioManager);
-        self.app_server_mut()
-            .register_io_source(mio_token, io_source);
-        Ok(())
-    }
-
-    fn poll_particular(&mut self, io_source: MioManagerIoSource) -> anyhow::Result<()> {
-        use MioManagerIoSource as S;
-        match io_source {
-            S::Listener(idx) => self.accept_from(idx)?,
-            S::Connection(idx) => self.poll_particular_connection(idx)?,
-        };
-        Ok(())
-    }
-
-    fn poll(&mut self) -> anyhow::Result<()> {
-        self.accept_connections()?;
-        self.poll_connections()?;
-        Ok(())
-    }
-
-    fn accept_connections(&mut self) -> io::Result<()> {
-        for idx in 0..self.mio_manager_mut().listeners.len() {
-            self.accept_from(idx)?;
-        }
-        Ok(())
-    }
-
-    fn accept_from(&mut self, idx: usize) -> io::Result<()> {
-        // Accept connection until the socket would block or returns another error
-        // TODO: This currently only adds connections--we eventually need the ability to remove
-        // them as well, see the note in connection.rs
-        loop {
-            match nonblocking_handle_io_errors(|| self.mio_manager().listeners[idx].accept())? {
-                None => break,
-                Some((conn, _addr)) => {
-                    self.add_connection(conn)?;
-                }
-            };
-        }
-
-        Ok(())
-    }
-
-    fn poll_connections(&mut self) -> anyhow::Result<()> {
-        for idx in 0..self.mio_manager().connections.len() {
-            self.poll_particular_connection(idx)?;
-        }
-        Ok(())
-    }
-
-    fn poll_particular_connection(&mut self, idx: usize) -> anyhow::Result<()> {
-        if self.mio_manager().connections[idx].is_none() {
-            return Ok(());
-        }
-
-        let mut conn = MioConnectionFocus::new(self, idx);
-        conn.poll()?;
-
-        if conn.should_close() {
-            let conn = self.mio_manager_mut().connections[idx].take().unwrap();
-            let mio_token = conn.mio_token();
-            if let Err(e) = conn.close(self.app_server_mut()) {
-                log::warn!("Error while closing API connection {e:?}");
-            };
-            self.app_server_mut().unregister_io_source(mio_token);
-        }
-
-        Ok(())
-    }
-}
-
-impl<T: ?Sized + MioManagerContext> MioConnectionContext for MioConnectionFocus<'_, T> {
-    fn mio_connection(&self) -> &MioConnection {
-        self.ctx.mio_manager().connections[self.conn_idx]
-            .as_ref()
-            .unwrap()
-    }
-
-    fn app_server(&self) -> &AppServer {
-        self.ctx.app_server()
-    }
-
-    fn mio_connection_mut(&mut self) -> &mut MioConnection {
-        self.ctx.mio_manager_mut().connections[self.conn_idx]
-            .as_mut()
-            .unwrap()
-    }
-
-    fn app_server_mut(&mut self) -> &mut AppServer {
-        self.ctx.app_server_mut()
-    }
-}
--- a/rosenpass/src/api/mio/mod.rs
+++ b/rosenpass/src/api/mio/mod.rs
@@ -1,5 +0,0 @@
-mod connection;
-mod manager;
-
-pub use connection::*;
-pub use manager::*;
--- a/rosenpass/src/api/mod.rs
+++ b/rosenpass/src/api/mod.rs
@@ -1,9 +0,0 @@
-mod api_handler;
-mod boilerplate;
-
-pub use api_handler::*;
-pub use boilerplate::*;
-
-pub mod cli;
-pub mod config;
-pub mod mio;
--- a/rosenpass/src/app_server.rs
+++ b/rosenpass/src/app_server.rs
@@ -1,6 +1,5 @@
 use anyhow::bail;

-use anyhow::Context;
 use anyhow::Result;
 use derive_builder::Builder;
 use log::{error, info, warn};
@@ -8,14 +7,7 @@ use mio::Interest;
 use mio::Token;
 use rosenpass_secret_memory::Public;
 use rosenpass_secret_memory::Secret;
-use rosenpass_util::build::ConstructionSite;
 use rosenpass_util::file::StoreValueB64;
-use rosenpass_util::functional::run;
-use rosenpass_util::functional::ApplyExt;
-use rosenpass_util::io::IoResultKindHintExt;
-use rosenpass_util::io::SubstituteForIoErrorKindExt;
-use rosenpass_util::option::SomeExt;
-use rosenpass_util::result::OkExt;
 use rosenpass_wireguard_broker::WireguardBrokerMio;
 use rosenpass_wireguard_broker::{WireguardBrokerCfg, WG_KEY_LEN};
 use zerocopy::AsBytes;
@@ -23,12 +15,8 @@ use zerocopy::AsBytes;
 use std::cell::Cell;

 use std::collections::HashMap;
-use std::collections::VecDeque;
 use std::fmt::Debug;
-use std::io;
-use std::io::stdout;
 use std::io::ErrorKind;
-use std::io::Write;
 use std::net::Ipv4Addr;
 use std::net::Ipv6Addr;
 use std::net::SocketAddr;
@@ -40,7 +28,6 @@ use std::slice;
 use std::time::Duration;
 use std::time::Instant;

-use crate::protocol::BuildCryptoServer;
 use crate::protocol::HostIdentification;
 use crate::{
    config::Verbosity,
@@ -76,7 +63,7 @@ pub struct MioTokenDispenser {
 }

 impl MioTokenDispenser {
-    pub fn dispense(&mut self) -> Token {
+    fn dispense(&mut self) -> Token {
        let r = self.counter;
        self.counter += 1;
        Token(r)
@@ -85,7 +72,7 @@ impl MioTokenDispenser {

 #[derive(Debug, Default)]
 pub struct BrokerStore {
-    pub store: HashMap<
+    store: HashMap<
        Public<BROKER_ID_BYTES>,
        Box<dyn WireguardBrokerMio<Error = anyhow::Error, MioError = anyhow::Error>>,
    >,
@@ -151,29 +138,15 @@ pub struct AppServerTest {
    pub termination_handler: Option<std::sync::mpsc::Receiver<()>>,
 }

-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum AppServerIoSource {
-    Socket(usize),
-    #[cfg(feature = "experiment_api")]
-    PskBroker(Public<BROKER_ID_BYTES>),
-    #[cfg(feature = "experiment_api")]
-    MioManager(crate::api::mio::MioManagerIoSource),
-}
-
-const EVENT_CAPACITY: usize = 20;
-
 /// Holds the state of the application, namely the external IO
 ///
 /// Responsible for file IO, network IO
 // TODO add user control via unix domain socket and stdin/stdout
 #[derive(Debug)]
 pub struct AppServer {
-    pub crypto_site: ConstructionSite<BuildCryptoServer, CryptoServer>,
+    pub crypt: CryptoServer,
    pub sockets: Vec<mio::net::UdpSocket>,
    pub events: mio::Events,
-    pub short_poll_queue: VecDeque<mio::event::Event>,
-    pub performed_long_poll: bool,
-    pub io_source_index: HashMap<mio::Token, AppServerIoSource>,
    pub mio_poll: mio::Poll,
    pub mio_token_dispenser: MioTokenDispenser,
    pub brokers: BrokerStore,
@@ -186,8 +159,6 @@ pub struct AppServer {
    pub unpolled_count: usize,
    pub last_update_time: Instant,
    pub test_helpers: Option<AppServerTest>,
-    #[cfg(feature = "experiment_api")]
-    pub api_manager: crate::api::mio::MioManager,
 }

 /// A socket pointer is an index assigned to a socket;
@@ -536,14 +507,15 @@ impl HostPathDiscoveryEndpoint {

 impl AppServer {
    pub fn new(
-        keypair: Option<(SSk, SPk)>,
+        sk: SSk,
+        pk: SPk,
        addrs: Vec<SocketAddr>,
        verbosity: Verbosity,
        test_helpers: Option<AppServerTest>,
    ) -> anyhow::Result<Self> {
        // setup mio
        let mio_poll = mio::Poll::new()?;
-        let events = mio::Events::with_capacity(EVENT_CAPACITY);
+        let events = mio::Events::with_capacity(20);
        let mut mio_token_dispenser = MioTokenDispenser::default();

        // bind each SocketAddr to a socket
@@ -618,30 +590,22 @@ impl AppServer {
        }

        // register all sockets to mio
-        let mut io_source_index = HashMap::new();
-        for (idx, socket) in sockets.iter_mut().enumerate() {
-            let mio_token = mio_token_dispenser.dispense();
-            mio_poll
-                .registry()
-                .register(socket, mio_token, Interest::READABLE)?;
-            let prev = io_source_index.insert(mio_token, AppServerIoSource::Socket(idx));
-            assert!(prev.is_none());
+        for socket in sockets.iter_mut() {
+            mio_poll.registry().register(
+                socket,
+                mio_token_dispenser.dispense(),
+                Interest::READABLE,
+            )?;
        }

-        let crypto_site = match keypair {
-            Some((sk, pk)) => ConstructionSite::from_product(CryptoServer::new(sk, pk)),
-            None => ConstructionSite::new(BuildCryptoServer::empty()),
-        };
+        // TODO use mio::net::UnixStream together with std::os::unix::net::UnixStream for Linux

        Ok(Self {
-            crypto_site,
+            crypt: CryptoServer::new(sk, pk),
            peers: Vec::new(),
            verbosity,
            sockets,
            events,
-            short_poll_queue: Default::default(),
-            performed_long_poll: false,
-            io_source_index,
            mio_poll,
            mio_token_dispenser,
            brokers: BrokerStore::default(),
@@ -652,78 +616,48 @@ impl AppServer {
            unpolled_count: 0,
            last_update_time: Instant::now(),
            test_helpers,
-            #[cfg(feature = "experiment_api")]
-            api_manager: crate::api::mio::MioManager::default(),
        })
    }

-    pub fn crypto_server(&self) -> anyhow::Result<&CryptoServer> {
-        self.crypto_site
-            .product_ref()
-            .context("Cryptography handler not initialized")
-    }
-
-    pub fn crypto_server_mut(&mut self) -> anyhow::Result<&mut CryptoServer> {
-        self.crypto_site
-            .product_mut()
-            .context("Cryptography handler not initialized")
-    }
-
    pub fn verbose(&self) -> bool {
        matches!(self.verbosity, Verbosity::Verbose)
    }

-    pub fn register_listen_socket(&mut self, mut sock: mio::net::UdpSocket) -> anyhow::Result<()> {
-        let mio_token = self.mio_token_dispenser.dispense();
-        self.mio_poll
-            .registry()
-            .register(&mut sock, mio_token, mio::Interest::READABLE)?;
-        let io_source = self.sockets.len().apply(AppServerIoSource::Socket);
-        self.sockets.push(sock);
-        self.register_io_source(mio_token, io_source);
-        Ok(())
-    }
-
-    pub fn register_io_source(&mut self, token: mio::Token, io_source: AppServerIoSource) {
-        let prev = self.io_source_index.insert(token, io_source);
-        assert!(prev.is_none());
-    }
-
-    pub fn unregister_io_source(&mut self, token: mio::Token) {
-        let value = self.io_source_index.remove(&token);
-        assert!(value.is_some(), "Removed IO source that does not exist");
-    }
-
    pub fn register_broker(
        &mut self,
        broker: Box<dyn WireguardBrokerMio<Error = anyhow::Error, MioError = anyhow::Error>>,
    ) -> Result<BrokerStorePtr> {
        let ptr = Public::from_slice((self.brokers.store.len() as u64).as_bytes());
+
        if self.brokers.store.insert(ptr, broker).is_some() {
            bail!("Broker already registered");
        }
-
-        let mio_token = self.mio_token_dispenser.dispense();
-        let io_source = ptr.apply(AppServerIoSource::PskBroker);
        //Register broker
        self.brokers
            .store
            .get_mut(&ptr)
            .ok_or(anyhow::format_err!("Broker wasn't added to registry"))?
-            .register(self.mio_poll.registry(), mio_token)?;
-        self.register_io_source(mio_token, io_source);
+            .register(
+                self.mio_poll.registry(),
+                self.mio_token_dispenser.dispense(),
+            )?;

        Ok(BrokerStorePtr(ptr))
    }

    pub fn unregister_broker(&mut self, ptr: BrokerStorePtr) -> Result<()> {
-        let mut broker = self
-            .brokers
+        //Unregister broker
+        self.brokers
+            .store
+            .get_mut(&ptr.0)
+            .ok_or_else(|| anyhow::anyhow!("Broker not found"))?
+            .unregister(self.mio_poll.registry())?;
+
+        //Remove broker from store
+        self.brokers
            .store
            .remove(&ptr.0)
-            .context("Broker not found")?;
-        self.unregister_io_source(broker.mio_token().unwrap());
-        broker.unregister(self.mio_poll.registry())?;
+            .ok_or_else(|| anyhow::anyhow!("Broker not found"))?;
        Ok(())
    }

@@ -735,13 +669,8 @@ impl AppServer {
        broker_peer: Option<BrokerPeer>,
        hostname: Option<String>,
    ) -> anyhow::Result<AppPeerPtr> {
-        let PeerPtr(pn) = match &mut self.crypto_site {
-            ConstructionSite::Void => bail!("Crypto server construction site is void"),
-            ConstructionSite::Builder(builder) => builder.add_peer(psk, pk),
-            ConstructionSite::Product(srv) => srv.add_peer(psk, pk)?,
-        };
+        let PeerPtr(pn) = self.crypt.add_peer(psk, pk)?;
        assert!(pn == self.peers.len());
-
        let initial_endpoint = hostname
            .map(Endpoint::discovery_from_hostname)
            .transpose()?;
@@ -783,7 +712,7 @@ impl AppServer {
            );
            if tries_left > 0 {
                error!("re-initializing networking in {sleep}! {tries_left} tries left.");
-                std::thread::sleep(Duration::from_secs_f64(sleep));
+                std::thread::sleep(self.crypt.timebase.dur(sleep));
                continue;
            }

@@ -826,31 +755,16 @@ impl AppServer {
                }
            }

-            enum CryptoSrv {
-                Avail,
-                Missing,
-            }
-
-            let poll_result = self.poll(&mut *rx)?;
-            let have_crypto = match self.crypto_site.is_available() {
-                true => CryptoSrv::Avail,
-                false => CryptoSrv::Missing,
-            };
-
-            #[allow(clippy::redundant_closure_call)]
-            match (have_crypto, poll_result) {
-                (CryptoSrv::Missing, SendInitiation(_)) => {}
-                (CryptoSrv::Avail, SendInitiation(peer)) => tx_maybe_with!(peer, || self
-                    .crypto_server_mut()?
+            match self.poll(&mut *rx)? {
+                #[allow(clippy::redundant_closure_call)]
+                SendInitiation(peer) => tx_maybe_with!(peer, || self
+                    .crypt
                    .initiate_handshake(peer.lower(), &mut *tx))?,
-
-                (CryptoSrv::Missing, SendRetransmission(_)) => {}
-                (CryptoSrv::Avail, SendRetransmission(peer)) => tx_maybe_with!(peer, || self
-                    .crypto_server_mut()?
+                #[allow(clippy::redundant_closure_call)]
+                SendRetransmission(peer) => tx_maybe_with!(peer, || self
+                    .crypt
                    .retransmit_handshake(peer.lower(), &mut *tx))?,
-
-                (CryptoSrv::Missing, DeleteKey(_)) => {}
-                (CryptoSrv::Avail, DeleteKey(peer)) => {
+                DeleteKey(peer) => {
                    self.output_key(peer, Stale, &SymKey::random())?;

                    // There was a loss of connection apparently; restart host discovery
@@ -864,15 +778,12 @@ impl AppServer {
                    );
                }

-                (CryptoSrv::Missing, ReceivedMessage(_, _)) => {}
-                (CryptoSrv::Avail, ReceivedMessage(len, endpoint)) => {
+                ReceivedMessage(len, endpoint) => {
                    let msg_result = match self.under_load {
                        DoSOperation::UnderLoad => {
                            self.handle_msg_under_load(&endpoint, &rx[..len], &mut *tx)
                        }
-                        DoSOperation::Normal => {
-                            self.crypto_server_mut()?.handle_msg(&rx[..len], &mut *tx)
-                        }
+                        DoSOperation::Normal => self.crypt.handle_msg(&rx[..len], &mut *tx),
                    };
                    match msg_result {
                        Err(ref e) => {
@@ -900,8 +811,7 @@ impl AppServer {
                                ap.get_app_mut(self).current_endpoint = Some(endpoint);

                                // TODO: Maybe we should rather call the key "rosenpass output"?
-                                let osk = &self.crypto_server_mut()?.osk(p)?;
-                                self.output_key(ap, Exchanged, osk)?;
+                                self.output_key(ap, Exchanged, &self.crypt.osk(p)?)?;
                            }
                        }
                    }
@@ -917,9 +827,9 @@ impl AppServer {
        tx: &mut [u8],
    ) -> Result<crate::protocol::HandleMsgResult> {
        match endpoint {
-            Endpoint::SocketBoundAddress(socket) => self
-                .crypto_server_mut()?
-                .handle_msg_under_load(rx, &mut *tx, socket),
+            Endpoint::SocketBoundAddress(socket) => {
+                self.crypt.handle_msg_under_load(rx, &mut *tx, socket)
+            }
            Endpoint::Discovery(_) => {
                anyhow::bail!("Host-path discovery is not supported under load")
            }
@@ -932,7 +842,7 @@ impl AppServer {
        why: KeyOutputReason,
        key: &SymKey,
    ) -> anyhow::Result<()> {
-        let peerid = peer.lower().get(self.crypto_server()?).pidt()?;
+        let peerid = peer.lower().get(&self.crypt).pidt()?;

        if self.verbose() {
            let msg = match why {
@@ -960,14 +870,10 @@ impl AppServer {

            // this is intentionally writing to stdout instead of stderr, because
            // it is meant to allow external detection of a successful key-exchange
-            let stdout = stdout();
-            let mut stdout = stdout.lock();
-            writeln!(
-                stdout,
+            println!(
                "output-key peer {} key-file {of:?} {why}",
                peerid.fmt_b64::<MAX_B64_PEER_ID_SIZE>()
-            )?;
-            stdout.flush()?;
+            );
        }

        peer.set_psk(self, key)?;
@@ -978,32 +884,17 @@ impl AppServer {
    pub fn poll(&mut self, rx_buf: &mut [u8]) -> anyhow::Result<AppPollResult> {
        use crate::protocol::PollResult as C;
        use AppPollResult as A;
-        let res = loop {
-            // Call CryptoServer's poll (if available)
-            let crypto_poll = self
-                .crypto_site
-                .product_mut()
-                .map(|crypto| crypto.poll())
-                .transpose()?;
-
-            // Map crypto server's poll result to our poll result
-            let io_poll_timeout = match crypto_poll {
-                Some(C::DeleteKey(PeerPtr(no))) => break A::DeleteKey(AppPeerPtr(no)),
-                Some(C::SendInitiation(PeerPtr(no))) => break A::SendInitiation(AppPeerPtr(no)),
-                Some(C::SendRetransmission(PeerPtr(no))) => {
-                    break A::SendRetransmission(AppPeerPtr(no))
-                }
-                Some(C::Sleep(timeout)) => timeout, // No event from crypto-server, do IO
-                None => crate::protocol::UNENDING,  // Crypto server is uninitialized, do IO
-            };
-
-            // Perform IO (look for a message)
-            if let Some((len, addr)) = self.try_recv(rx_buf, io_poll_timeout)? {
-                break A::ReceivedMessage(len, addr);
-            }
-        };
-
-        Ok(res)
+        loop {
+            return Ok(match self.crypt.poll()? {
+                C::DeleteKey(PeerPtr(no)) => A::DeleteKey(AppPeerPtr(no)),
+                C::SendInitiation(PeerPtr(no)) => A::SendInitiation(AppPeerPtr(no)),
+                C::SendRetransmission(PeerPtr(no)) => A::SendRetransmission(AppPeerPtr(no)),
+                C::Sleep(timeout) => match self.try_recv(rx_buf, timeout)? {
+                    Some((len, addr)) => A::ReceivedMessage(len, addr),
+                    None => continue,
+                },
+            });
+        }
    }

    /// Tries to receive a new message
@@ -1041,33 +932,22 @@ impl AppServer {
        // readiness event seems to be good enough™ for now.

        // only poll if we drained all sockets before
-        run(|| -> anyhow::Result<()> {
-            if !self.all_sockets_drained || !self.short_poll_queue.is_empty() {
-                self.unpolled_count += 1;
-                return Ok(());
-            }
+        if self.all_sockets_drained {
+            //Non blocked polling
+            self.mio_poll
+                .poll(&mut self.events, Some(Duration::from_secs(0)))?;

-            self.perform_mio_poll_and_register_events(Duration::from_secs(0))?; // Non-blocking poll
-            if !self.short_poll_queue.is_empty() {
-                // Got some events in non-blocking mode
+            if self.events.iter().peekable().peek().is_none() {
+                // if there are no events, then add to blocking poll count
+                self.blocking_polls_count += 1;
+                //Execute blocking poll
+                self.mio_poll.poll(&mut self.events, Some(timeout))?;
+            } else {
                self.non_blocking_polls_count += 1;
-                return Ok(());
            }
-
-            if !self.performed_long_poll {
-                // pass – go perform a full long poll before we enter blocking poll mode
-                // to make sure our experimental short poll feature did not miss any events
-                // due to being buggy.
-                return Ok(());
-            }
-
-            // Perform and register blocking poll
-            self.blocking_polls_count += 1;
-            self.perform_mio_poll_and_register_events(timeout)?;
-            self.performed_long_poll = false;
-
-            Ok(())
-        })?;
+        } else {
+            self.unpolled_count += 1;
+        }

        if let Some(AppServerTest {
            enable_dos_permanently: true,
@@ -1102,58 +982,26 @@ impl AppServer {
            }
        }

-        // Focused polling – i.e. actually using mio::Token – is experimental for now.
-        // The reason for this is that we need to figure out how to integrate load detection
-        // and focused polling for one. Mio event-based polling also does not play nice with
-        // the current function signature and its reentrant design which is focused around receiving UDP socket packages
-        // for processing by the crypto protocol server.
-        // Besides that, there are also some parts of the code which intentionally block
-        // despite available data. This is the correct behavior; e.g. api::mio::Connection blocks
-        // further reads from its unix socket until the write buffer is flushed. In other words
-        // the connection handler makes sure that there is a buffer to put the response in while
-        // before reading further request.
-        // The potential problem with this behavior is that we end up ignoring instructions from
-        // epoll() to read from the particular sockets, so epoll will return information about that
-        // particular – blocked – file descriptor every call. We have only so many event slots and
-        // in theory, the event array could fill up entirely with intentionally blocked sockets.
-        // We need to figure out how to deal with this situation.
-        // Mio uses uses epoll in level-triggered mode, so we could handle taint-tracking for ignored
-        // sockets ourselves. The facilities are available in epoll and Mio, but we need to figure out how mio uses those
-        // facilities and how we can integrate them here.
-        // This will involve rewriting a lot of IO code and we should probably have integration
-        // tests  before we approach that.
-        //
-        // This hybrid approach is not without merit though; the short poll implementation covers
-        // all our IO sources, so under contention, rosenpass should generally not hit the long
-        // poll mode below. We keep short polling and calling epoll() in non-blocking mode (timeout
-        // of zero) until we run out of IO events processed. Then, just before we would perform a
-        // blocking poll, we go through all available IO sources to see if we missed anything.
-        {
-            while let Some(ev) = self.short_poll_queue.pop_front() {
-                if let Some(v) = self.try_recv_from_mio_token(buf, ev.token())? {
-                    return Ok(Some(v));
-                }
-            }
-        }
-
        // drain all sockets
        let mut would_block_count = 0;
-        for sock_no in 0..self.sockets.len() {
-            match self
-                .try_recv_from_listen_socket(buf, sock_no)
-                .io_err_kind_hint()
-            {
-                Ok(None) => continue,
-                Ok(Some(v)) => {
+        for (sock_no, socket) in self.sockets.iter_mut().enumerate() {
+            match socket.recv_from(buf) {
+                Ok((n, addr)) => {
                    // at least one socket was not drained...
                    self.all_sockets_drained = false;
-                    return Ok(Some(v));
+                    return Ok(Some((
+                        n,
+                        Endpoint::SocketBoundAddress(SocketBoundEndpoint::new(
+                            SocketPtr(sock_no),
+                            addr,
+                        )),
+                    )));
                }
-                Err((_, ErrorKind::WouldBlock)) => {
+                Err(e) if e.kind() == ErrorKind::WouldBlock => {
                    would_block_count += 1;
                }
                // TODO if one socket continuously returns an error, then we never poll, thus we never wait for a timeout, thus we have a spin-lock
-                Err((e, _)) => return Err(e)?,
+                Err(e) => return Err(e.into()),
            }
        }

@@ -1165,126 +1013,6 @@ impl AppServer {
            broker.process_poll()?;
        }

-        // API poll
-
-        #[cfg(feature = "experiment_api")]
-        {
-            use crate::api::mio::MioManagerContext;
-            MioManagerFocus(self).poll()?;
-        }
-
-        self.performed_long_poll = true;
-
        Ok(None)
    }
-
-    fn perform_mio_poll_and_register_events(&mut self, timeout: Duration) -> io::Result<()> {
-        self.mio_poll.poll(&mut self.events, Some(timeout))?;
-        // Fill the short poll buffer with the acquired events
-        self.events
-            .iter()
-            .cloned()
-            .for_each(|v| self.short_poll_queue.push_back(v));
-        Ok(())
-    }
-
-    fn try_recv_from_mio_token(
-        &mut self,
-        buf: &mut [u8],
-        token: mio::Token,
-    ) -> anyhow::Result<Option<(usize, Endpoint)>> {
-        let io_source = match self.io_source_index.get(&token) {
-            Some(io_source) => *io_source,
-            None => {
-                log::warn!("No IO source assiociated with mio token ({token:?}). Polling using mio tokens directly is an experimental feature and IO handler should recover when all available io sources are polled. This is a developer error. Please report it.");
-                return Ok(None);
-            }
-        };
-
-        self.try_recv_from_io_source(buf, io_source)
-    }
-
-    fn try_recv_from_io_source(
-        &mut self,
-        buf: &mut [u8],
-        io_source: AppServerIoSource,
-    ) -> anyhow::Result<Option<(usize, Endpoint)>> {
-        use crate::api::mio::MioManagerContext;
-
-        match io_source {
-            AppServerIoSource::Socket(idx) => self
-                .try_recv_from_listen_socket(buf, idx)
-                .substitute_for_ioerr_wouldblock(None)?
-                .ok(),
-
-            #[cfg(feature = "experiment_api")]
-            AppServerIoSource::PskBroker(key) => self
-                .brokers
-                .store
-                .get_mut(&key)
-                .with_context(|| format!("No PSK broker under key {key:?}"))?
-                .process_poll()
-                .map(|_| None),
-
-            #[cfg(feature = "experiment_api")]
-            AppServerIoSource::MioManager(mmio_src) => MioManagerFocus(self)
-                .poll_particular(mmio_src)
-                .map(|_| None),
-        }
-    }
-
-    fn try_recv_from_listen_socket(
-        &mut self,
-        buf: &mut [u8],
-        idx: usize,
-    ) -> io::Result<Option<(usize, Endpoint)>> {
-        use std::io::ErrorKind as K;
-        let (n, addr) = loop {
-            match self.sockets[idx].recv_from(buf).io_err_kind_hint() {
-                Ok(v) => break v,
-                Err((_, K::Interrupted)) => continue,
-                Err((e, _)) => return Err(e)?,
-            }
-        };
-        SocketPtr(idx)
-            .apply(|sp| SocketBoundEndpoint::new(sp, addr))
-            .apply(Endpoint::SocketBoundAddress)
-            .apply(|ep| (n, ep))
-            .some()
-            .ok()
-    }
-
-    #[cfg(feature = "experiment_api")]
-    pub fn add_api_connection(&mut self, connection: mio::net::UnixStream) -> std::io::Result<()> {
-        use crate::api::mio::MioManagerContext;
-        MioManagerFocus(self).add_connection(connection)
-    }
-
-    #[cfg(feature = "experiment_api")]
-    pub fn add_api_listener(&mut self, listener: mio::net::UnixListener) -> std::io::Result<()> {
-        use crate::api::mio::MioManagerContext;
-        MioManagerFocus(self).add_listener(listener)
-    }
-}
-
-#[cfg(feature = "experiment_api")]
-struct MioManagerFocus<'a>(&'a mut AppServer);
-
-#[cfg(feature = "experiment_api")]
-impl crate::api::mio::MioManagerContext for MioManagerFocus<'_> {
-    fn mio_manager(&self) -> &crate::api::mio::MioManager {
-        &self.0.api_manager
-    }
-
-    fn mio_manager_mut(&mut self) -> &mut crate::api::mio::MioManager {
-        &mut self.0.api_manager
-    }
-
-    fn app_server(&self) -> &AppServer {
-        self.0
-    }
-
-    fn app_server_mut(&mut self) -> &mut AppServer {
-        self.0
-    }
 }
--- a/rosenpass/src/bin/gen-ipc-msg-types.rs
+++ b/rosenpass/src/bin/gen-ipc-msg-types.rs
@@ -1,92 +0,0 @@
-use anyhow::{Context, Result};
-use heck::ToShoutySnakeCase;
-
-use rosenpass_ciphers::{hash_domain::HashDomain, KEY_LEN};
-
-fn calculate_hash_value(hd: HashDomain, values: &[&str]) -> Result<[u8; KEY_LEN]> {
-    match values.split_first() {
-        Some((head, tail)) => calculate_hash_value(hd.mix(head.as_bytes())?, tail),
-        None => Ok(hd.into_value()),
-    }
-}
-
-fn print_literal(path: &[&str]) -> Result<()> {
-    let val = calculate_hash_value(HashDomain::zero(), path)?;
-    let (last, prefix) = path.split_last().context("developer error!")?;
-    let var_name = last.to_shouty_snake_case();
-
-    print!("// hash domain hash of: ");
-    for n in prefix.iter() {
-        print!("{n} -> ");
-    }
-    println!("{last}");
-
-    let c = hex::encode(val)
-        .chars()
-        .collect::<Vec<char>>()
-        .chunks_exact(4)
-        .map(|chunk| chunk.iter().collect::<String>())
-        .collect::<Vec<_>>();
-    println!("const {var_name} : RawMsgType = RawMsgType::from_le_bytes(hex!(\"{} {} {} {}    {} {} {} {}\"));",
-        c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
-
-    Ok(())
-}
-
-#[derive(Debug, Clone)]
-enum Tree {
-    Branch(String, Vec<Tree>),
-    Leaf(String),
-}
-
-impl Tree {
-    fn name(&self) -> &str {
-        match self {
-            Self::Branch(name, _) => name,
-            Self::Leaf(name) => name,
-        }
-    }
-
-    fn gen_code_inner(&self, prefix: &[&str]) -> Result<()> {
-        let mut path = prefix.to_owned();
-        path.push(self.name());
-
-        match self {
-            Self::Branch(_, ref children) => {
-                for c in children.iter() {
-                    c.gen_code_inner(&path)?
-                }
-            }
-            Self::Leaf(_) => print_literal(&path)?,
-        };
-
-        Ok(())
-    }
-
-    fn gen_code(&self) -> Result<()> {
-        self.gen_code_inner(&[])
-    }
-}
-
-fn main() -> Result<()> {
-    let tree = Tree::Branch(
-        "Rosenpass IPC API".to_owned(),
-        vec![Tree::Branch(
-            "Rosenpass Protocol Server".to_owned(),
-            vec![
-                Tree::Leaf("Ping Request".to_owned()),
-                Tree::Leaf("Ping Response".to_owned()),
-                Tree::Leaf("Supply Keypair Request".to_owned()),
-                Tree::Leaf("Supply Keypair Response".to_owned()),
-                Tree::Leaf("Add Listen Socket Request".to_owned()),
-                Tree::Leaf("Add Listen Socket Response".to_owned()),
-                Tree::Leaf("Add Psk Broker Request".to_owned()),
-                Tree::Leaf("Add Psk Broker Response".to_owned()),
-            ],
-        )],
-    );
-
-    println!("type RawMsgType = u128;");
-    println!();
-    tree.gen_code()
-}
--- a/rosenpass/src/cli.rs
+++ b/rosenpass/src/cli.rs
@@ -1,8 +1,11 @@
-use anyhow::{bail, ensure, Context};
+use anyhow::{bail, ensure};
 use clap::{Parser, Subcommand};
 use rosenpass_cipher_traits::Kem;
 use rosenpass_ciphers::kem::StaticKem;
 use rosenpass_secret_memory::file::StoreSecret;
+use rosenpass_secret_memory::{
+    secret_policy_try_use_memfd_secrets, secret_policy_use_only_malloc_secrets,
+};
 use rosenpass_util::file::{LoadValue, LoadValueB64, StoreValue};
 use rosenpass_wireguard_broker::brokers::native_unix::{
    NativeUnixBroker, NativeUnixBrokerConfigBaseBuilder, NativeUnixBrokerConfigBaseBuilderError,
@@ -16,29 +19,6 @@ use crate::protocol::{SPk, SSk, SymKey};

 use super::config;

-#[cfg(feature = "experiment_api")]
-use {
-    command_fds::{CommandFdExt, FdMapping},
-    log::{error, info},
-    mio::net::UnixStream,
-    rosenpass_util::fd::claim_fd,
-    rosenpass_wireguard_broker::brokers::mio_client::MioBrokerClient,
-    rosenpass_wireguard_broker::WireguardBrokerMio,
-    rustix::fd::AsRawFd,
-    rustix::net::{socketpair, AddressFamily, SocketFlags, SocketType},
-    std::os::unix::net,
-    std::process::Command,
-    std::thread,
-};
-
-/// enum representing a choice of interface to a WireGuard broker
-#[derive(Debug)]
-pub enum BrokerInterface {
-    Socket(PathBuf),
-    FileDescriptor(i32),
-    SocketPair,
-}
-
 /// struct holding all CLI arguments for `clap` crate to parse
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about)]
@@ -55,41 +35,11 @@ pub struct CliArgs {
    #[arg(short, long, group = "log-level")]
    quiet: bool,

-    #[command(flatten)]
-    #[cfg(feature = "experiment_api")]
-    api: crate::api::cli::ApiCli,
-
-    /// path of the wireguard_psk broker socket to connect to
-    #[cfg(feature = "experiment_api")]
-    #[arg(long, group = "psk-broker-specs")]
-    psk_broker_path: Option<PathBuf>,
-
-    /// fd of the wireguard_spk broker socket to connect to
-    ///
-    /// when this command is called from another process, the other process can open and bind the
-    /// Unix socket for the psk broker connection to use themselves, passing it to this process --
-    /// in Rust this can be achieved using the
-    /// [command-fds](https://docs.rs/command-fds/latest/command_fds/) crate
-    #[cfg(feature = "experiment_api")]
-    #[arg(long, group = "psk-broker-specs")]
-    psk_broker_fd: Option<i32>,
-
-    /// spawn a psk broker locally using a socket pair
-    #[cfg(feature = "experiment_api")]
-    #[arg(short, long, group = "psk-broker-specs")]
-    psk_broker_spawn: bool,
-
    #[command(subcommand)]
    pub command: CliCommand,
 }

 impl CliArgs {
-    pub fn apply_to_config(&self, _cfg: &mut config::Rosenpass) -> anyhow::Result<()> {
-        #[cfg(feature = "experiment_api")]
-        self.api.apply_to_config(_cfg)?;
-        Ok(())
-    }
-
    /// returns the log level filter set by CLI args
    /// returns `None` if the user did not specify any log level filter via CLI
    ///
@@ -101,35 +51,13 @@ impl CliArgs {
            return Some(log::LevelFilter::Info);
        }
        if self.quiet {
-            return Some(log::LevelFilter::Warn);
+            return Some(log::LevelFilter::Error);
        }
        if let Some(level_filter) = self.log_level {
            return Some(level_filter);
        }
        None
    }
-
-    #[cfg(feature = "experiment_api")]
-    /// returns the broker interface set by CLI args
-    /// returns `None` if the `experiment_api` feature isn't enabled
-    pub fn get_broker_interface(&self) -> Option<BrokerInterface> {
-        if let Some(path_ref) = self.psk_broker_path.as_ref() {
-            Some(BrokerInterface::Socket(path_ref.to_path_buf()))
-        } else if let Some(fd) = self.psk_broker_fd {
-            Some(BrokerInterface::FileDescriptor(fd))
-        } else if self.psk_broker_spawn {
-            Some(BrokerInterface::SocketPair)
-        } else {
-            None
-        }
-    }
-
-    #[cfg(not(feature = "experiment_api"))]
-    /// returns the broker interface set by CLI args
-    /// returns `None` if the `experiment_api` feature isn't enabled
-    pub fn get_broker_interface(&self) -> Option<BrokerInterface> {
-        None
-    }
 }

 /// represents a command specified via CLI
@@ -224,18 +152,21 @@ pub enum CliCommand {
    Man,
 }

-impl CliArgs {
+impl CliCommand {
    /// runs the command specified via CLI
    ///
    /// ## TODO
    /// - This method consumes the [`CliCommand`] value. It might be wise to use a reference...
-    pub fn run(
-        self,
-        broker_interface: Option<BrokerInterface>,
-        test_helpers: Option<AppServerTest>,
-    ) -> anyhow::Result<()> {
+    pub fn run(self, test_helpers: Option<AppServerTest>) -> anyhow::Result<()> {
+        //Specify secret policy
+
+        #[cfg(feature = "enable_memfd_alloc")]
+        secret_policy_try_use_memfd_secrets();
+        #[cfg(not(feature = "enable_memfd_alloc"))]
+        secret_policy_use_only_malloc_secrets();
+
        use CliCommand::*;
-        match &self.command {
+        match self {
            Man => {
                let man_cmd = std::process::Command::new("man")
                    .args(["1", "rosenpass"])
@@ -247,7 +178,7 @@ impl CliArgs {
            }
            GenConfig { config_file, force } => {
                ensure!(
-                    *force || !config_file.exists(),
+                    force || !config_file.exists(),
                    "config file {config_file:?} already exists"
                );

@@ -262,9 +193,9 @@ impl CliArgs {
                let mut secret_key: Option<PathBuf> = None;

                // Manual arg parsing, since clap wants to prefix flags with "--"
-                let mut args = args.iter();
+                let mut args = args.into_iter();
                loop {
-                    match (args.next().map(|x| x.as_str()), args.next()) {
+                    match (args.next().as_deref(), args.next()) {
                        (Some("private-key"), Some(opt)) | (Some("secret-key"), Some(opt)) => {
                            secret_key = Some(opt.into());
                        }
@@ -303,13 +234,10 @@ impl CliArgs {
                        );

                        let config = config::Rosenpass::load(config_file)?;
-                        let keypair = config
-                            .keypair
-                            .context("Config file present, but no keypair is specified.")?;

-                        (keypair.public_key, keypair.secret_key)
+                        (config.public_key, config.secret_key)
                    }
-                    (_, Some(pkf), Some(skf)) => (pkf.clone(), skf.clone()),
+                    (_, Some(pkf), Some(skf)) => (pkf, skf),
                    _ => {
                        bail!("either a config-file or both public-key and secret-key file are required")
                    }
@@ -319,14 +247,12 @@ impl CliArgs {
                let mut problems = vec![];
                if !force && pkf.is_file() {
                    problems.push(format!(
-                        "public-key file {:?} exists, refusing to overwrite",
-                        std::fs::canonicalize(&pkf)?,
+                        "public-key file {pkf:?} exist, refusing to overwrite it"
                    ));
                }
                if !force && skf.is_file() {
                    problems.push(format!(
-                        "secret-key file {:?} exists, refusing to overwrite",
-                        std::fs::canonicalize(&skf)?,
+                        "secret-key file {skf:?} exist, refusing to overwrite it"
                    ));
                }
                if !problems.is_empty() {
@@ -343,38 +269,31 @@ impl CliArgs {
                    "config file '{config_file:?}' does not exist"
                );

-                let mut config = config::Rosenpass::load(config_file)?;
+                let config = config::Rosenpass::load(config_file)?;
                config.validate()?;
-                self.apply_to_config(&mut config)?;
-                config.check_usefullness()?;
-
-                Self::event_loop(config, broker_interface, test_helpers)?;
+                Self::event_loop(config, test_helpers)?;
            }

            Exchange {
                first_arg,
-                rest_of_args,
+                mut rest_of_args,
                config_file,
            } => {
-                let mut rest_of_args = rest_of_args.clone();
-                rest_of_args.insert(0, first_arg.clone());
+                rest_of_args.insert(0, first_arg);
                let args = rest_of_args;
                let mut config = config::Rosenpass::parse_args(args)?;

                if let Some(p) = config_file {
-                    config.store(p)?;
-                    config.config_file_path.clone_from(p);
+                    config.store(&p)?;
+                    config.config_file_path = p;
                }
                config.validate()?;
-                self.apply_to_config(&mut config)?;
-                config.check_usefullness()?;
-
-                Self::event_loop(config, broker_interface, test_helpers)?;
+                Self::event_loop(config, test_helpers)?;
            }

            Validate { config_files } => {
                for file in config_files {
-                    match config::Rosenpass::load(file) {
+                    match config::Rosenpass::load(&file) {
                        Ok(config) => {
                            eprintln!("{file:?} is valid TOML and conforms to the expected schema");
                            match config.validate() {
@@ -393,34 +312,23 @@ impl CliArgs {

    fn event_loop(
        config: config::Rosenpass,
-        broker_interface: Option<BrokerInterface>,
        test_helpers: Option<AppServerTest>,
    ) -> anyhow::Result<()> {
        const MAX_PSK_SIZE: usize = 1000;
-
        // load own keys
-        let keypair = config
-            .keypair
-            .as_ref()
-            .map(|kp| -> anyhow::Result<_> {
-                let sk = SSk::load(&kp.secret_key)?;
-                let pk = SPk::load(&kp.public_key)?;
-                Ok((sk, pk))
-            })
-            .transpose()?;
+        let sk = SSk::load(&config.secret_key)?;
+        let pk = SPk::load(&config.public_key)?;

        // start an application server
        let mut srv = std::boxed::Box::<AppServer>::new(AppServer::new(
-            keypair,
-            config.listen.clone(),
+            sk,
+            pk,
+            config.listen,
            config.verbosity,
            test_helpers,
        )?);

-        config.apply_to_app_server(&mut srv)?;
-
-        let broker = Self::create_broker(broker_interface)?;
-        let broker_store_ptr = srv.register_broker(broker)?;
+        let broker_store_ptr = srv.register_broker(Box::new(NativeUnixBroker::new()))?;

        fn cfg_err_map(e: NativeUnixBrokerConfigBaseBuilderError) -> anyhow::Error {
            anyhow::Error::msg(format!("NativeUnixBrokerConfigBaseBuilderError: {:?}", e))
@@ -457,83 +365,6 @@ impl CliArgs {

        srv.event_loop()
    }
-
-    #[cfg(feature = "experiment_api")]
-    fn create_broker(
-        broker_interface: Option<BrokerInterface>,
-    ) -> Result<
-        Box<dyn WireguardBrokerMio<MioError = anyhow::Error, Error = anyhow::Error>>,
-        anyhow::Error,
-    > {
-        if let Some(interface) = broker_interface {
-            let socket = Self::get_broker_socket(interface)?;
-            Ok(Box::new(MioBrokerClient::new(socket)))
-        } else {
-            Ok(Box::new(NativeUnixBroker::new()))
-        }
-    }
-
-    #[cfg(not(feature = "experiment_api"))]
-    fn create_broker(
-        _broker_interface: Option<BrokerInterface>,
-    ) -> Result<Box<NativeUnixBroker>, anyhow::Error> {
-        Ok(Box::new(NativeUnixBroker::new()))
-    }
-
-    #[cfg(feature = "experiment_api")]
-    fn get_broker_socket(broker_interface: BrokerInterface) -> Result<UnixStream, anyhow::Error> {
-        // Connect to the psk broker unix socket if one was specified
-        // OR OTHERWISE spawn the psk broker and use socketpair(2) to connect with them
-        match broker_interface {
-            BrokerInterface::Socket(broker_path) => Ok(UnixStream::connect(broker_path)?),
-            BrokerInterface::FileDescriptor(broker_fd) => {
-                // mio::net::UnixStream doesn't implement From<OwnedFd>, so we have to go through std
-                let sock = net::UnixStream::from(claim_fd(broker_fd)?);
-                sock.set_nonblocking(true)?;
-                Ok(UnixStream::from_std(sock))
-            }
-            BrokerInterface::SocketPair => {
-                // Form a socketpair for communicating to the broker
-                let (ours, theirs) = socketpair(
-                    AddressFamily::UNIX,
-                    SocketType::STREAM,
-                    SocketFlags::empty(),
-                    None,
-                )?;
-
-                // Setup our end of the socketpair
-                let ours = net::UnixStream::from(ours);
-                ours.set_nonblocking(true)?;
-
-                // Start the PSK broker
-                let mut child = Command::new("rosenpass-wireguard-broker-socket-handler")
-                    .args(["--stream-fd", "3"])
-                    .fd_mappings(vec![FdMapping {
-                        parent_fd: theirs.as_raw_fd(),
-                        child_fd: 3,
-                    }])?
-                    .spawn()?;
-
-                // Handle the PSK broker crashing
-                thread::spawn(move || {
-                    let status = child.wait();
-
-                    if let Ok(status) = status {
-                        if status.success() {
-                            // Maybe they are doing double forking?
-                            info!("PSK broker exited.");
-                        } else {
-                            error!("PSK broker exited with an error ({status:?})");
-                        }
-                    } else {
-                        error!("Wait on PSK broker process failed ({status:?})");
-                    }
-                });
-
-                Ok(UnixStream::from_std(ours))
-            }
-        }
-    }
 }

 /// generate secret and public keys, store in files according to the paths passed as arguments
@@ -544,15 +375,3 @@ fn generate_and_save_keypair(secret_key: PathBuf, public_key: PathBuf) -> anyhow
    ssk.store_secret(secret_key)?;
    spk.store(public_key)
 }
-
-#[cfg(feature = "internal_testing")]
-pub mod testing {
-    use super::*;
-
-    pub fn generate_and_save_keypair(
-        secret_key: PathBuf,
-        public_key: PathBuf,
-    ) -> anyhow::Result<()> {
-        super::generate_and_save_keypair(secret_key, public_key)
-    }
-}
--- a/rosenpass/src/config.rs
+++ b/rosenpass/src/config.rs
@@ -19,28 +19,13 @@ use anyhow::{bail, ensure};
 use rosenpass_util::file::{fopen_w, Visibility};
 use serde::{Deserialize, Serialize};

-use crate::app_server::AppServer;
-
-#[cfg(feature = "experiment_api")]
-fn empty_api_config() -> crate::api::config::ApiConfig {
-    crate::api::config::ApiConfig {
-        listen_path: Vec::new(),
-        listen_fd: Vec::new(),
-        stream_fd: Vec::new(),
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Rosenpass {
-    // TODO: Raise error if secret key or public key alone is set during deserialization
-    // SEE: https://github.com/serde-rs/serde/issues/2793
-    #[serde(flatten)]
-    pub keypair: Option<Keypair>,
+    /// path to the public key file
+    pub public_key: PathBuf,

-    /// Location of the API listen sockets
-    #[cfg(feature = "experiment_api")]
-    #[serde(default = "empty_api_config")]
-    pub api: crate::api::config::ApiConfig,
+    /// path to the secret key file
+    pub secret_key: PathBuf,

    /// list of [`SocketAddr`] to listen on
    ///
@@ -67,29 +52,9 @@ pub struct Rosenpass {
    pub config_file_path: PathBuf,
 }

-#[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone)]
-pub struct Keypair {
-    /// path to the public key file
-    pub public_key: PathBuf,
-
-    /// path to the secret key file
-    pub secret_key: PathBuf,
-}
-
-impl Keypair {
-    pub fn new<Pk: AsRef<Path>, Sk: AsRef<Path>>(public_key: Pk, secret_key: Sk) -> Self {
-        let public_key = public_key.as_ref().to_path_buf();
-        let secret_key = secret_key.as_ref().to_path_buf();
-        Self {
-            public_key,
-            secret_key,
-        }
-    }
-}
-
 /// ## TODO
 /// - replace this type with [`log::LevelFilter`], also see <https://github.com/rosenpass/rosenpass/pull/246>
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Verbosity {
    Quiet,
    Verbose,
@@ -142,12 +107,6 @@ pub struct WireGuard {
    pub extra_params: Vec<String>,
 }

-impl Default for Rosenpass {
-    fn default() -> Self {
-        Self::empty()
-    }
-}
-
 impl Rosenpass {
    /// load configuration from a TOML file
    ///
@@ -163,10 +122,8 @@ impl Rosenpass {

        // resolve `~` (see https://github.com/rosenpass/rosenpass/issues/237)
        use util::resolve_path_with_tilde;
-        if let Some(ref mut keypair) = config.keypair {
-            resolve_path_with_tilde(&mut keypair.public_key);
-            resolve_path_with_tilde(&mut keypair.secret_key);
-        }
+        resolve_path_with_tilde(&mut config.public_key);
+        resolve_path_with_tilde(&mut config.secret_key);
        for peer in config.peers.iter_mut() {
            resolve_path_with_tilde(&mut peer.public_key);
            if let Some(ref mut psk) = &mut peer.pre_shared_key {
@@ -200,33 +157,25 @@ impl Rosenpass {
        self.store(&self.config_file_path)
    }

-    pub fn apply_to_app_server(&self, _srv: &mut AppServer) -> anyhow::Result<()> {
-        #[cfg(feature = "experiment_api")]
-        self.api.apply_to_app_server(_srv)?;
-        Ok(())
-    }
-
    /// Validate a configuration
    ///
    /// ## TODO
    /// - check that files do not just exist but are also readable
    /// - warn if neither out_key nor exchange_command of a peer is defined (v.i.)
    pub fn validate(&self) -> anyhow::Result<()> {
-        if let Some(ref keypair) = self.keypair {
-            // check the public key file exists
-            ensure!(
-                keypair.public_key.is_file(),
-                "could not find public-key file {:?}: no such file",
-                keypair.public_key
-            );
+        // check the public key file exists
+        ensure!(
+            self.public_key.is_file(),
+            "could not find public-key file {:?}: no such file",
+            self.public_key
+        );

-            // check the secret-key file exists
-            ensure!(
-                keypair.secret_key.is_file(),
-                "could not find secret-key file {:?}: no such file",
-                keypair.secret_key
-            );
-        }
+        // check the secret-key file exists
+        ensure!(
+            self.secret_key.is_file(),
+            "could not find secret-key file {:?}: no such file",
+            self.secret_key
+        );

        for (i, peer) in self.peers.iter().enumerate() {
            // check peer's public-key file exists
@@ -251,36 +200,12 @@ impl Rosenpass {
        Ok(())
    }

-    pub fn check_usefullness(&self) -> anyhow::Result<()> {
-        #[cfg(not(feature = "experiment_api"))]
-        ensure!(self.keypair.is_some(), "Server keypair missing.");
-
-        #[cfg(feature = "experiment_api")]
-        ensure!(
-            self.keypair.is_some() || self.api.has_api_sources(),
-            "{}{}",
-            "Specify a server keypair or some API connections to configure the keypair with.",
-            "Without a keypair, rosenpass can not operate."
-        );
-
-        Ok(())
-    }
-
-    pub fn empty() -> Self {
-        Self::new(None)
-    }
-
-    pub fn from_sk_pk<Sk: AsRef<Path>, Pk: AsRef<Path>>(sk: Sk, pk: Pk) -> Self {
-        Self::new(Some(Keypair::new(pk, sk)))
-    }
-
    /// Creates a new configuration
-    pub fn new(keypair: Option<Keypair>) -> Self {
+    pub fn new<P1: AsRef<Path>, P2: AsRef<Path>>(public_key: P1, secret_key: P2) -> Self {
        Self {
-            keypair,
+            public_key: PathBuf::from(public_key.as_ref()),
+            secret_key: PathBuf::from(secret_key.as_ref()),
            listen: vec![],
-            #[cfg(feature = "experiment_api")]
-            api: crate::api::config::ApiConfig::default(),
            verbosity: Verbosity::Quiet,
            peers: vec![],
            config_file_path: PathBuf::new(),
@@ -303,7 +228,7 @@ impl Rosenpass {
    /// from chaotic args
    /// Quest: the grammar is undecideable, what do we do here?
    pub fn parse_args(args: Vec<String>) -> anyhow::Result<Self> {
-        let mut config = Self::new(Some(Keypair::new("", "")));
+        let mut config = Self::new("", "");

        #[derive(Debug, Hash, PartialEq, Eq)]
        enum State {
@@ -364,7 +289,7 @@ impl Rosenpass {
                        already_set.insert(OwnPublicKey),
                        "public-key was already set"
                    );
-                    config.keypair.as_mut().unwrap().public_key = pk.into();
+                    config.public_key = pk.into();
                    Own
                }
                (OwnSecretKey, sk, None) => {
@@ -372,7 +297,7 @@ impl Rosenpass {
                        already_set.insert(OwnSecretKey),
                        "secret-key was already set"
                    );
-                    config.keypair.as_mut().unwrap().secret_key = sk.into();
+                    config.secret_key = sk.into();
                    Own
                }
                (OwnListen, l, None) => {
@@ -507,12 +432,10 @@ impl Rosenpass {
        };

        Self {
-            keypair: Some(Keypair {
-                public_key: "/path/to/rp-public-key".into(),
-                secret_key: "/path/to/rp-secret-key".into(),
-            }),
+            public_key: "/path/to/rp-public-key".into(),
+            secret_key: "/path/to/rp-secret-key".into(),
            peers: vec![peer],
-            ..Self::new(None)
+            ..Self::new("", "")
        }
    }
 }
@@ -525,119 +448,13 @@ impl Default for Verbosity {

 #[cfg(test)]
 mod test {
-
    use super::*;
-    use std::{borrow::Borrow, net::IpAddr};
-
-    fn toml_des<S: Borrow<str>>(s: S) -> Result<toml::Table, toml::de::Error> {
-        toml::from_str(s.borrow())
-    }
-
-    fn toml_ser<S: Serialize>(s: S) -> Result<toml::Table, toml::ser::Error> {
-        toml::Table::try_from(s)
-    }
-
-    fn assert_toml<L: Serialize, R: Borrow<str>>(l: L, r: R, info: &str) -> anyhow::Result<()> {
-        fn lines_prepend(prefix: &str, s: &str) -> anyhow::Result<String> {
-            use std::fmt::Write;
-
-            let mut buf = String::new();
-            for line in s.lines() {
-                writeln!(&mut buf, "{prefix}{line}")?;
-            }
-            Ok(buf)
-        }
-
-        let l = toml_ser(l)?;
-        let r = toml_des(r.borrow())?;
-        ensure!(
-            l == r,
-            "{}{}TOML value mismatch.\n  Have:\n{}\n  Expected:\n{}",
-            info,
-            if info.is_empty() { "" } else { ": " },
-            lines_prepend("    ", &toml::to_string_pretty(&l)?)?,
-            lines_prepend("    ", &toml::to_string_pretty(&r)?)?
-        );
-        Ok(())
-    }
-
-    fn assert_toml_round<'de, L: Serialize + Deserialize<'de>, R: Borrow<str>>(
-        l: L,
-        r: R,
-    ) -> anyhow::Result<()> {
-        let l = toml_ser(l)?;
-        assert_toml(&l, r.borrow(), "Straight deserialization")?;
-
-        let l: L = l.try_into().unwrap();
-        let l = toml_ser(l).unwrap();
-        assert_toml(l, r.borrow(), "Roundtrip deserialization")?;
-
-        Ok(())
-    }
+    use std::net::IpAddr;

    fn split_str(s: &str) -> Vec<String> {
        s.split(' ').map(|s| s.to_string()).collect()
    }

-    #[test]
-    fn toml_serialization() -> anyhow::Result<()> {
-        #[cfg(feature = "experiment_api")]
-        assert_toml_round(
-            Rosenpass::empty(),
-            r#"
-            listen = []
-            verbosity = "Quiet"
-            peers = []
-
-            [api]
-            listen_path = []
-            listen_fd = []
-            stream_fd = []
-        "#,
-        )?;
-
-        #[cfg(not(feature = "experiment_api"))]
-        assert_toml_round(
-            Rosenpass::empty(),
-            r#"
-            listen = []
-            verbosity = "Quiet"
-            peers = []
-        "#,
-        )?;
-
-        #[cfg(feature = "experiment_api")]
-        assert_toml_round(
-            Rosenpass::from_sk_pk("/my/sk", "/my/pk"),
-            r#"
-            public_key = "/my/pk"
-            secret_key = "/my/sk"
-            listen = []
-            verbosity = "Quiet"
-            peers = []
-
-            [api]
-            listen_path = []
-            listen_fd = []
-            stream_fd = []
-        "#,
-        )?;
-
-        #[cfg(not(feature = "experiment_api"))]
-        assert_toml_round(
-            Rosenpass::from_sk_pk("/my/sk", "/my/pk"),
-            r#"
-            public_key = "/my/pk"
-            secret_key = "/my/sk"
-            listen = []
-            verbosity = "Quiet"
-            peers = []
-        "#,
-        )?;
-
-        Ok(())
-    }
-
    #[test]
    fn test_simple_cli_parse() {
        let args = split_str(
@@ -648,10 +465,8 @@ mod test {

        let config = Rosenpass::parse_args(args).unwrap();

-        assert_eq!(
-            config.keypair,
-            Some(Keypair::new("/my/public-key", "/my/secret-key"))
-        );
+        assert_eq!(config.public_key, PathBuf::from("/my/public-key"));
+        assert_eq!(config.secret_key, PathBuf::from("/my/secret-key"));
        assert_eq!(config.verbosity, Verbosity::Verbose);
        assert_eq!(
            &config.listen,
@@ -680,10 +495,8 @@ mod test {

        let config = Rosenpass::parse_args(args).unwrap();

-        assert_eq!(
-            config.keypair,
-            Some(Keypair::new("/my/public-key", "/my/secret-key"))
-        );
+        assert_eq!(config.public_key, PathBuf::from("/my/public-key"));
+        assert_eq!(config.secret_key, PathBuf::from("/my/secret-key"));
        assert_eq!(config.verbosity, Verbosity::Verbose);
        assert!(&config.listen.is_empty());
        assert_eq!(
--- a/rosenpass/src/lib.rs
+++ b/rosenpass/src/lib.rs
@@ -1,5 +1,3 @@
-#[cfg(feature = "experiment_api")]
-pub mod api;
 pub mod app_server;
 pub mod cli;
 pub mod config;
@@ -13,8 +11,4 @@ pub enum RosenpassError {
    BufferSizeMismatch,
    #[error("invalid message type")]
    InvalidMessageType(u8),
-    #[error("invalid API message type")]
-    InvalidApiMessageType(u128),
-    #[error("could not parse API message")]
-    InvalidApiMessage,
 }
--- a/rosenpass/src/main.rs
+++ b/rosenpass/src/main.rs
@@ -8,14 +8,6 @@ pub fn main() {
    // parse CLI arguments
    let args = CliArgs::parse();

-    {
-        use rosenpass_secret_memory as SM;
-        #[cfg(feature = "experiment_memfd_secret")]
-        SM::secret_policy_try_use_memfd_secrets();
-        #[cfg(not(feature = "experiment_memfd_secret"))]
-        SM::secret_policy_use_only_malloc_secrets();
-    }
-
    // init logging
    {
        let mut log_builder = env_logger::Builder::from_default_env(); // sets log level filter from environment (or defaults)
@@ -34,11 +26,10 @@ pub fn main() {
        // error!("error dummy");
    }

-    let broker_interface = args.get_broker_interface();
-    match args.run(broker_interface, None) {
+    match args.command.run(None) {
        Ok(_) => {}
        Err(e) => {
-            error!("{e:?}");
+            error!("{e}");
            exit(1);
        }
    }
--- a/rosenpass/src/protocol/protocol.rs
+++ b/rosenpass/src/protocol/protocol.rs
@@ -91,13 +91,19 @@ use rosenpass_ciphers::kem::{EphemeralKem, StaticKem};
 use rosenpass_ciphers::{aead, xaead, KEY_LEN};
 use rosenpass_constant_time as constant_time;
 use rosenpass_secret_memory::{Public, PublicBox, Secret};
-use rosenpass_util::{cat, mem::cpy_min, time::Timebase};
+use rosenpass_util::{cat, mem::cpy_min, ord::max_usize, time::Timebase};
 use zerocopy::{AsBytes, FromBytes, Ref};

 use crate::{hash_domains, msgs::*, RosenpassError};

 // CONSTANTS & SETTINGS //////////////////////////

+/// Size required to fit any message in binary form
+pub const RTX_BUFFER_SIZE: usize = max_usize(
+    size_of::<Envelope<InitHello>>(),
+    size_of::<Envelope<InitConf>>(),
+);
+
 /// A type for time, e.g. for backoff before re-tries
 pub type Timing = f64;

--- a/rosenpass/src/protocol/build_crypto_server.rs
+++ b/rosenpass/src/protocol/build_crypto_server.rs
@@ -1,127 +0,0 @@
-use rosenpass_util::{
-    build::Build,
-    mem::{DiscardResultExt, SwapWithDefaultExt},
-    result::ensure_or,
-};
-use thiserror::Error;
-
-use super::{CryptoServer, PeerPtr, SPk, SSk, SymKey};
-
-#[derive(Debug, Clone)]
-pub struct Keypair {
-    pub sk: SSk,
-    pub pk: SPk,
-}
-
-// TODO: We need a named tuple derive
-impl Keypair {
-    pub fn new(sk: SSk, pk: SPk) -> Self {
-        Self { sk, pk }
-    }
-
-    pub fn zero() -> Self {
-        Self::new(SSk::zero(), SPk::zero())
-    }
-
-    pub fn random() -> Self {
-        Self::new(SSk::random(), SPk::random())
-    }
-
-    pub fn from_parts(parts: (SSk, SPk)) -> Self {
-        Self::new(parts.0, parts.1)
-    }
-
-    pub fn into_parts(self) -> (SSk, SPk) {
-        (self.sk, self.pk)
-    }
-}
-
-#[derive(Error, Debug)]
-#[error("PSK already set in BuildCryptoServer")]
-pub struct PskAlreadySet;
-
-#[derive(Error, Debug)]
-#[error("Keypair already set in BuildCryptoServer")]
-pub struct KeypairAlreadySet;
-
-#[derive(Error, Debug)]
-#[error("Can not construct CryptoServer: Missing keypair")]
-pub struct MissingKeypair;
-
-#[derive(Debug, Default)]
-pub struct BuildCryptoServer {
-    pub keypair: Option<Keypair>,
-    pub peers: Vec<PeerParams>,
-}
-
-impl Build<CryptoServer> for BuildCryptoServer {
-    type Error = anyhow::Error;
-
-    fn build(self) -> Result<CryptoServer, Self::Error> {
-        let Some(Keypair { sk, pk }) = self.keypair else {
-            return Err(MissingKeypair)?;
-        };
-
-        let mut srv = CryptoServer::new(sk, pk);
-
-        for (idx, PeerParams { psk, pk }) in self.peers.into_iter().enumerate() {
-            let PeerPtr(idx2) = srv.add_peer(psk, pk)?;
-            assert!(idx == idx2, "Peer id changed during CryptoServer construction from {idx} to {idx2}. This is a developer error.")
-        }
-
-        Ok(srv)
-    }
-}
-
-#[derive(Debug)]
-pub struct PeerParams {
-    pub psk: Option<SymKey>,
-    pub pk: SPk,
-}
-
-impl BuildCryptoServer {
-    pub fn new(keypair: Option<Keypair>, peers: Vec<PeerParams>) -> Self {
-        Self { keypair, peers }
-    }
-
-    pub fn empty() -> Self {
-        Self::new(None, Vec::new())
-    }
-
-    pub fn from_parts(parts: (Option<Keypair>, Vec<PeerParams>)) -> Self {
-        Self {
-            keypair: parts.0,
-            peers: parts.1,
-        }
-    }
-
-    pub fn take_parts(&mut self) -> (Option<Keypair>, Vec<PeerParams>) {
-        (self.keypair.take(), self.peers.swap_with_default())
-    }
-
-    pub fn into_parts(mut self) -> (Option<Keypair>, Vec<PeerParams>) {
-        self.take_parts()
-    }
-
-    pub fn with_keypair(&mut self, keypair: Keypair) -> Result<&mut Self, KeypairAlreadySet> {
-        ensure_or(self.keypair.is_none(), KeypairAlreadySet)?;
-        self.keypair.insert(keypair).discard_result();
-        Ok(self)
-    }
-
-    pub fn with_added_peer(&mut self, psk: Option<SymKey>, pk: SPk) -> &mut Self {
-        // TODO: Check here already whether peer was already added
-        self.peers.push(PeerParams { psk, pk });
-        self
-    }
-
-    pub fn add_peer(&mut self, psk: Option<SymKey>, pk: SPk) -> PeerPtr {
-        let id = PeerPtr(self.peers.len());
-        self.with_added_peer(psk, pk);
-        id
-    }
-
-    pub fn emancipate(&mut self) -> Self {
-        Self::from_parts(self.take_parts())
-    }
-}
--- a/rosenpass/src/protocol/mod.rs
+++ b/rosenpass/src/protocol/mod.rs
@@ -1,6 +0,0 @@
-mod build_crypto_server;
-#[allow(clippy::module_inception)]
-mod protocol;
-
-pub use build_crypto_server::*;
-pub use protocol::*;
--- a/rosenpass/tests/api-integration-tests-api-setup.rs
+++ b/rosenpass/tests/api-integration-tests-api-setup.rs
@@ -1,332 +0,0 @@
-use std::{
-    borrow::Borrow,
-    io::{BufRead, BufReader, Write},
-    os::unix::net::UnixStream,
-    process::Stdio,
-    thread::sleep,
-    time::Duration,
-};
-
-use anyhow::{bail, Context};
-use command_fds::{CommandFdExt, FdMapping};
-use hex_literal::hex;
-use rosenpass::api::{
-    self, add_listen_socket_response_status, add_psk_broker_response_status,
-    supply_keypair_response_status,
-};
-use rosenpass_util::{
-    b64::B64Display,
-    file::LoadValueB64,
-    io::IoErrorKind,
-    length_prefix_encoding::{decoder::LengthPrefixDecoder, encoder::LengthPrefixEncoder},
-    mem::{DiscardResultExt, MoveExt},
-    mio::WriteWithFileDescriptors,
-    zerocopy::ZerocopySliceExt,
-};
-use rustix::fd::{AsFd, AsRawFd};
-use tempfile::TempDir;
-use zerocopy::AsBytes;
-
-use rosenpass::protocol::SymKey;
-
-struct KillChild(std::process::Child);
-
-impl Drop for KillChild {
-    fn drop(&mut self) {
-        self.0.kill().discard_result();
-        self.0.wait().discard_result()
-    }
-}
-
-#[test]
-fn api_integration_api_setup() -> anyhow::Result<()> {
-    rosenpass_secret_memory::policy::secret_policy_use_only_malloc_secrets();
-
-    let dir = TempDir::with_prefix("rosenpass-api-integration-test")?;
-
-    macro_rules! tempfile {
-        ($($lst:expr),+) => {{
-            let mut buf =  dir.path().to_path_buf();
-            $(buf.push($lst);)*
-            buf
-        }}
-    }
-
-    let peer_a_endpoint = "[::1]:0";
-    let peer_a_listen = std::net::UdpSocket::bind(peer_a_endpoint)?;
-    let peer_a_endpoint = format!("{}", peer_a_listen.local_addr()?);
-    let peer_a_keypair = config::Keypair::new(tempfile!("a.pk"), tempfile!("a.sk"));
-
-    let peer_b_osk = tempfile!("b.osk");
-    let peer_b_wg_device = "mock_device";
-    let peer_b_wg_peer_id = hex!(
-        "
-        93 0f ee 77 0c 6b 54 7e  13 5f 13 92 21 97 26 53
-        7d 77 4a 6a 0f 6c eb 1a  dd 6e 5b c4 1b 92 cd 99
-    "
-    );
-
-    use rosenpass::config;
-    let peer_a = config::Rosenpass {
-        config_file_path: tempfile!("a.config"),
-        keypair: None,
-        listen: vec![], // TODO: This could collide by accident
-        verbosity: config::Verbosity::Verbose,
-        api: api::config::ApiConfig {
-            listen_path: vec![tempfile!("a.sock")],
-            listen_fd: vec![],
-            stream_fd: vec![],
-        },
-        peers: vec![config::RosenpassPeer {
-            public_key: tempfile!("b.pk"),
-            key_out: None,
-            endpoint: None,
-            pre_shared_key: None,
-            wg: Some(config::WireGuard {
-                device: peer_b_wg_device.to_string(),
-                peer: format!("{}", peer_b_wg_peer_id.fmt_b64::<8129>()),
-                extra_params: vec![],
-            }),
-        }],
-    };
-
-    let peer_b_keypair = config::Keypair::new(tempfile!("b.pk"), tempfile!("b.sk"));
-    let peer_b = config::Rosenpass {
-        config_file_path: tempfile!("b.config"),
-        keypair: Some(peer_b_keypair.clone()),
-        listen: vec![],
-        verbosity: config::Verbosity::Verbose,
-        api: api::config::ApiConfig {
-            listen_path: vec![tempfile!("b.sock")],
-            listen_fd: vec![],
-            stream_fd: vec![],
-        },
-        peers: vec![config::RosenpassPeer {
-            public_key: tempfile!("a.pk"),
-            key_out: Some(peer_b_osk.clone()),
-            endpoint: Some(peer_a_endpoint.to_owned()),
-            pre_shared_key: None,
-            wg: None,
-        }],
-    };
-
-    // Generate the keys
-    rosenpass::cli::testing::generate_and_save_keypair(
-        peer_a_keypair.secret_key.clone(),
-        peer_a_keypair.public_key.clone(),
-    )?;
-    rosenpass::cli::testing::generate_and_save_keypair(
-        peer_b_keypair.secret_key.clone(),
-        peer_b_keypair.public_key.clone(),
-    )?;
-
-    // Write the configuration files
-    peer_a.commit()?;
-    peer_b.commit()?;
-
-    let (deliberate_fail_api_client, deliberate_fail_api_server) =
-        std::os::unix::net::UnixStream::pair()?;
-    let deliberate_fail_child_fd = 3;
-
-    // Start peer a
-    let _proc_a = KillChild(
-        std::process::Command::new(env!("CARGO_BIN_EXE_rosenpass"))
-            .args(["--api-stream-fd", &deliberate_fail_child_fd.to_string()])
-            .fd_mappings(vec![FdMapping {
-                parent_fd: deliberate_fail_api_server.move_here().as_raw_fd(),
-                child_fd: 3,
-            }])?
-            .args([
-                "exchange-config",
-                peer_a.config_file_path.to_str().context("")?,
-            ])
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .spawn()?,
-    );
-
-    // Start peer b
-    let mut proc_b = KillChild(
-        std::process::Command::new(env!("CARGO_BIN_EXE_rosenpass"))
-            .args([
-                "exchange-config",
-                peer_b.config_file_path.to_str().context("")?,
-            ])
-            .stdin(Stdio::null())
-            .stderr(Stdio::null())
-            .stdout(Stdio::piped())
-            .spawn()?,
-    );
-
-    // Acquire stdout
-    let mut out_b = BufReader::new(proc_b.0.stdout.take().context("")?).lines();
-
-    // Now connect to the peers
-    let api_path = peer_a.api.listen_path[0].as_path();
-
-    // Wait for the socket to be created
-    let attempt = 0;
-    while !api_path.exists() {
-        sleep(Duration::from_millis(200));
-        assert!(
-            attempt < 50,
-            "Api failed to be created even after 50 seconds"
-        );
-    }
-
-    let api = UnixStream::connect(api_path)?;
-    let (psk_broker_sock, psk_broker_server_sock) = UnixStream::pair()?;
-
-    // Send AddListenSocket request
-    {
-        let fd = peer_a_listen.as_fd();
-
-        let mut fds = vec![&fd].into();
-        let mut api = WriteWithFileDescriptors::<UnixStream, _, _, _>::new(&api, &mut fds);
-        LengthPrefixEncoder::from_message(api::AddListenSocketRequest::new().as_bytes())
-            .write_all_to_stdio(&mut api)?;
-        assert!(fds.is_empty(), "Failed to write all file descriptors");
-        std::mem::forget(peer_a_listen);
-    }
-
-    // Read response
-    {
-        let mut decoder = LengthPrefixDecoder::new([0u8; api::MAX_RESPONSE_LEN]);
-        let res = decoder.read_all_from_stdio(&api)?;
-        let res = res.zk_parse::<api::AddListenSocketResponse>()?;
-        assert_eq!(
-            *res,
-            api::AddListenSocketResponse::new(add_listen_socket_response_status::OK)
-        );
-    }
-
-    // Deliberately break API connection given via FD; this checks that the
-    // API connections are closed when invalid data is received and it also
-    // implicitly checks that other connections are unaffected
-    {
-        use std::io::ErrorKind as K;
-        let client = deliberate_fail_api_client;
-        let err = loop {
-            if let Err(e) = client.borrow().write(&[0xffu8; 16]) {
-                break e;
-            }
-        };
-        // NotConnected happens on Mac
-        assert!(matches!(
-            err.io_error_kind(),
-            K::ConnectionReset | K::BrokenPipe | K::NotConnected
-        ));
-    }
-
-    // Send SupplyKeypairRequest
-    {
-        use rustix::fs::{open, Mode, OFlags};
-        let sk = open(peer_a_keypair.secret_key, OFlags::RDONLY, Mode::empty())?;
-        let pk = open(peer_a_keypair.public_key, OFlags::RDONLY, Mode::empty())?;
-
-        let mut fds = vec![&sk, &pk].into();
-        let mut api = WriteWithFileDescriptors::<UnixStream, _, _, _>::new(&api, &mut fds);
-        LengthPrefixEncoder::from_message(api::SupplyKeypairRequest::new().as_bytes())
-            .write_all_to_stdio(&mut api)?;
-        assert!(fds.is_empty(), "Failed to write all file descriptors");
-    }
-
-    // Read response
-    {
-        let mut decoder = LengthPrefixDecoder::new([0u8; api::MAX_RESPONSE_LEN]);
-        let res = decoder.read_all_from_stdio(&api)?;
-        let res = res.zk_parse::<api::SupplyKeypairResponse>()?;
-        assert_eq!(
-            *res,
-            api::SupplyKeypairResponse::new(supply_keypair_response_status::OK)
-        );
-    }
-
-    // Send AddPskBroker request
-    {
-        let mut fds = vec![psk_broker_server_sock.as_fd()].into();
-        let mut api = WriteWithFileDescriptors::<UnixStream, _, _, _>::new(&api, &mut fds);
-        LengthPrefixEncoder::from_message(api::AddPskBrokerRequest::new().as_bytes())
-            .write_all_to_stdio(&mut api)?;
-        assert!(fds.is_empty(), "Failed to write all file descriptors");
-    }
-
-    // Read response
-    {
-        let mut decoder = LengthPrefixDecoder::new([0u8; api::MAX_RESPONSE_LEN]);
-        let res = decoder.read_all_from_stdio(&api)?;
-        let res = res.zk_parse::<api::AddPskBrokerResponse>()?;
-        assert_eq!(
-            *res,
-            api::AddPskBrokerResponse::new(add_psk_broker_response_status::OK)
-        );
-    }
-
-    // Wait for the keys to successfully exchange a key
-    let mut attempt = 0;
-    loop {
-        // Read OSK generated by A
-        let osk_a = {
-            use rosenpass_wireguard_broker::api::msgs as M;
-            type SetPskReqPkg = M::Envelope<M::SetPskRequest>;
-            type SetPskResPkg = M::Envelope<M::SetPskResponse>;
-
-            // Receive request
-            let mut decoder = LengthPrefixDecoder::new([0u8; M::REQUEST_MSG_BUFFER_SIZE]);
-            let req = decoder.read_all_from_stdio(&psk_broker_sock)?;
-
-            let req = req.zk_parse::<SetPskReqPkg>()?;
-            assert_eq!(req.msg_type, M::MsgType::SetPsk as u8);
-            assert_eq!(req.payload.peer_id, peer_b_wg_peer_id);
-            assert_eq!(req.payload.iface()?, peer_b_wg_device);
-
-            // Send response
-            let res = SetPskResPkg {
-                msg_type: M::MsgType::SetPsk as u8,
-                reserved: [0u8; 3],
-                payload: M::SetPskResponse {
-                    return_code: M::SetPskResponseReturnCode::Success as u8,
-                },
-            };
-            LengthPrefixEncoder::from_message(res.as_bytes())
-                .write_all_to_stdio(&psk_broker_sock)?;
-
-            SymKey::from_slice(&req.payload.psk)
-        };
-
-        // Read OSK generated by B
-        let osk_b = {
-            let line = out_b.next().context("")??;
-            let words = line.split(' ').collect::<Vec<_>>();
-
-            // FIXED     FIXED PEER-ID                                      FIXED    FILENAME       STATUS
-            // output-key peer KZqXTZ4l2aNnkJtLPhs4D8JxHTGmRSL9w3Qr+X8JxFk= key-file "client-A-osk" exchanged
-            let peer_id = words
-                .get(2)
-                .with_context(|| format!("Bad rosenpass output: `{line}`"))?;
-            assert_eq!(
-                line,
-                format!(
-                    "output-key peer {peer_id} key-file \"{}\" exchanged",
-                    peer_b_osk.to_str().context("")?
-                )
-            );
-
-            SymKey::load_b64::<64, _>(peer_b_osk.clone())?
-        };
-
-        // TODO: This may be flaky. Both rosenpass instances are not guaranteed to produce
-        // the same number of output events; they merely guarantee eventual consistency of OSK.
-        // Correctly, we should use tokio to read any number of generated OSKs and indicate
-        // success on consensus
-        match osk_a.secret() == osk_b.secret() {
-            true => break,
-            false if attempt > 10 => bail!("Peers did not produce a matching key even after ten attempts. Something is wrong with the key exchange!"),
-            false => {},
-        };
-
-        attempt += 1;
-    }
-
-    Ok(())
-}
--- a/rosenpass/tests/api-integration-tests.rs
+++ b/rosenpass/tests/api-integration-tests.rs
@@ -1,194 +0,0 @@
-use std::{
-    io::{BufRead, BufReader},
-    net::ToSocketAddrs,
-    os::unix::net::UnixStream,
-    process::Stdio,
-};
-
-use anyhow::{bail, Context};
-use rosenpass::api;
-use rosenpass_to::{ops::copy_slice_least_src, To};
-use rosenpass_util::{
-    file::LoadValueB64,
-    length_prefix_encoding::{decoder::LengthPrefixDecoder, encoder::LengthPrefixEncoder},
-};
-use rosenpass_util::{mem::DiscardResultExt, zerocopy::ZerocopySliceExt};
-use tempfile::TempDir;
-use zerocopy::AsBytes;
-
-use rosenpass::protocol::SymKey;
-
-struct KillChild(std::process::Child);
-
-impl Drop for KillChild {
-    fn drop(&mut self) {
-        self.0.kill().discard_result();
-        self.0.wait().discard_result()
-    }
-}
-
-#[test]
-fn api_integration_test() -> anyhow::Result<()> {
-    rosenpass_secret_memory::policy::secret_policy_use_only_malloc_secrets();
-
-    let dir = TempDir::with_prefix("rosenpass-api-integration-test")?;
-
-    macro_rules! tempfile {
-        ($($lst:expr),+) => {{
-            let mut buf =  dir.path().to_path_buf();
-            $(buf.push($lst);)*
-            buf
-        }}
-    }
-
-    let peer_a_endpoint = "[::1]:61423";
-    let peer_a_osk = tempfile!("a.osk");
-    let peer_b_osk = tempfile!("b.osk");
-
-    use rosenpass::config;
-
-    let peer_a_keypair = config::Keypair::new(tempfile!("a.pk"), tempfile!("a.sk"));
-    let peer_a = config::Rosenpass {
-        config_file_path: tempfile!("a.config"),
-        keypair: Some(peer_a_keypair.clone()),
-        listen: peer_a_endpoint.to_socket_addrs()?.collect(), // TODO: This could collide by accident
-        verbosity: config::Verbosity::Verbose,
-        api: api::config::ApiConfig {
-            listen_path: vec![tempfile!("a.sock")],
-            listen_fd: vec![],
-            stream_fd: vec![],
-        },
-        peers: vec![config::RosenpassPeer {
-            public_key: tempfile!("b.pk"),
-            key_out: Some(peer_a_osk.clone()),
-            endpoint: None,
-            pre_shared_key: None,
-            wg: None,
-        }],
-    };
-
-    let peer_b_keypair = config::Keypair::new(tempfile!("b.pk"), tempfile!("b.sk"));
-    let peer_b = config::Rosenpass {
-        config_file_path: tempfile!("b.config"),
-        keypair: Some(peer_b_keypair.clone()),
-        listen: vec![],
-        verbosity: config::Verbosity::Verbose,
-        api: api::config::ApiConfig {
-            listen_path: vec![tempfile!("b.sock")],
-            listen_fd: vec![],
-            stream_fd: vec![],
-        },
-        peers: vec![config::RosenpassPeer {
-            public_key: tempfile!("a.pk"),
-            key_out: Some(peer_b_osk.clone()),
-            endpoint: Some(peer_a_endpoint.to_owned()),
-            pre_shared_key: None,
-            wg: None,
-        }],
-    };
-
-    // Generate the keys
-    rosenpass::cli::testing::generate_and_save_keypair(
-        peer_a_keypair.secret_key.clone(),
-        peer_a_keypair.public_key.clone(),
-    )?;
-    rosenpass::cli::testing::generate_and_save_keypair(
-        peer_b_keypair.secret_key.clone(),
-        peer_b_keypair.public_key.clone(),
-    )?;
-
-    // Write the configuration files
-    peer_a.commit()?;
-    peer_b.commit()?;
-
-    // Start peer a
-    let mut proc_a = KillChild(
-        std::process::Command::new(env!("CARGO_BIN_EXE_rosenpass"))
-            .args([
-                "exchange-config",
-                peer_a.config_file_path.to_str().context("")?,
-            ])
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .spawn()?,
-    );
-
-    // Start peer b
-    let mut proc_b = KillChild(
-        std::process::Command::new(env!("CARGO_BIN_EXE_rosenpass"))
-            .args([
-                "exchange-config",
-                peer_b.config_file_path.to_str().context("")?,
-            ])
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .spawn()?,
-    );
-
-    // Acquire stdout
-    let mut out_a = BufReader::new(proc_a.0.stdout.take().context("")?).lines();
-    let mut out_b = BufReader::new(proc_b.0.stdout.take().context("")?).lines();
-
-    // Wait for the keys to successfully exchange a key
-    let mut attempt = 0;
-    loop {
-        let line_a = out_a.next().context("")??;
-        let line_b = out_b.next().context("")??;
-
-        let words_a = line_a.split(' ').collect::<Vec<_>>();
-        let words_b = line_b.split(' ').collect::<Vec<_>>();
-
-        // FIXED     FIXED PEER-ID                                      FIXED    FILENAME       STATUS
-        // output-key peer KZqXTZ4l2aNnkJtLPhs4D8JxHTGmRSL9w3Qr+X8JxFk= key-file "client-A-osk" exchanged
-        let peer_a_id = words_b
-            .get(2)
-            .with_context(|| format!("Bad rosenpass output: `{line_b}`"))?;
-        let peer_b_id = words_a
-            .get(2)
-            .with_context(|| format!("Bad rosenpass output: `{line_a}`"))?;
-        assert_eq!(
-            line_a,
-            format!(
-                "output-key peer {peer_b_id} key-file \"{}\" exchanged",
-                peer_a_osk.to_str().context("")?
-            )
-        );
-        assert_eq!(
-            line_b,
-            format!(
-                "output-key peer {peer_a_id} key-file \"{}\" exchanged",
-                peer_b_osk.to_str().context("")?
-            )
-        );
-
-        // Read OSKs
-        let osk_a = SymKey::load_b64::<64, _>(peer_a_osk.clone())?;
-        let osk_b = SymKey::load_b64::<64, _>(peer_b_osk.clone())?;
-        match osk_a.secret() == osk_b.secret() {
-            true => break,
-            false if attempt > 10 => bail!("Peers did not produce a matching key even after ten attempts. Something is wrong with the key exchange!"),
-            false => {},
-        };
-
-        attempt += 1;
-    }
-
-    // Now connect to the peers
-    let api_a = UnixStream::connect(&peer_a.api.listen_path[0])?;
-    let api_b = UnixStream::connect(&peer_b.api.listen_path[0])?;
-
-    for conn in ([api_a, api_b]).iter() {
-        let mut echo = [0u8; 256];
-        copy_slice_least_src("Hello World".as_bytes()).to(&mut echo);
-
-        let req = api::PingRequest::new(echo);
-        LengthPrefixEncoder::from_message(req.as_bytes()).write_all_to_stdio(conn)?;
-
-        let mut decoder = LengthPrefixDecoder::new([0u8; api::MAX_RESPONSE_LEN]);
-        let res = decoder.read_all_from_stdio(conn)?;
-        let res = res.zk_parse::<api::PingResponse>()?;
-        assert_eq!(*res, api::PingResponse::new(echo));
-    }
-
-    Ok(())
-}
--- a/rosenpass/tests/integration_test.rs
+++ b/rosenpass/tests/integration_test.rs
@@ -2,32 +2,19 @@ use std::{
    fs,
    net::UdpSocket,
    path::PathBuf,
-    sync::{Arc, Mutex},
    time::Duration,
 };

 use clap::Parser;
 use rosenpass::{app_server::AppServerTestBuilder, cli::CliArgs};
-use rosenpass_secret_memory::{Public, Secret};
-use rosenpass_wireguard_broker::{WireguardBrokerMio, WG_KEY_LEN, WG_PEER_LEN};
 use serial_test::serial;
 use std::io::Write;

 const BIN: &str = "rosenpass";

-fn setup_tests() {
-    use rosenpass_secret_memory as SM;
-    #[cfg(feature = "experiment_memfd_secret")]
-    SM::secret_policy_try_use_memfd_secrets();
-    #[cfg(not(feature = "experiment_memfd_secret"))]
-    SM::secret_policy_use_only_malloc_secrets();
-}
-
 // check that we can generate keys
 #[test]
 fn generate_keys() {
-    setup_tests();
-
    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("keygen");
    fs::create_dir_all(&tmpdir).unwrap();

@@ -104,11 +91,14 @@ fn run_server_client_exchange(
    .unwrap();

    std::thread::spawn(move || {
-        let test_helpers = server_test_builder
-            .termination_handler(Some(server_terminate_rx))
-            .build()
+        cli.command
+            .run(Some(
+                server_test_builder
+                    .termination_handler(Some(server_terminate_rx))
+                    .build()
+                    .unwrap(),
+            ))
            .unwrap();
-        cli.run(None, Some(test_helpers)).unwrap();
    });

    let cli = CliArgs::try_parse_from(
@@ -119,11 +109,14 @@ fn run_server_client_exchange(
    .unwrap();

    std::thread::spawn(move || {
-        let test_helpers = client_test_builder
-            .termination_handler(Some(client_terminate_rx))
-            .build()
+        cli.command
+            .run(Some(
+                client_test_builder
+                    .termination_handler(Some(client_terminate_rx))
+                    .build()
+                    .unwrap(),
+            ))
            .unwrap();
-        cli.run(None, Some(test_helpers)).unwrap();
    });

    // give them some time to do the key exchange under load
@@ -138,7 +131,6 @@ fn run_server_client_exchange(
 #[test]
 #[serial]
 fn check_exchange_under_normal() {
-    setup_tests();
    setup_logging();

    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange");
@@ -211,7 +203,6 @@ fn check_exchange_under_normal() {
 #[test]
 #[serial]
 fn check_exchange_under_dos() {
-    setup_tests();
    setup_logging();

    //Generate binary with responder with feature integration_test
@@ -280,66 +271,3 @@ fn check_exchange_under_dos() {
    // cleanup
    fs::remove_dir_all(&tmpdir).unwrap();
 }
-
-#[allow(dead_code)]
-#[derive(Debug, Default)]
-struct MockBrokerInner {
-    psk: Option<Secret<WG_KEY_LEN>>,
-    peer_id: Option<Public<WG_PEER_LEN>>,
-    interface: Option<String>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Default)]
-struct MockBroker {
-    inner: Arc<Mutex<MockBrokerInner>>,
-    mio_token: Option<mio::Token>,
-}
-
-impl WireguardBrokerMio for MockBroker {
-    type MioError = anyhow::Error;
-
-    fn register(
-        &mut self,
-        _registry: &mio::Registry,
-        token: mio::Token,
-    ) -> Result<(), Self::MioError> {
-        self.mio_token = Some(token);
-        Ok(())
-    }
-
-    fn process_poll(&mut self) -> Result<(), Self::MioError> {
-        Ok(())
-    }
-
-    fn unregister(&mut self, _registry: &mio::Registry) -> Result<(), Self::MioError> {
-        self.mio_token = None;
-        Ok(())
-    }
-
-    fn mio_token(&self) -> Option<mio::Token> {
-        self.mio_token
-    }
-}
-
-impl rosenpass_wireguard_broker::WireGuardBroker for MockBroker {
-    type Error = anyhow::Error;
-
-    fn set_psk(
-        &mut self,
-        config: rosenpass_wireguard_broker::SerializedBrokerConfig<'_>,
-    ) -> Result<(), Self::Error> {
-        loop {
-            let mut lock = self.inner.try_lock();
-
-            if let Ok(ref mut mutex) = lock {
-                **mutex = MockBrokerInner {
-                    psk: Some(config.psk.clone()),
-                    peer_id: Some(*config.peer_id),
-                    interface: Some(std::str::from_utf8(config.interface).unwrap().to_string()),
-                };
-                break Ok(());
-            }
-        }
-    }
-}
--- a/rp/Cargo.toml
+++ b/rp/Cargo.toml
@@ -39,5 +39,5 @@ tempfile = {workspace = true}
 stacker = {workspace = true}

 [features]
-experiment_memfd_secret = []
+enable_memfd_alloc = []
 experiment_libcrux = ["rosenpass-ciphers/experiment_libcrux"]
--- a/rp/src/exchange.rs
+++ b/rp/src/exchange.rs
@@ -188,7 +188,8 @@ pub async fn exchange(options: ExchangeOptions) -> Result<()> {
    let pk = SPk::load(&pqpk)?;

    let mut srv = Box::new(AppServer::new(
-        Some((sk, pk)),
+        sk,
+        pk,
        if let Some(listen) = options.listen {
            vec![listen]
        } else {
--- a/rp/src/main.rs
+++ b/rp/src/main.rs
@@ -11,9 +11,9 @@ mod key;

 #[tokio::main]
 async fn main() {
-    #[cfg(feature = "experiment_memfd_secret")]
+    #[cfg(feature = "enable_memfd_alloc")]
    policy::secret_policy_try_use_memfd_secrets();
-    #[cfg(not(feature = "experiment_memfd_secret"))]
+    #[cfg(not(feature = "enable_memfd_alloc"))]
    policy::secret_policy_use_only_malloc_secrets();

    let cli = match Cli::parse(std::env::args().peekable()) {
--- a/secret-memory/src/public.rs
+++ b/secret-memory/src/public.rs
@@ -317,7 +317,6 @@ impl<const N: usize> StoreValueB64Writer for PublicBox<N> {
 mod tests {

    #[cfg(test)]
-    #[allow(clippy::module_inception)]
    mod tests {
        use crate::{Public, PublicBox};
        use rosenpass_util::{
@@ -347,7 +346,7 @@ mod tests {

            // Store the original bytes to an example file in the temporary directory
            let example_file = temp_dir.path().join("example_file");
-            std::fs::write(&example_file, original_bytes).unwrap();
+            std::fs::write(example_file.clone(), &original_bytes).unwrap();

            // Load the value from the example file into our generic type
            let loaded_public = T::load(&example_file).unwrap();
--- a/secret-memory/src/secret.rs
+++ b/secret-memory/src/secret.rs
@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
+use std::convert::TryInto;
 use std::fmt;
 use std::ops::{Deref, DerefMut};
 use std::path::Path;
@@ -386,7 +387,7 @@ mod test {

            // Store the original secret to an example file in the temporary directory
            let example_file = temp_dir.path().join("example_file");
-            std::fs::write(&example_file, original_bytes).unwrap();
+            std::fs::write(example_file.clone(), &original_bytes).unwrap();

            // Load the secret from the example file
            let loaded_secret = Secret::load(&example_file).unwrap();
--- a/to/src/to/mod.rs
+++ b/to/src/to/mod.rs
@@ -6,8 +6,8 @@
 //! - `Dst: ?Sized`; (e.g. [u8]) – The target to write to
 //! - `Out: Sized = &mut Dst`; (e.g. &mut [u8]) – A reference to the target to write to
 //! - `Coercable: ?Sized + DstCoercion<Dst>`; (e.g. `[u8]`, `[u8; 16]`) – Some value that
-//!   destination coercion can be applied to. Usually either `Dst` itself (e.g. `[u8]` or some sized variant of
-//!   `Dst` (e.g. `[u8; 64]`).
+//! destination coercion can be applied to. Usually either `Dst` itself (e.g. `[u8]` or some sized variant of
+//! `Dst` (e.g. `[u8; 64]`).
 //! - `Ret: Sized`; (anything) – must be `CondenseBeside<_>` if condensing is to be applied. The ordinary return value of a function with an output
 //! - `Val: Sized + BorrowMut<Dst>`; (e.g. [u8; 16]) – Some owned storage that can be borrowed as `Dst`
 //! - `Condensed: Sized = CondenseBeside<Val>::Condensed`; (e.g. [u8; 16], Result<[u8; 16]>) – The combiation of Val and Ret after condensing was applied (`Beside<Val, Ret>::condense()`/`Ret::condense(v)` for all `v : Val`).
--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@@ -16,14 +16,5 @@ base64ct = { workspace = true }
 anyhow = { workspace = true }
 typenum = { workspace = true }
 static_assertions = { workspace = true }
-rustix = { workspace = true }
-zeroize = { workspace = true }
-zerocopy = { workspace = true }
-thiserror = { workspace = true }
-mio = { workspace = true }
-tempfile = { workspace = true }
-uds = { workspace = true, optional = true, features = ["mio_1xx"] }
-
-
-[features]
-experiment_file_descriptor_passing = ["uds"]
+rustix = {workspace = true}
+zeroize = {workspace = true}
--- a/util/src/build.rs
+++ b/util/src/build.rs
@@ -1,169 +0,0 @@
-use crate::{
-    functional::ApplyExt,
-    mem::{SwapWithDefaultExt, SwapWithExt},
-};
-
-#[derive(thiserror::Error, Debug)]
-pub enum ConstructionSiteErectError<E> {
-    #[error("Construction site is void")]
-    IsVoid,
-    #[error("Construction is already built")]
-    AlreadyBuilt,
-    #[error("Other construction site error {0:?}")]
-    Other(#[from] E),
-}
-
-pub trait Build<T>: Sized {
-    type Error;
-    fn build(self) -> Result<T, Self::Error>;
-}
-
-#[derive(Debug)]
-pub enum ConstructionSite<Builder, T>
-where
-    Builder: Build<T>,
-{
-    Void,
-    Builder(Builder),
-    Product(T),
-}
-
-impl<Builder, T> Default for ConstructionSite<Builder, T>
-where
-    Builder: Build<T>,
-{
-    fn default() -> Self {
-        Self::Void
-    }
-}
-
-impl<Builder, T> ConstructionSite<Builder, T>
-where
-    Builder: Build<T>,
-{
-    pub fn void() -> Self {
-        Self::Void
-    }
-
-    pub fn new(builder: Builder) -> Self {
-        Self::Builder(builder)
-    }
-
-    pub fn from_product(value: T) -> Self {
-        Self::Product(value)
-    }
-
-    pub fn take(&mut self) -> Self {
-        self.swap_with_default()
-    }
-
-    pub fn modify_taken_with_return<R, F>(&mut self, f: F) -> R
-    where
-        F: FnOnce(Self) -> (Self, R),
-    {
-        let (site, res) = self.take().apply(f);
-        self.swap_with(site);
-        res
-    }
-
-    pub fn modify_taken<F>(&mut self, f: F)
-    where
-        F: FnOnce(Self) -> Self,
-    {
-        self.take().apply(f).swap_with_mut(self)
-    }
-
-    #[allow(clippy::result_unit_err)]
-    pub fn erect(&mut self) -> Result<(), ConstructionSiteErectError<Builder::Error>> {
-        self.modify_taken_with_return(|site| {
-            let builder = match site {
-                site @ Self::Void => return (site, Err(ConstructionSiteErectError::IsVoid)),
-                site @ Self::Product(_) => {
-                    return (site, Err(ConstructionSiteErectError::AlreadyBuilt))
-                }
-                Self::Builder(builder) => builder,
-            };
-
-            let product = match builder.build() {
-                Err(e) => {
-                    return (Self::void(), Err(ConstructionSiteErectError::Other(e)));
-                }
-                Ok(p) => p,
-            };
-
-            (Self::from_product(product), Ok(()))
-        })
-    }
-
-    /// Returns `true` if the construction site is [`Void`].
-    ///
-    /// [`Void`]: ConstructionSite::Void
-    #[must_use]
-    pub fn is_void(&self) -> bool {
-        matches!(self, Self::Void)
-    }
-
-    /// Returns `true` if the construction site is [`InProgress`].
-    ///
-    /// [`InProgress`]: ConstructionSite::InProgress
-    #[must_use]
-    pub fn in_progess(&self) -> bool {
-        matches!(self, Self::Builder(..))
-    }
-
-    /// Returns `true` if the construction site is [`Done`].
-    ///
-    /// [`Done`]: ConstructionSite::Done
-    #[must_use]
-    pub fn is_available(&self) -> bool {
-        matches!(self, Self::Product(..))
-    }
-
-    pub fn into_builder(self) -> Option<Builder> {
-        use ConstructionSite as S;
-        match self {
-            S::Builder(v) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn builder_ref(&self) -> Option<&Builder> {
-        use ConstructionSite as S;
-        match self {
-            S::Builder(v) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn builder_mut(&mut self) -> Option<&mut Builder> {
-        use ConstructionSite as S;
-        match self {
-            S::Builder(v) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn into_product(self) -> Option<T> {
-        use ConstructionSite as S;
-        match self {
-            S::Product(v) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn product_ref(&self) -> Option<&T> {
-        use ConstructionSite as S;
-        match self {
-            S::Product(v) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn product_mut(&mut self) -> Option<&mut T> {
-        use ConstructionSite as S;
-        match self {
-            S::Product(v) => Some(v),
-            _ => None,
-        }
-    }
-}
--- a/util/src/controlflow.rs
+++ b/util/src/controlflow.rs
@@ -1,149 +0,0 @@
-/// A collection of control flow utility macros
-
-#[macro_export]
-/// A simple for loop to repeat a $body a number of times
-macro_rules! repeat {
-    ($times:expr, $body:expr) => {
-        for _ in 0..($times) {
-            $body
-        }
-    };
-}
-
-#[macro_export]
-/// Return unless the condition $cond is true, with return value $val, if given.
-macro_rules! return_unless {
-    ($cond:expr) => {
-        if !($cond) {
-            return;
-        }
-    };
-    ($cond:expr, $val:expr) => {
-        if !($cond) {
-            return $val;
-        }
-    };
-}
-
-#[macro_export]
-/// Return if the condition $cond is true, with return value $val, if given.
-macro_rules! return_if {
-    ($cond:expr) => {
-        if $cond {
-            return;
-        }
-    };
-    ($cond:expr, $val:expr) => {
-        if $cond {
-            return $val;
-        }
-    };
-}
-
-#[macro_export]
-/// Break unless the condition is true, from the loop with label $val, if given.
-macro_rules! break_if {
-    ($cond:expr) => {
-        if $cond {
-            break;
-        }
-    };
-    ($cond:expr, $val:tt) => {
-        if $cond {
-            break $val;
-        }
-    };
-}
-
-#[macro_export]
-/// Continue if the condition is true, in the loop with label $val, if given.
-macro_rules! continue_if {
-    ($cond:expr) => {
-        if $cond {
-            continue;
-        }
-    };
-    ($cond:expr, $val:tt) => {
-        if $cond {
-            continue $val;
-        }
-    };
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_repeat() {
-        let mut sum = 0;
-        repeat!(10, {
-            sum += 1;
-        });
-        assert_eq!(sum, 10);
-    }
-
-    #[test]
-    fn test_return_unless() {
-        fn test_fn() -> i32 {
-            return_unless!(true, 1);
-            0
-        }
-        assert_eq!(test_fn(), 0);
-
-        fn test_fn2() -> i32 {
-            return_unless!(false, 1);
-            0
-        }
-        assert_eq!(test_fn2(), 1);
-    }
-
-    #[test]
-    fn test_return_if() {
-        fn test_fn() -> i32 {
-            return_if!(true, 1);
-            0
-        }
-        assert_eq!(test_fn(), 1);
-
-        fn test_fn2() -> i32 {
-            return_if!(false, 1);
-            0
-        }
-        assert_eq!(test_fn2(), 0);
-    }
-
-    #[test]
-    fn test_break_if() {
-        let mut sum = 0;
-        for i in 0..10 {
-            break_if!(i == 5);
-            sum += 1;
-        }
-        assert_eq!(sum, 5);
-
-        let mut sum = 0;
-        'one: for _ in 0..10 {
-            for j in 0..20 {
-                break_if!(j == 5, 'one);
-                sum += 1;
-            }
-        }
-        assert_eq!(sum, 5);
-    }
-
-    #[test]
-    fn test_continue_if() {
-        let mut sum = 0;
-        for i in 0..10 {
-            continue_if!(i == 5);
-            sum += 1;
-        }
-        assert_eq!(sum, 9);
-
-        let mut sum = 0;
-        'one: for i in 0..10 {
-            continue_if!(i == 5, 'one);
-            sum += 1;
-        }
-        assert_eq!(sum, 9);
-    }
-}
--- a/util/src/fd.rs
+++ b/util/src/fd.rs
@@ -1,300 +1,12 @@
-use anyhow::bail;
-use rustix::{
-    fd::{AsFd, BorrowedFd, FromRawFd, OwnedFd, RawFd},
-    io::fcntl_dupfd_cloexec,
-};
+use std::os::fd::{OwnedFd, RawFd};

-use crate::{mem::Forgetting, result::OkExt};
-
-/// Prepare a file descriptor for use in Rust code.
+/// Clone some file descriptor
 ///
+/// If the file descriptor is invalid, an error will be raised.
+pub fn claim_fd(fd: RawFd) -> anyhow::Result<OwnedFd> {
+    use rustix::{fd::BorrowedFd, io::dup};

-/// Checks if the file descriptor is valid and duplicates it to a new file descriptor.
-/// The old file descriptor is masked to avoid potential use after free (on file descriptor)
-/// in case the given file descriptor is still used somewhere
-pub fn claim_fd(fd: RawFd) -> rustix::io::Result<OwnedFd> {
-    let new = clone_fd_cloexec(unsafe { BorrowedFd::borrow_raw(fd) })?;
-    mask_fd(fd)?;
-    Ok(new)
-}
-
-/// Prepare a file descriptor for use in Rust code.
-///
-/// Checks if the file descriptor is valid.
-///
-/// Unlike [claim_fd], this will reuse the same file descriptor identifier instead of masking it.
-pub fn claim_fd_inplace(fd: RawFd) -> rustix::io::Result<OwnedFd> {
-    let mut new = unsafe { OwnedFd::from_raw_fd(fd) };
-    let tmp = clone_fd_cloexec(&new)?;
-    clone_fd_to_cloexec(tmp, &mut new)?;
-    Ok(new)
-}
-
-pub fn mask_fd(fd: RawFd) -> rustix::io::Result<()> {
-    // Safety: because the OwnedFd resulting from OwnedFd::from_raw_fd is wrapped in a Forgetting,
-    // it never gets dropped, meaning that fd is never closed and thus outlives the OwnedFd
-    let mut owned = Forgetting::new(unsafe { OwnedFd::from_raw_fd(fd) });
-    clone_fd_to_cloexec(open_nullfd()?, &mut owned)
-}
-
-pub fn clone_fd_cloexec<Fd: AsFd>(fd: Fd) -> rustix::io::Result<OwnedFd> {
-    const MINFD: RawFd = 3; // Avoid stdin, stdout, and stderr
-    fcntl_dupfd_cloexec(fd, MINFD)
-}
-
-#[cfg(target_os = "linux")]
-pub fn clone_fd_to_cloexec<Fd: AsFd>(fd: Fd, new: &mut OwnedFd) -> rustix::io::Result<()> {
-    use rustix::io::{dup3, DupFlags};
-    dup3(fd, new, DupFlags::CLOEXEC)
-}
-
-#[cfg(not(target_os = "linux"))]
-pub fn clone_fd_to_cloexec<Fd: AsFd>(fd: Fd, new: &mut OwnedFd) -> rustix::io::Result<()> {
-    use rustix::io::{dup2, fcntl_setfd, FdFlags};
-    dup2(&fd, new)?;
-    fcntl_setfd(&new, FdFlags::CLOEXEC)
-}
-
-/// Open a "blocked" file descriptor. I.e. a file descriptor that is neither meant for reading nor
-/// writing
-pub fn open_nullfd() -> rustix::io::Result<OwnedFd> {
-    use rustix::fs::{open, Mode, OFlags};
-    // TODO: Add tests showing that this will throw errors on use
-    open("/dev/null", OFlags::CLOEXEC, Mode::empty())
-}
-
-/// Convert low level errors into std::io::Error
-pub trait IntoStdioErr {
-    type Target;
-    fn into_stdio_err(self) -> Self::Target;
-}
-
-impl IntoStdioErr for rustix::io::Errno {
-    type Target = std::io::Error;
-
-    fn into_stdio_err(self) -> Self::Target {
-        std::io::Error::from_raw_os_error(self.raw_os_error())
-    }
-}
-
-impl<T> IntoStdioErr for rustix::io::Result<T> {
-    type Target = std::io::Result<T>;
-
-    fn into_stdio_err(self) -> Self::Target {
-        self.map_err(IntoStdioErr::into_stdio_err)
-    }
-}
-
-/// Read and write directly from a file descriptor
-pub struct FdIo<Fd: AsFd>(pub Fd);
-
-impl<Fd: AsFd> std::io::Read for FdIo<Fd> {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        rustix::io::read(&self.0, buf).into_stdio_err()
-    }
-}
-
-impl<Fd: AsFd> std::io::Write for FdIo<Fd> {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        rustix::io::write(&self.0, buf).into_stdio_err()
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-pub trait StatExt {
-    fn is_socket(&self) -> bool;
-}
-
-impl StatExt for rustix::fs::Stat {
-    fn is_socket(&self) -> bool {
-        use rustix::fs::FileType;
-        let ft = FileType::from_raw_mode(self.st_mode);
-        matches!(ft, FileType::Socket)
-    }
-}
-
-pub trait TryStatExt {
-    type Error;
-    fn is_socket(&self) -> Result<bool, Self::Error>;
-}
-
-impl<T> TryStatExt for T
-where
-    T: AsFd,
-{
-    type Error = rustix::io::Errno;
-
-    fn is_socket(&self) -> Result<bool, Self::Error> {
-        rustix::fs::fstat(self)?.is_socket().ok()
-    }
-}
-
-pub trait GetSocketType {
-    type Error;
-    fn socket_type(&self) -> Result<rustix::net::SocketType, Self::Error>;
-    fn is_datagram_socket(&self) -> Result<bool, Self::Error> {
-        use rustix::net::SocketType;
-        matches!(self.socket_type()?, SocketType::DGRAM).ok()
-    }
-    fn is_stream_socket(&self) -> Result<bool, Self::Error> {
-        Ok(self.socket_type()? == rustix::net::SocketType::STREAM)
-    }
-}
-
-impl<T> GetSocketType for T
-where
-    T: AsFd,
-{
-    type Error = rustix::io::Errno;
-
-    fn socket_type(&self) -> Result<rustix::net::SocketType, Self::Error> {
-        rustix::net::sockopt::get_socket_type(self)
-    }
-}
-
-#[cfg(target_os = "linux")]
-pub trait GetSocketDomain {
-    type Error;
-    fn socket_domain(&self) -> Result<rustix::net::AddressFamily, Self::Error>;
-    fn socket_address_family(&self) -> Result<rustix::net::AddressFamily, Self::Error> {
-        self.socket_domain()
-    }
-    fn is_unix_socket(&self) -> Result<bool, Self::Error> {
-        Ok(self.socket_domain()? == rustix::net::AddressFamily::UNIX)
-    }
-}
-
-#[cfg(target_os = "linux")]
-impl<T> GetSocketDomain for T
-where
-    T: AsFd,
-{
-    type Error = rustix::io::Errno;
-
-    fn socket_domain(&self) -> Result<rustix::net::AddressFamily, Self::Error> {
-        rustix::net::sockopt::get_socket_domain(self)
-    }
-}
-
-#[cfg(target_os = "linux")]
-pub trait GetUnixSocketType {
-    type Error;
-    fn is_unix_stream_socket(&self) -> Result<bool, Self::Error>;
-    fn demand_unix_stream_socket(&self) -> anyhow::Result<()>;
-}
-
-#[cfg(target_os = "linux")]
-impl<T> GetUnixSocketType for T
-where
-    T: GetSocketType + GetSocketDomain<Error = <T as GetSocketType>::Error>,
-    anyhow::Error: From<<T as GetSocketType>::Error>,
-{
-    type Error = <T as GetSocketType>::Error;
-
-    fn is_unix_stream_socket(&self) -> Result<bool, Self::Error> {
-        Ok(self.is_unix_socket()? && self.is_stream_socket()?)
-    }
-
-    fn demand_unix_stream_socket(&self) -> anyhow::Result<()> {
-        use rustix::net::AddressFamily as SA;
-        use rustix::net::SocketType as ST;
-        match (self.socket_domain()?, self.socket_type()?) {
-            (SA::UNIX, ST::STREAM) => Ok(()),
-            (SA::UNIX, mode) => bail!("Expected unix socket in stream mode, but mode is {mode:?}"),
-            (domain, _) => bail!("Expected unix socket, but socket domain is {domain:?} instead"),
-        }
-    }
-}
-
-#[cfg(target_os = "linux")]
-pub trait GetSocketProtocol {
-    fn socket_protocol(&self) -> Result<Option<rustix::net::Protocol>, rustix::io::Errno>;
-    fn is_udp_socket(&self) -> Result<bool, rustix::io::Errno> {
-        self.socket_protocol()?
-            .map(|p| p == rustix::net::ipproto::UDP)
-            .unwrap_or(false)
-            .ok()
-    }
-    fn demand_udp_socket(&self) -> anyhow::Result<()> {
-        match self.socket_protocol() {
-            Ok(Some(rustix::net::ipproto::UDP)) => Ok(()),
-            Ok(Some(other_proto)) => {
-                bail!("Not a udp socket, instead socket protocol is: {other_proto:?}")
-            }
-            Ok(None) => bail!("getsockopt() returned empty value"),
-            Err(errno) => Err(errno.into_stdio_err())?,
-        }
-    }
-}
-
-#[cfg(target_os = "linux")]
-impl<T> GetSocketProtocol for T
-where
-    T: AsFd,
-{
-    fn socket_protocol(&self) -> Result<Option<rustix::net::Protocol>, rustix::io::Errno> {
-        rustix::net::sockopt::get_socket_protocol(self)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{read_to_string, File};
-    use std::io::{Read, Write};
-    use std::os::fd::IntoRawFd;
-    use tempfile::tempdir;
-
-    #[test]
-    fn test_claim_fd() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let file = File::create(path.clone()).unwrap();
-        let fd: RawFd = file.into_raw_fd();
-        let owned_fd = claim_fd(fd).unwrap();
-        let mut file = unsafe { File::from_raw_fd(owned_fd.into_raw_fd()) };
-        file.write_all(b"Hello, World!").unwrap();
-
-        let message = read_to_string(path).unwrap();
-        assert_eq!(message, "Hello, World!");
-    }
-
-    #[test]
-    #[should_panic(expected = "fd != u32::MAX as RawFd")]
-    fn test_claim_fd_invalid_neg() {
-        let fd: RawFd = -1;
-        let _ = claim_fd(fd);
-    }
-
-    #[test]
-    #[should_panic(expected = "fd != u32::MAX as RawFd")]
-    fn test_claim_fd_invalid_max() {
-        let fd: RawFd = i64::MAX as RawFd;
-        let _ = claim_fd(fd);
-    }
-
-    #[test]
-    fn test_open_nullfd_write() {
-        let nullfd = open_nullfd().unwrap();
-        let mut file = unsafe { File::from_raw_fd(nullfd.into_raw_fd()) };
-        let res = file.write_all(b"Hello, World!");
-        assert!(res.is_err());
-        assert_eq!(
-            res.unwrap_err().to_string(),
-            "Bad file descriptor (os error 9)"
-        );
-    }
-
-    #[test]
-    fn test_open_nullfd_read() {
-        let nullfd = open_nullfd().unwrap();
-        let mut file = unsafe { File::from_raw_fd(nullfd.into_raw_fd()) };
-        let mut buffer = [0; 10];
-        let res = file.read_exact(&mut buffer);
-        assert!(res.is_err());
-        assert_eq!(res.unwrap_err().to_string(), "failed to fill whole buffer");
-    }
+    // This is safe since [dup] will simply raise
+    let fd = unsafe { dup(BorrowedFd::borrow_raw(fd))? };
+    Ok(fd)
 }
--- a/util/src/file.rs
+++ b/util/src/file.rs
@@ -2,6 +2,7 @@ use anyhow::ensure;
 use std::fs::File;
 use std::io::Read;
 use std::os::unix::fs::OpenOptionsExt;
+use std::result::Result;
 use std::{fs::OpenOptions, path::Path};

 pub enum Visibility {
@@ -114,96 +115,3 @@ pub trait DisplayValueB64 {

    fn display_b64<'o>(&self, output: &'o mut [u8]) -> Result<&'o str, Self::Error>;
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::File;
-    use std::io::Write;
-    use std::os::unix::fs::PermissionsExt;
-    use tempfile::tempdir;
-
-    #[test]
-    fn test_fopen_w_public() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = fopen_w(path, Visibility::Public).unwrap();
-        file.write_all(b"test").unwrap();
-        let metadata = file.metadata().unwrap();
-        let permissions = metadata.permissions();
-        assert_eq!(permissions.mode(), 0o100644);
-    }
-
-    #[test]
-    fn test_fopen_w_secret() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = fopen_w(path, Visibility::Secret).unwrap();
-        file.write_all(b"test").unwrap();
-        let metadata = file.metadata().unwrap();
-        let permissions = metadata.permissions();
-        assert_eq!(permissions.mode(), 0o100600);
-    }
-
-    #[test]
-    fn test_fopen_r() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = File::create(path.clone()).unwrap();
-        file.write_all(b"test").unwrap();
-        let mut contents = String::new();
-        let mut file = fopen_r(path).unwrap();
-        file.read_to_string(&mut contents).unwrap();
-        assert_eq!(contents, "test");
-    }
-
-    #[test]
-    fn test_read_slice_to_end() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = File::create(path.clone()).unwrap();
-        file.write_all(b"test").unwrap();
-        let mut buf = [0u8; 4];
-        let mut file = fopen_r(path).unwrap();
-        file.read_slice_to_end(&mut buf).unwrap();
-        assert_eq!(buf, [116, 101, 115, 116]);
-    }
-
-    #[test]
-    fn test_read_exact_to_end() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = File::create(path.clone()).unwrap();
-        file.write_all(b"test").unwrap();
-        let mut buf = [0u8; 4];
-        let mut file = fopen_r(path).unwrap();
-        file.read_exact_to_end(&mut buf).unwrap();
-        assert_eq!(buf, [116, 101, 115, 116]);
-    }
-
-    #[test]
-    fn test_read_exact_to_end_to_long() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = File::create(path.clone()).unwrap();
-        file.write_all(b"test").unwrap();
-        let mut buf = [0u8; 3];
-        let mut file = fopen_r(path).unwrap();
-        let result = file.read_exact_to_end(&mut buf);
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err().to_string(), "File too long!");
-    }
-
-    #[test]
-    fn test_read_slice_to_end_to_long() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().join("test");
-        let mut file = File::create(path.clone()).unwrap();
-        file.write_all(b"test").unwrap();
-        let mut buf = [0u8; 3];
-        let mut file = fopen_r(path).unwrap();
-        let result = file.read_slice_to_end(&mut buf);
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err().to_string(), "File too long!");
-    }
-}
--- a/util/src/functional.rs
+++ b/util/src/functional.rs
@@ -6,32 +6,6 @@ where
    v
 }

-pub trait MutatingExt {
-    fn mutating<F>(self, f: F) -> Self
-    where
-        F: Fn(&mut Self);
-    fn mutating_mut<F>(&mut self, f: F) -> &mut Self
-    where
-        F: Fn(&mut Self);
-}
-
-impl<T> MutatingExt for T {
-    fn mutating<F>(self, f: F) -> Self
-    where
-        F: Fn(&mut Self),
-    {
-        mutating(self, f)
-    }
-
-    fn mutating_mut<F>(&mut self, f: F) -> &mut Self
-    where
-        F: Fn(&mut Self),
-    {
-        f(self);
-        self
-    }
-}
-
 pub fn sideeffect<T, F>(v: T, f: F) -> T
 where
    F: Fn(&T),
@@ -39,59 +13,3 @@ where
    f(&v);
    v
 }
-
-pub trait SideffectExt {
-    fn sideeffect<F>(self, f: F) -> Self
-    where
-        F: Fn(&Self);
-    fn sideeffect_ref<F>(&self, f: F) -> &Self
-    where
-        F: Fn(&Self);
-    fn sideeffect_mut<F>(&mut self, f: F) -> &mut Self
-    where
-        F: Fn(&Self);
-}
-
-impl<T> SideffectExt for T {
-    fn sideeffect<F>(self, f: F) -> Self
-    where
-        F: Fn(&Self),
-    {
-        sideeffect(self, f)
-    }
-
-    fn sideeffect_ref<F>(&self, f: F) -> &Self
-    where
-        F: Fn(&Self),
-    {
-        f(self);
-        self
-    }
-
-    fn sideeffect_mut<F>(&mut self, f: F) -> &mut Self
-    where
-        F: Fn(&Self),
-    {
-        f(self);
-        self
-    }
-}
-
-pub fn run<R, F: FnOnce() -> R>(f: F) -> R {
-    f()
-}
-
-pub trait ApplyExt: Sized {
-    fn apply<R, F>(self, f: F) -> R
-    where
-        F: FnOnce(Self) -> R;
-}
-
-impl<T: Sized> ApplyExt for T {
-    fn apply<R, F>(self, f: F) -> R
-    where
-        F: FnOnce(Self) -> R,
-    {
-        f(self)
-    }
-}
--- a/util/src/io.rs
+++ b/util/src/io.rs
@@ -1,180 +0,0 @@
-use std::{borrow::Borrow, io};
-
-use anyhow::ensure;
-
-pub trait IoErrorKind {
-    fn io_error_kind(&self) -> io::ErrorKind;
-}
-
-impl<T: Borrow<io::Error>> IoErrorKind for T {
-    fn io_error_kind(&self) -> io::ErrorKind {
-        self.borrow().kind()
-    }
-}
-
-pub trait TryIoErrorKind {
-    fn try_io_error_kind(&self) -> Option<io::ErrorKind>;
-}
-
-impl<T: IoErrorKind> TryIoErrorKind for T {
-    fn try_io_error_kind(&self) -> Option<io::ErrorKind> {
-        Some(self.io_error_kind())
-    }
-}
-
-pub trait IoResultKindHintExt<T>: Sized {
-    type Error;
-    fn io_err_kind_hint(self) -> Result<T, (Self::Error, io::ErrorKind)>;
-}
-
-impl<T, E: IoErrorKind> IoResultKindHintExt<T> for Result<T, E> {
-    type Error = E;
-    fn io_err_kind_hint(self) -> Result<T, (E, io::ErrorKind)> {
-        self.map_err(|e| {
-            let kind = e.borrow().io_error_kind();
-            (e, kind)
-        })
-    }
-}
-
-pub trait TryIoResultKindHintExt<T>: Sized {
-    type Error;
-    fn try_io_err_kind_hint(self) -> Result<T, (Self::Error, Option<io::ErrorKind>)>;
-}
-
-impl<T, E: TryIoErrorKind> TryIoResultKindHintExt<T> for Result<T, E> {
-    type Error = E;
-    fn try_io_err_kind_hint(self) -> Result<T, (E, Option<io::ErrorKind>)> {
-        self.map_err(|e| {
-            let opt_kind = e.borrow().try_io_error_kind();
-            (e, opt_kind)
-        })
-    }
-}
-
-pub trait SubstituteForIoErrorKindExt<T>: Sized {
-    type Error;
-    fn substitute_for_ioerr_kind_with<F: FnOnce() -> T>(
-        self,
-        kind: io::ErrorKind,
-        f: F,
-    ) -> Result<T, Self::Error>;
-    fn substitute_for_ioerr_kind(self, kind: io::ErrorKind, v: T) -> Result<T, Self::Error> {
-        self.substitute_for_ioerr_kind_with(kind, || v)
-    }
-
-    fn substitute_for_ioerr_interrupted_with<F: FnOnce() -> T>(
-        self,
-        f: F,
-    ) -> Result<T, Self::Error> {
-        self.substitute_for_ioerr_kind_with(io::ErrorKind::Interrupted, f)
-    }
-
-    fn substitute_for_ioerr_interrupted(self, v: T) -> Result<T, Self::Error> {
-        self.substitute_for_ioerr_interrupted_with(|| v)
-    }
-
-    fn substitute_for_ioerr_wouldblock_with<F: FnOnce() -> T>(
-        self,
-        f: F,
-    ) -> Result<T, Self::Error> {
-        self.substitute_for_ioerr_kind_with(io::ErrorKind::WouldBlock, f)
-    }
-
-    fn substitute_for_ioerr_wouldblock(self, v: T) -> Result<T, Self::Error> {
-        self.substitute_for_ioerr_wouldblock_with(|| v)
-    }
-}
-
-impl<T, E: TryIoErrorKind> SubstituteForIoErrorKindExt<T> for Result<T, E> {
-    type Error = E;
-
-    fn substitute_for_ioerr_kind_with<F: FnOnce() -> T>(
-        self,
-        kind: io::ErrorKind,
-        f: F,
-    ) -> Result<T, Self::Error> {
-        match self.try_io_err_kind_hint() {
-            Ok(v) => Ok(v),
-            Err((_, Some(k))) if k == kind => Ok(f()),
-            Err((e, _)) => Err(e),
-        }
-    }
-}
-
-/// Automatically handles `std::io::ErrorKind::Interrupted`.
-///
-/// - If there is no error (i.e. on `Ok(r)`), the function will return `Ok(Some(r))`
-/// - `Interrupted` is handled internally, by retrying the IO operation
-/// - Other errors are returned as is
-pub fn handle_interrupted<R, E, F>(mut iofn: F) -> Result<Option<R>, E>
-where
-    E: TryIoErrorKind,
-    F: FnMut() -> Result<R, E>,
-{
-    use io::ErrorKind as E;
-    loop {
-        match iofn().try_io_err_kind_hint() {
-            Ok(v) => return Ok(Some(v)),
-            Err((_, Some(E::Interrupted))) => continue, // try again
-            Err((e, _)) => return Err(e),
-        };
-    }
-}
-
-/// Automatically handles `std::io::ErrorKind::{WouldBlock, Interrupted}`.
-///
-/// - If there is no error (i.e. on `Ok(r)`), the function will return `Ok(Some(r))`
-/// - `Interrupted` is handled internally, by retrying the IO operation
-/// - `WouldBlock` is handled by returning `Ok(None)`,
-/// - Other errors are returned as is
-pub fn nonblocking_handle_io_errors<R, E, F>(mut iofn: F) -> Result<Option<R>, E>
-where
-    E: TryIoErrorKind,
-    F: FnMut() -> Result<R, E>,
-{
-    use io::ErrorKind as E;
-    loop {
-        match iofn().try_io_err_kind_hint() {
-            Ok(v) => return Ok(Some(v)),
-            Err((_, Some(E::WouldBlock))) => return Ok(None), // no data to read
-            Err((_, Some(E::Interrupted))) => continue,       // try again
-            Err((e, _)) => return Err(e),
-        };
-    }
-}
-
-pub trait ReadNonblockingWithBoringErrorsHandledExt {
-    /// Convenience wrapper using [nonblocking_handle_io_errors] with [std::io::Read]
-    fn read_nonblocking_with_boring_errors_handled(
-        &mut self,
-        buf: &mut [u8],
-    ) -> io::Result<Option<usize>>;
-}
-
-impl<T: io::Read> ReadNonblockingWithBoringErrorsHandledExt for T {
-    fn read_nonblocking_with_boring_errors_handled(
-        &mut self,
-        buf: &mut [u8],
-    ) -> io::Result<Option<usize>> {
-        nonblocking_handle_io_errors(|| self.read(buf))
-    }
-}
-
-pub trait ReadExt {
-    fn read_exact_til_end(&mut self, buf: &mut [u8]) -> anyhow::Result<()>;
-}
-
-impl<T> ReadExt for T
-where
-    T: std::io::Read,
-{
-    fn read_exact_til_end(&mut self, buf: &mut [u8]) -> anyhow::Result<()> {
-        self.read_exact(buf)?;
-        ensure!(
-            self.read(&mut [0u8; 8])? == 0,
-            "Read source longer than buffer"
-        );
-        Ok(())
-    }
-}
--- a/util/src/length_prefix_encoding/decoder.rs
+++ b/util/src/length_prefix_encoding/decoder.rs
@@ -1,359 +0,0 @@
-use std::{borrow::BorrowMut, cmp::min, io};
-
-use thiserror::Error;
-use zeroize::Zeroize;
-
-use crate::{
-    io::{TryIoErrorKind, TryIoResultKindHintExt},
-    result::ensure_or,
-};
-
-pub const HEADER_SIZE: usize = std::mem::size_of::<u64>();
-
-#[derive(Error, Debug)]
-pub enum SanityError {
-    #[error("Offset is out of read buffer bounds")]
-    OutOfBufferBounds,
-    #[error("Offset is out of message buffer bounds")]
-    OutOfMessageBounds,
-}
-
-#[derive(Error, Debug)]
-#[error("Message too large ({msg_size} bytes) for buffer ({buf_size} bytes)")]
-pub struct MessageTooLargeError {
-    msg_size: usize,
-    buf_size: usize,
-}
-
-impl MessageTooLargeError {
-    pub fn new(msg_size: usize, buf_size: usize) -> Self {
-        Self { msg_size, buf_size }
-    }
-
-    pub fn ensure(msg_size: usize, buf_size: usize) -> Result<(), Self> {
-        let err = MessageTooLargeError { msg_size, buf_size };
-        ensure_or(msg_size <= buf_size, err)
-    }
-}
-
-#[derive(Debug)]
-pub struct ReadFromIoReturn<'a> {
-    pub bytes_read: usize,
-    pub message: Option<&'a mut [u8]>,
-}
-
-impl<'a> ReadFromIoReturn<'a> {
-    pub fn new(bytes_read: usize, message: Option<&'a mut [u8]>) -> Self {
-        Self {
-            bytes_read,
-            message,
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum ReadFromIoError {
-    #[error("Error reading from the underlying stream")]
-    IoError(#[from] io::Error),
-    #[error("Message size out of buffer bounds")]
-    MessageTooLargeError(#[from] MessageTooLargeError),
-}
-
-impl TryIoErrorKind for ReadFromIoError {
-    fn try_io_error_kind(&self) -> Option<io::ErrorKind> {
-        match self {
-            ReadFromIoError::IoError(ioe) => Some(ioe.kind()),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct LengthPrefixDecoder<Buf: BorrowMut<[u8]>> {
-    header: [u8; HEADER_SIZE],
-    buf: Buf,
-    off: usize,
-}
-
-impl<Buf: BorrowMut<[u8]>> LengthPrefixDecoder<Buf> {
-    pub fn new(buf: Buf) -> Self {
-        let header = Default::default();
-        let off = 0;
-        Self { header, buf, off }
-    }
-
-    pub fn clear(&mut self) {
-        self.zeroize()
-    }
-
-    pub fn from_parts(header: [u8; HEADER_SIZE], buf: Buf, off: usize) -> Self {
-        Self { header, buf, off }
-    }
-
-    pub fn into_parts(self) -> ([u8; HEADER_SIZE], Buf, usize) {
-        let Self { header, buf, off } = self;
-        (header, buf, off)
-    }
-
-    pub fn read_all_from_stdio<R: io::Read>(
-        &mut self,
-        mut r: R,
-    ) -> Result<&mut [u8], ReadFromIoError> {
-        use io::ErrorKind as K;
-        loop {
-            match self.read_from_stdio(&mut r).try_io_err_kind_hint() {
-                // Success (appeasing the borrow checker by calling message_mut())
-                Ok(ReadFromIoReturn {
-                    message: Some(_), ..
-                }) => break Ok(self.message_mut().unwrap().unwrap()),
-
-                // Unexpected EOF
-                Ok(ReadFromIoReturn { bytes_read: 0, .. }) => {
-                    break Err(ReadFromIoError::IoError(io::Error::new(
-                        K::UnexpectedEof,
-                        "",
-                    )))
-                }
-
-                // Retry
-                Ok(ReadFromIoReturn { message: None, .. }) => continue,
-                Err((_, Some(K::Interrupted))) => continue,
-
-                // Other error
-                Err((e, _)) => break Err(e),
-            }
-        }
-    }
-
-    pub fn read_from_stdio<R: io::Read>(
-        &mut self,
-        mut r: R,
-    ) -> Result<ReadFromIoReturn, ReadFromIoError> {
-        Ok(match self.next_slice_to_write_to()? {
-            // Read some bytes; any MessageTooLargeError in the call to self.message_mut() is
-            // ignored to ensure this function changes no state upon errors; the user should rerun
-            // the function and collect the MessageTooLargeError on the following invocation
-            Some(buf) => {
-                let bytes_read = r.read(buf)?;
-                self.advance(bytes_read).unwrap();
-                let message = self.message_mut().ok().flatten();
-                ReadFromIoReturn {
-                    bytes_read,
-                    message,
-                }
-            }
-            // Message is already fully read; full delegation to self.message_mut()
-            None => ReadFromIoReturn {
-                bytes_read: 0,
-                message: self.message_mut()?,
-            },
-        })
-    }
-
-    pub fn next_slice_to_write_to(&mut self) -> Result<Option<&mut [u8]>, MessageTooLargeError> {
-        fn some_if_nonempty(buf: &mut [u8]) -> Option<&mut [u8]> {
-            match buf.is_empty() {
-                true => None,
-                false => Some(buf),
-            }
-        }
-
-        macro_rules! return_if_nonempty_some {
-            ($opt:expr) => {{
-                // Deliberate double expansion of $opt to appease the borrow checker *sigh*
-                if $opt.and_then(some_if_nonempty).is_some() {
-                    return Ok($opt);
-                }
-            }};
-        }
-
-        return_if_nonempty_some!(Some(self.header_buffer_left_mut()));
-        return_if_nonempty_some!(self.message_fragment_left_mut()?);
-        Ok(None)
-    }
-
-    pub fn advance(&mut self, count: usize) -> Result<(), SanityError> {
-        let off = self.off + count;
-        let msg_off = off.saturating_sub(HEADER_SIZE);
-
-        use SanityError as E;
-        let alloc = self.message_buffer().len();
-        let msgsz = self.message_size();
-        ensure_or(msg_off <= alloc, E::OutOfBufferBounds)?;
-        ensure_or(
-            msgsz.map(|s| msg_off <= s).unwrap_or(true),
-            E::OutOfMessageBounds,
-        )?;
-
-        self.off = off;
-        Ok(())
-    }
-
-    pub fn ensure_sufficient_msg_buffer(&self) -> Result<(), MessageTooLargeError> {
-        let buf_size = self.message_buffer().len();
-        let msg_size = match self.get_header() {
-            None => return Ok(()),
-            Some(v) => v,
-        };
-        MessageTooLargeError::ensure(msg_size, buf_size)
-    }
-
-    pub fn header_buffer(&self) -> &[u8] {
-        &self.header[..]
-    }
-
-    pub fn header_buffer_mut(&mut self) -> &mut [u8] {
-        &mut self.header[..]
-    }
-
-    pub fn message_buffer(&self) -> &[u8] {
-        self.buf.borrow()
-    }
-
-    pub fn message_buffer_mut(&mut self) -> &mut [u8] {
-        self.buf.borrow_mut()
-    }
-
-    pub fn bytes_read(&self) -> &usize {
-        &self.off
-    }
-
-    pub fn into_message_buffer(self) -> Buf {
-        let Self { buf, .. } = self;
-        buf
-    }
-
-    pub fn header_buffer_offset(&self) -> usize {
-        min(self.off, HEADER_SIZE)
-    }
-
-    pub fn message_buffer_offset(&self) -> usize {
-        self.off.saturating_sub(HEADER_SIZE)
-    }
-
-    pub fn has_header(&self) -> bool {
-        self.header_buffer_offset() == HEADER_SIZE
-    }
-
-    pub fn has_message(&self) -> Result<bool, MessageTooLargeError> {
-        self.ensure_sufficient_msg_buffer()?;
-        let msg_size = match self.get_header() {
-            None => return Ok(false),
-            Some(v) => v,
-        };
-        Ok(self.message_buffer_avail().len() == msg_size)
-    }
-
-    pub fn header_buffer_avail(&self) -> &[u8] {
-        let off = self.header_buffer_offset();
-        &self.header_buffer()[..off]
-    }
-
-    pub fn header_buffer_avail_mut(&mut self) -> &mut [u8] {
-        let off = self.header_buffer_offset();
-        &mut self.header_buffer_mut()[..off]
-    }
-
-    pub fn header_buffer_left(&self) -> &[u8] {
-        let off = self.header_buffer_offset();
-        &self.header_buffer()[off..]
-    }
-
-    pub fn header_buffer_left_mut(&mut self) -> &mut [u8] {
-        let off = self.header_buffer_offset();
-        &mut self.header_buffer_mut()[off..]
-    }
-
-    pub fn message_buffer_avail(&self) -> &[u8] {
-        let off = self.message_buffer_offset();
-        &self.message_buffer()[..off]
-    }
-
-    pub fn message_buffer_avail_mut(&mut self) -> &mut [u8] {
-        let off = self.message_buffer_offset();
-        &mut self.message_buffer_mut()[..off]
-    }
-
-    pub fn message_buffer_left(&self) -> &[u8] {
-        let off = self.message_buffer_offset();
-        &self.message_buffer()[off..]
-    }
-
-    pub fn message_buffer_left_mut(&mut self) -> &mut [u8] {
-        let off = self.message_buffer_offset();
-        &mut self.message_buffer_mut()[off..]
-    }
-
-    pub fn get_header(&self) -> Option<usize> {
-        match self.header_buffer_offset() == HEADER_SIZE {
-            false => None,
-            true => Some(u64::from_le_bytes(self.header) as usize),
-        }
-    }
-
-    pub fn message_size(&self) -> Option<usize> {
-        self.get_header()
-    }
-
-    pub fn encoded_message_bytes(&self) -> Option<usize> {
-        self.message_size().map(|sz| sz + HEADER_SIZE)
-    }
-
-    pub fn message_fragment(&self) -> Result<Option<&[u8]>, MessageTooLargeError> {
-        self.ensure_sufficient_msg_buffer()?;
-        Ok(self.message_size().map(|sz| &self.message_buffer()[..sz]))
-    }
-
-    pub fn message_fragment_mut(&mut self) -> Result<Option<&mut [u8]>, MessageTooLargeError> {
-        self.ensure_sufficient_msg_buffer()?;
-        Ok(self
-            .message_size()
-            .map(|sz| &mut self.message_buffer_mut()[..sz]))
-    }
-
-    pub fn message_fragment_avail(&self) -> Result<Option<&[u8]>, MessageTooLargeError> {
-        let off = self.message_buffer_avail().len();
-        self.message_fragment()
-            .map(|frag| frag.map(|frag| &frag[..off]))
-    }
-
-    pub fn message_fragment_avail_mut(
-        &mut self,
-    ) -> Result<Option<&mut [u8]>, MessageTooLargeError> {
-        let off = self.message_buffer_avail().len();
-        self.message_fragment_mut()
-            .map(|frag| frag.map(|frag| &mut frag[..off]))
-    }
-
-    pub fn message_fragment_left(&self) -> Result<Option<&[u8]>, MessageTooLargeError> {
-        let off = self.message_buffer_avail().len();
-        self.message_fragment()
-            .map(|frag| frag.map(|frag| &frag[off..]))
-    }
-
-    pub fn message_fragment_left_mut(&mut self) -> Result<Option<&mut [u8]>, MessageTooLargeError> {
-        let off = self.message_buffer_avail().len();
-        self.message_fragment_mut()
-            .map(|frag| frag.map(|frag| &mut frag[off..]))
-    }
-
-    pub fn message(&self) -> Result<Option<&[u8]>, MessageTooLargeError> {
-        let sz = self.message_size();
-        self.message_fragment_avail()
-            .map(|frag_opt| frag_opt.and_then(|frag| (frag.len() == sz?).then_some(frag)))
-    }
-
-    pub fn message_mut(&mut self) -> Result<Option<&mut [u8]>, MessageTooLargeError> {
-        let sz = self.message_size();
-        self.message_fragment_avail_mut()
-            .map(|frag_opt| frag_opt.and_then(|frag| (frag.len() == sz?).then_some(frag)))
-    }
-}
-
-impl<Buf: BorrowMut<[u8]>> Zeroize for LengthPrefixDecoder<Buf> {
-    fn zeroize(&mut self) {
-        self.header.zeroize();
-        self.message_buffer_mut().zeroize();
-        self.off.zeroize();
-    }
-}
--- a/util/src/length_prefix_encoding/encoder.rs
+++ b/util/src/length_prefix_encoding/encoder.rs
@@ -1,381 +0,0 @@
-use std::{
-    borrow::{Borrow, BorrowMut},
-    cmp::min,
-    io,
-};
-
-use thiserror::Error;
-use zeroize::Zeroize;
-
-use crate::{io::IoResultKindHintExt, result::ensure_or};
-
-pub const HEADER_SIZE: usize = std::mem::size_of::<u64>();
-
-#[derive(Error, Debug, Clone, Copy)]
-#[error("Write position is out of buffer bounds")]
-pub struct PositionOutOfBufferBounds;
-
-#[derive(Error, Debug, Clone, Copy)]
-#[error("Write position is out of message bounds")]
-pub struct PositionOutOfMessageBounds;
-
-#[derive(Error, Debug, Clone, Copy)]
-#[error("Write position is out of header bounds")]
-pub struct PositionOutOfHeaderBounds;
-
-#[derive(Error, Debug, Clone, Copy)]
-#[error("Message length is bigger than buffer length")]
-pub struct MessageTooLarge;
-
-#[derive(Error, Debug, Clone, Copy)]
-pub enum MessageLenSanityError {
-    #[error("{0:?}")]
-    PositionOutOfMessageBounds(#[from] PositionOutOfMessageBounds),
-    #[error("{0:?}")]
-    MessageTooLarge(#[from] MessageTooLarge),
-}
-
-#[derive(Error, Debug, Clone, Copy)]
-pub enum PositionSanityError {
-    #[error("{0:?}")]
-    PositionOutOfMessageBounds(#[from] PositionOutOfMessageBounds),
-    #[error("{0:?}")]
-    PositionOutOfBufferBounds(#[from] PositionOutOfBufferBounds),
-}
-
-#[derive(Error, Debug, Clone, Copy)]
-pub enum SanityError {
-    #[error("{0:?}")]
-    PositionOutOfMessageBounds(#[from] PositionOutOfMessageBounds),
-    #[error("{0:?}")]
-    PositionOutOfBufferBounds(#[from] PositionOutOfBufferBounds),
-    #[error("{0:?}")]
-    MessageTooLarge(#[from] MessageTooLarge),
-}
-
-impl TryFrom<SanityError> for MessageLenSanityError {
-    type Error = PositionOutOfBufferBounds;
-
-    fn try_from(value: SanityError) -> Result<Self, Self::Error> {
-        use {MessageLenSanityError as T, SanityError as F};
-        match value {
-            F::PositionOutOfMessageBounds(e) => Ok(T::PositionOutOfMessageBounds(e)),
-            F::MessageTooLarge(e) => Ok(T::MessageTooLarge(e)),
-            F::PositionOutOfBufferBounds(e) => Err(e),
-        }
-    }
-}
-
-impl From<MessageLenSanityError> for SanityError {
-    fn from(value: MessageLenSanityError) -> Self {
-        use {MessageLenSanityError as F, SanityError as T};
-        match value {
-            F::PositionOutOfMessageBounds(e) => T::PositionOutOfMessageBounds(e),
-            F::MessageTooLarge(e) => T::MessageTooLarge(e),
-        }
-    }
-}
-
-impl From<PositionSanityError> for SanityError {
-    fn from(value: PositionSanityError) -> Self {
-        use {PositionSanityError as F, SanityError as T};
-        match value {
-            F::PositionOutOfBufferBounds(e) => T::PositionOutOfBufferBounds(e),
-            F::PositionOutOfMessageBounds(e) => T::PositionOutOfMessageBounds(e),
-        }
-    }
-}
-
-pub struct WriteToIoReturn {
-    pub bytes_written: usize,
-    pub done: bool,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct LengthPrefixEncoder<Buf: Borrow<[u8]>> {
-    buf: Buf,
-    header: [u8; HEADER_SIZE],
-    pos: usize,
-}
-
-impl<Buf: Borrow<[u8]>> LengthPrefixEncoder<Buf> {
-    pub fn from_buffer(buf: Buf) -> Self {
-        let (header, pos) = ([0u8; HEADER_SIZE], 0);
-        let mut r = Self { buf, header, pos };
-        r.clear();
-        r
-    }
-
-    pub fn from_message(msg: Buf) -> Self {
-        let mut r = Self::from_buffer(msg);
-        r.restart_write_with_new_message(r.buffer_bytes().len())
-            .unwrap();
-        r
-    }
-
-    pub fn from_short_message(msg: Buf, len: usize) -> Result<Self, MessageLenSanityError> {
-        let mut r = Self::from_message(msg);
-        r.set_message_len(len)?;
-        Ok(r)
-    }
-
-    pub fn from_parts(buf: Buf, len: usize, pos: usize) -> Result<Self, SanityError> {
-        let mut r = Self::from_buffer(buf);
-        r.set_msg_len_and_position(len, pos)?;
-        Ok(r)
-    }
-
-    pub fn into_buffer(self) -> Buf {
-        let Self { buf, .. } = self;
-        buf
-    }
-
-    pub fn into_parts(self) -> (Buf, usize, usize) {
-        let len = self.message_len();
-        let pos = self.writing_position();
-        let buf = self.into_buffer();
-        (buf, len, pos)
-    }
-
-    pub fn clear(&mut self) {
-        self.set_msg_len_and_position(0, 0).unwrap();
-        self.set_message_offset(0).unwrap();
-    }
-
-    pub fn write_all_to_stdio<W: io::Write>(&mut self, mut w: W) -> io::Result<()> {
-        use io::ErrorKind as K;
-        loop {
-            match self.write_to_stdio(&mut w).io_err_kind_hint() {
-                // Done
-                Ok(WriteToIoReturn { done: true, .. }) => break Ok(()),
-
-                // Retry
-                Ok(WriteToIoReturn { done: false, .. }) => continue,
-                Err((_, K::Interrupted)) => continue,
-
-                Err((e, _)) => break Err(e),
-            }
-        }
-    }
-
-    pub fn write_to_stdio<W: io::Write>(&mut self, mut w: W) -> io::Result<WriteToIoReturn> {
-        if self.exhausted() {
-            return Ok(WriteToIoReturn {
-                bytes_written: 0,
-                done: true,
-            });
-        }
-
-        let buf = self.next_slice_to_write();
-        let bytes_written = w.write(buf)?;
-        self.advance(bytes_written).unwrap();
-
-        let done = self.exhausted();
-        Ok(WriteToIoReturn {
-            bytes_written,
-            done,
-        })
-    }
-
-    pub fn restart_write(&mut self) {
-        self.set_writing_position(0).unwrap()
-    }
-
-    pub fn restart_write_with_new_message(
-        &mut self,
-        len: usize,
-    ) -> Result<(), MessageLenSanityError> {
-        self.set_msg_len_and_position(len, 0)
-            .map_err(|e| e.try_into().unwrap())
-    }
-
-    pub fn next_slice_to_write(&self) -> &[u8] {
-        let s = self.header_left();
-        if !s.is_empty() {
-            return s;
-        }
-
-        let s = self.message_left();
-        if !s.is_empty() {
-            return s;
-        }
-
-        &[]
-    }
-
-    pub fn exhausted(&self) -> bool {
-        self.next_slice_to_write().is_empty()
-    }
-
-    pub fn message(&self) -> &[u8] {
-        &self.buffer_bytes()[..self.message_len()]
-    }
-
-    pub fn header_written(&self) -> &[u8] {
-        &self.header()[..self.header_offset()]
-    }
-
-    pub fn header_left(&self) -> &[u8] {
-        &self.header()[self.header_offset()..]
-    }
-
-    pub fn message_written(&self) -> &[u8] {
-        &self.message()[..self.message_offset()]
-    }
-
-    pub fn message_left(&self) -> &[u8] {
-        &self.message()[self.message_offset()..]
-    }
-
-    pub fn buf(&self) -> &Buf {
-        &self.buf
-    }
-
-    pub fn buffer_bytes(&self) -> &[u8] {
-        self.buf().borrow()
-    }
-
-    pub fn decode_header(&self) -> u64 {
-        u64::from_le_bytes(self.header)
-    }
-
-    pub fn header(&self) -> &[u8; HEADER_SIZE] {
-        &self.header
-    }
-
-    pub fn message_len(&self) -> usize {
-        self.decode_header() as usize
-    }
-
-    pub fn encoded_message_bytes(&self) -> usize {
-        self.message_len() + HEADER_SIZE
-    }
-
-    pub fn writing_position(&self) -> usize {
-        self.pos
-    }
-
-    pub fn header_offset(&self) -> usize {
-        min(self.writing_position(), HEADER_SIZE)
-    }
-
-    pub fn message_offset(&self) -> usize {
-        self.writing_position().saturating_sub(HEADER_SIZE)
-    }
-
-    pub fn set_header(&mut self, header: [u8; HEADER_SIZE]) -> Result<(), MessageLenSanityError> {
-        self.offset_transaction(|t| {
-            t.header = header;
-            t.ensure_msg_in_buf_bounds()?;
-            t.ensure_pos_in_msg_bounds()?;
-            Ok(())
-        })
-    }
-
-    pub fn encode_and_set_header(&mut self, header: u64) -> Result<(), MessageLenSanityError> {
-        self.set_header(header.to_le_bytes())
-    }
-
-    pub fn set_message_len(&mut self, len: usize) -> Result<(), MessageLenSanityError> {
-        self.encode_and_set_header(len as u64)
-    }
-
-    pub fn set_writing_position(&mut self, pos: usize) -> Result<(), PositionSanityError> {
-        self.offset_transaction(|t| {
-            t.pos = pos;
-            t.ensure_pos_in_buf_bounds()?;
-            t.ensure_pos_in_msg_bounds()?;
-            Ok(())
-        })
-    }
-
-    pub fn set_header_offset(&mut self, off: usize) -> Result<(), PositionOutOfHeaderBounds> {
-        ensure_or(off <= HEADER_SIZE, PositionOutOfHeaderBounds)?;
-        self.set_writing_position(off).unwrap();
-        Ok(())
-    }
-
-    pub fn set_message_offset(&mut self, off: usize) -> Result<(), PositionSanityError> {
-        self.set_writing_position(off + HEADER_SIZE)
-    }
-
-    pub fn advance(&mut self, off: usize) -> Result<(), PositionSanityError> {
-        self.set_writing_position(self.writing_position() + off)
-    }
-
-    pub fn set_msg_len_and_position(&mut self, len: usize, pos: usize) -> Result<(), SanityError> {
-        self.pos = 0;
-        self.set_message_len(len)?;
-        self.set_writing_position(pos)?;
-        Ok(())
-    }
-
-    fn offset_transaction<E, F>(&mut self, f: F) -> Result<(), E>
-    where
-        F: FnOnce(&mut LengthPrefixEncoder<&[u8]>) -> Result<(), E>,
-    {
-        let (header, pos) = {
-            let (buf, header, pos) = (self.buffer_bytes(), self.header, self.pos);
-            let mut tmp = LengthPrefixEncoder { buf, header, pos };
-            f(&mut tmp)?;
-            Ok((tmp.header, tmp.pos))
-        }?;
-        (self.header, self.pos) = (header, pos);
-        Ok(())
-    }
-
-    fn ensure_pos_in_buf_bounds(&self) -> Result<(), PositionOutOfBufferBounds> {
-        ensure_or(
-            self.message_offset() <= self.buffer_bytes().len(),
-            PositionOutOfBufferBounds,
-        )
-    }
-
-    fn ensure_pos_in_msg_bounds(&self) -> Result<(), PositionOutOfMessageBounds> {
-        ensure_or(
-            self.message_offset() <= self.message_len(),
-            PositionOutOfMessageBounds,
-        )
-    }
-
-    fn ensure_msg_in_buf_bounds(&self) -> Result<(), MessageTooLarge> {
-        ensure_or(
-            self.message_len() <= self.buffer_bytes().len(),
-            MessageTooLarge,
-        )
-    }
-}
-
-impl<Buf: BorrowMut<[u8]>> LengthPrefixEncoder<Buf> {
-    pub fn buf_mut(&mut self) -> &mut Buf {
-        &mut self.buf
-    }
-
-    pub fn buffer_bytes_mut(&mut self) -> &mut [u8] {
-        self.buf.borrow_mut()
-    }
-
-    pub fn message_mut(&mut self) -> &mut [u8] {
-        let off = self.message_len();
-        &mut self.buffer_bytes_mut()[..off]
-    }
-
-    pub fn message_written_mut(&mut self) -> &mut [u8] {
-        let off = self.message_offset();
-        &mut self.message_mut()[..off]
-    }
-
-    pub fn message_left_mut(&mut self) -> &mut [u8] {
-        let off = self.message_offset();
-        &mut self.message_mut()[off..]
-    }
-}
-
-impl<Buf: BorrowMut<[u8]>> Zeroize for LengthPrefixEncoder<Buf> {
-    fn zeroize(&mut self) {
-        self.buffer_bytes_mut().zeroize();
-        self.header.zeroize();
-        self.pos.zeroize();
-        self.clear();
-    }
-}
--- a/util/src/length_prefix_encoding/mod.rs
+++ b/util/src/length_prefix_encoding/mod.rs
@@ -1,2 +0,0 @@
-pub mod decoder;
-pub mod encoder;
--- a/util/src/lib.rs
+++ b/util/src/lib.rs
@@ -1,18 +1,11 @@
 #![recursion_limit = "256"]

 pub mod b64;
-pub mod build;
-pub mod controlflow;
 pub mod fd;
 pub mod file;
 pub mod functional;
-pub mod io;
-pub mod length_prefix_encoding;
 pub mod mem;
-pub mod mio;
-pub mod option;
+pub mod ord;
 pub mod result;
 pub mod time;
 pub mod typenum;
-pub mod zerocopy;
-pub mod zeroize;
--- a/util/src/mem.rs
+++ b/util/src/mem.rs
@@ -1,7 +1,5 @@
 use std::borrow::{Borrow, BorrowMut};
 use std::cmp::min;
-use std::mem::{forget, swap};
-use std::ops::{Deref, DerefMut};

 /// Concatenate two byte arrays
 // TODO: Zeroize result?
@@ -33,120 +31,3 @@ pub fn cpy_min<T: BorrowMut<[u8]> + ?Sized, F: Borrow<[u8]> + ?Sized>(src: &F, d
    let len = min(src.len(), dst.len());
    dst[..len].copy_from_slice(&src[..len]);
 }
-
-/// Wrapper type to inhibit calling [std::mem::Drop] when the underlying variable is freed
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Default)]
-pub struct Forgetting<T> {
-    value: Option<T>,
-}
-
-impl<T> Forgetting<T> {
-    pub fn new(value: T) -> Self {
-        let value = Some(value);
-        Self { value }
-    }
-
-    pub fn extract(mut self) -> T {
-        let mut value = None;
-        swap(&mut value, &mut self.value);
-        value.unwrap()
-    }
-}
-
-impl<T> From<T> for Forgetting<T> {
-    fn from(value: T) -> Self {
-        Self::new(value)
-    }
-}
-
-impl<T> Deref for Forgetting<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.value.as_ref().unwrap()
-    }
-}
-
-impl<T> DerefMut for Forgetting<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.value.as_mut().unwrap()
-    }
-}
-
-impl<T> Borrow<T> for Forgetting<T> {
-    fn borrow(&self) -> &T {
-        self.deref()
-    }
-}
-
-impl<T> BorrowMut<T> for Forgetting<T> {
-    fn borrow_mut(&mut self) -> &mut T {
-        self.deref_mut()
-    }
-}
-
-impl<T> Drop for Forgetting<T> {
-    fn drop(&mut self) {
-        let mut value = None;
-        swap(&mut self.value, &mut value);
-        forget(value)
-    }
-}
-
-pub trait DiscardResultExt {
-    fn discard_result(self);
-}
-
-impl<T> DiscardResultExt for T {
-    fn discard_result(self) {}
-}
-
-pub trait ForgetExt {
-    fn forget(self);
-}
-
-impl<T> ForgetExt for T {
-    fn forget(self) {
-        std::mem::forget(self)
-    }
-}
-
-pub trait SwapWithExt {
-    fn swap_with(&mut self, other: Self) -> Self;
-    fn swap_with_mut(&mut self, other: &mut Self);
-}
-
-impl<T> SwapWithExt for T {
-    fn swap_with(&mut self, mut other: Self) -> Self {
-        self.swap_with_mut(&mut other);
-        other
-    }
-
-    fn swap_with_mut(&mut self, other: &mut Self) {
-        std::mem::swap(self, other)
-    }
-}
-
-pub trait SwapWithDefaultExt {
-    fn swap_with_default(&mut self) -> Self;
-}
-
-impl<T: Default> SwapWithDefaultExt for T {
-    fn swap_with_default(&mut self) -> Self {
-        self.swap_with(Self::default())
-    }
-}
-
-pub trait MoveExt {
-    /// Deliberately move the value
-    ///
-    /// Usually employed to enforce an object being
-    /// dropped after use.
-    fn move_here(self) -> Self;
-}
-
-impl<T: Sized> MoveExt for T {
-    fn move_here(self) -> Self {
-        self
-    }
-}
--- a/util/src/mio/mio.rs
+++ b/util/src/mio/mio.rs
@@ -1,53 +0,0 @@
-use mio::net::{UnixListener, UnixStream};
-use rustix::fd::{OwnedFd, RawFd};
-
-use crate::{
-    fd::{claim_fd, claim_fd_inplace},
-    result::OkExt,
-};
-
-pub mod interest {
-    use mio::Interest;
-    pub const R: Interest = Interest::READABLE;
-    pub const W: Interest = Interest::WRITABLE;
-    pub const RW: Interest = R.add(W);
-}
-
-pub trait UnixListenerExt: Sized {
-    fn claim_fd(fd: RawFd) -> anyhow::Result<Self>;
-}
-
-impl UnixListenerExt for UnixListener {
-    fn claim_fd(fd: RawFd) -> anyhow::Result<Self> {
-        use std::os::unix::net::UnixListener as StdUnixListener;
-
-        let sock = StdUnixListener::from(claim_fd(fd)?);
-        sock.set_nonblocking(true)?;
-        Ok(UnixListener::from_std(sock))
-    }
-}
-
-pub trait UnixStreamExt: Sized {
-    fn from_fd(fd: OwnedFd) -> anyhow::Result<Self>;
-    fn claim_fd(fd: RawFd) -> anyhow::Result<Self>;
-    fn claim_fd_inplace(fd: RawFd) -> anyhow::Result<Self>;
-}
-
-impl UnixStreamExt for UnixStream {
-    fn from_fd(fd: OwnedFd) -> anyhow::Result<Self> {
-        use std::os::unix::net::UnixStream as StdUnixStream;
-        #[cfg(target_os = "linux")] // TODO: We should support this on other plattforms
-        crate::fd::GetUnixSocketType::demand_unix_stream_socket(&fd)?;
-        let sock = StdUnixStream::from(fd);
-        sock.set_nonblocking(true)?;
-        UnixStream::from_std(sock).ok()
-    }
-
-    fn claim_fd(fd: RawFd) -> anyhow::Result<Self> {
-        Self::from_fd(claim_fd(fd)?)
-    }
-
-    fn claim_fd_inplace(fd: RawFd) -> anyhow::Result<Self> {
-        Self::from_fd(claim_fd_inplace(fd)?)
-    }
-}
--- a/util/src/mio/mod.rs
+++ b/util/src/mio/mod.rs
@@ -1,13 +0,0 @@
-#[allow(clippy::module_inception)]
-mod mio;
-pub use mio::*;
-
-#[cfg(feature = "experiment_file_descriptor_passing")]
-mod uds_send_fd;
-#[cfg(feature = "experiment_file_descriptor_passing")]
-pub use uds_send_fd::*;
-
-#[cfg(feature = "experiment_file_descriptor_passing")]
-mod uds_recv_fd;
-#[cfg(feature = "experiment_file_descriptor_passing")]
-pub use uds_recv_fd::*;
--- a/util/src/mio/uds_recv_fd.rs
+++ b/util/src/mio/uds_recv_fd.rs
@@ -1,123 +0,0 @@
-use std::{
-    borrow::{Borrow, BorrowMut},
-    collections::VecDeque,
-    io::Read,
-    marker::PhantomData,
-    os::fd::OwnedFd,
-};
-use uds::UnixStreamExt as FdPassingExt;
-
-use crate::fd::{claim_fd_inplace, IntoStdioErr};
-
-pub struct ReadWithFileDescriptors<const MAX_FDS: usize, Sock, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<OwnedFd>>,
-{
-    socket: BorrowSock,
-    fds: BorrowFds,
-    _sock_dummy: PhantomData<Sock>,
-}
-
-impl<const MAX_FDS: usize, Sock, BorrowSock, BorrowFds>
-    ReadWithFileDescriptors<MAX_FDS, Sock, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<OwnedFd>>,
-{
-    pub fn new(socket: BorrowSock, fds: BorrowFds) -> Self {
-        let _sock_dummy = PhantomData;
-        Self {
-            socket,
-            fds,
-            _sock_dummy,
-        }
-    }
-
-    pub fn into_parts(self) -> (BorrowSock, BorrowFds) {
-        let Self { socket, fds, .. } = self;
-        (socket, fds)
-    }
-
-    pub fn socket(&self) -> &Sock {
-        self.socket.borrow()
-    }
-
-    pub fn fds(&self) -> &VecDeque<OwnedFd> {
-        self.fds.borrow()
-    }
-
-    pub fn fds_mut(&mut self) -> &mut VecDeque<OwnedFd> {
-        self.fds.borrow_mut()
-    }
-}
-
-impl<const MAX_FDS: usize, Sock, BorrowSock, BorrowFds>
-    ReadWithFileDescriptors<MAX_FDS, Sock, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    BorrowSock: BorrowMut<Sock>,
-    BorrowFds: BorrowMut<VecDeque<OwnedFd>>,
-{
-    pub fn socket_mut(&mut self) -> &mut Sock {
-        self.socket.borrow_mut()
-    }
-}
-
-impl<const MAX_FDS: usize, Sock, BorrowSock, BorrowFds> Read
-    for ReadWithFileDescriptors<MAX_FDS, Sock, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<OwnedFd>>,
-{
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        // Calculate space for additional file descriptors
-        let have_fds_before_read = self.fds().len();
-        let free_fd_slots = MAX_FDS.saturating_sub(have_fds_before_read);
-
-        // Allocate a buffer for file descriptors
-        let mut fd_buf = [0; MAX_FDS];
-        let fd_buf = &mut fd_buf[..free_fd_slots];
-
-        // Read from the unix socket
-        let (bytes_read, fds_read) = self.socket.borrow().recv_fds(buf, fd_buf)?;
-        let fd_buf = &fd_buf[..fds_read];
-
-        // Process the file descriptors
-        let mut fd_iter = fd_buf.iter();
-
-        // Try claiming all the file descriptors
-        let mut claim_fd_result = Ok(bytes_read);
-        self.fds_mut().reserve(fd_buf.len());
-        for fd in fd_iter.by_ref() {
-            match claim_fd_inplace(*fd) {
-                Ok(owned) => self.fds_mut().push_back(owned),
-                Err(e) => {
-                    // Abort on error and pass to error handler
-                    // Note that claim_fd_inplace is responsible for closing this particular
-                    // file descriptor if claiming it fails
-                    claim_fd_result = Err(e.into_stdio_err());
-                    break;
-                }
-            }
-        }
-
-        // Return if we where able to claim all file descriptors
-        if claim_fd_result.is_ok() {
-            return claim_fd_result;
-        };
-
-        // An error occurred while claiming fds
-        self.fds_mut().truncate(have_fds_before_read); // Close fds successfully claimed
-
-        // Close the remaining fds
-        for fd in fd_iter {
-            unsafe { rustix::io::close(*fd) };
-        }
-
-        claim_fd_result
-    }
-}
--- a/util/src/mio/uds_send_fd.rs
+++ b/util/src/mio/uds_send_fd.rs
@@ -1,121 +0,0 @@
-use rustix::fd::{AsFd, AsRawFd};
-use std::{
-    borrow::{Borrow, BorrowMut},
-    cmp::min,
-    collections::VecDeque,
-    io::Write,
-    marker::PhantomData,
-};
-use uds::UnixStreamExt as FdPassingExt;
-
-use crate::{repeat, return_if};
-
-pub struct WriteWithFileDescriptors<Sock, Fd, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    Fd: AsFd,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<Fd>>,
-{
-    socket: BorrowSock,
-    fds: BorrowFds,
-    _sock_dummy: PhantomData<Sock>,
-    _fd_dummy: PhantomData<Fd>,
-}
-
-impl<Sock, Fd, BorrowSock, BorrowFds> WriteWithFileDescriptors<Sock, Fd, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    Fd: AsFd,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<Fd>>,
-{
-    pub fn new(socket: BorrowSock, fds: BorrowFds) -> Self {
-        let _sock_dummy = PhantomData;
-        let _fd_dummy = PhantomData;
-        Self {
-            socket,
-            fds,
-            _sock_dummy,
-            _fd_dummy,
-        }
-    }
-
-    pub fn into_parts(self) -> (BorrowSock, BorrowFds) {
-        let Self { socket, fds, .. } = self;
-        (socket, fds)
-    }
-
-    pub fn socket(&self) -> &Sock {
-        self.socket.borrow()
-    }
-
-    pub fn fds(&self) -> &VecDeque<Fd> {
-        self.fds.borrow()
-    }
-
-    pub fn fds_mut(&mut self) -> &mut VecDeque<Fd> {
-        self.fds.borrow_mut()
-    }
-}
-
-impl<Sock, Fd, BorrowSock, BorrowFds> WriteWithFileDescriptors<Sock, Fd, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    Fd: AsFd,
-    BorrowSock: BorrowMut<Sock>,
-    BorrowFds: BorrowMut<VecDeque<Fd>>,
-{
-    pub fn socket_mut(&mut self) -> &mut Sock {
-        self.socket.borrow_mut()
-    }
-}
-
-impl<Sock, Fd, BorrowSock, BorrowFds> Write
-    for WriteWithFileDescriptors<Sock, Fd, BorrowSock, BorrowFds>
-where
-    Sock: FdPassingExt,
-    Fd: AsFd,
-    BorrowSock: Borrow<Sock>,
-    BorrowFds: BorrowMut<VecDeque<Fd>>,
-{
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        // At least one byte of real data should be sent when sending ancillary data. -- unix(7)
-        return_if!(buf.is_empty(), Ok(0));
-
-        // The kernel constant SCM_MAX_FD defines a limit on the number of file descriptors
-        // in the array.  Attempting to  send  an  array  larger  than  this  limit  causes
-        // sendmsg(2)  to fail with the error EINVAL.  SCM_MAX_FD has the value 253 (or 255
-        // before Linux 2.6.38).
-        // -- unix(7)
-        const SCM_MAX_FD: usize = 253;
-        let buf = match self.fds().len() <= SCM_MAX_FD {
-            false => &buf[..1], // Force caller to immediately call write() again to send its data
-            true => buf,
-        };
-
-        // Allocate the buffer for the file descriptor array
-        let fd_no = min(SCM_MAX_FD, self.fds().len());
-        let mut fd_buf = [0; SCM_MAX_FD]; // My kingdom for alloca(3)
-        let fd_buf = &mut fd_buf[..fd_no];
-
-        // Fill the file descriptor array
-        for (raw, fancy) in fd_buf.iter_mut().zip(self.fds().iter()) {
-            *raw = fancy.as_fd().as_raw_fd();
-        }
-
-        // Send data and file descriptors
-        let bytes_written = self.socket().send_fds(buf, fd_buf)?;
-
-        // Drop the file descriptors from the Deque
-        repeat!(fd_no, {
-            self.fds_mut().pop_front();
-        });
-
-        Ok(bytes_written)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
--- a/util/src/option.rs
+++ b/util/src/option.rs
@@ -1,7 +0,0 @@
-pub trait SomeExt: Sized {
-    fn some(self) -> Option<Self> {
-        Some(self)
-    }
-}
-
-impl<T> SomeExt for T {}
--- a/util/src/ord.rs
+++ b/util/src/ord.rs
@@ -0,0 +1,8 @@
+// TODO remove this once std::cmp::max becomes const
+pub const fn max_usize(a: usize, b: usize) -> usize {
+    if a > b {
+        a
+    } else {
+        b
+    }
+}
--- a/util/src/result.rs
+++ b/util/src/result.rs
@@ -1,4 +1,5 @@
 use std::convert::Infallible;
+use std::result::Result;

 /// Try block basically…returns a result and allows the use of the question mark operator inside
 #[macro_export]
@@ -8,16 +9,6 @@ macro_rules! attempt {
    };
 }

-pub trait OkExt<E>: Sized {
-    fn ok(self) -> Result<Self, E>;
-}
-
-impl<T, E> OkExt<E> for T {
-    fn ok(self) -> Result<Self, E> {
-        Ok(self)
-    }
-}
-
 /// Trait for container types that guarantee successful unwrapping.
 ///
 /// The `.guaranteed()` function can be used over unwrap to show that
@@ -35,24 +26,6 @@ pub trait GuaranteedValue {
    fn guaranteed(self) -> Self::Value;
 }

-pub trait FinallyExt {
-    fn finally<F: FnOnce(&mut Self)>(self, f: F) -> Self;
-}
-
-impl<T, E> FinallyExt for Result<T, E> {
-    fn finally<F: FnOnce(&mut Self)>(mut self, f: F) -> Self {
-        f(&mut self);
-        self
-    }
-}
-
-impl<T> FinallyExt for Option<T> {
-    fn finally<F: FnOnce(&mut Self)>(mut self, f: F) -> Self {
-        f(&mut self);
-        self
-    }
-}
-
 /// A result type that never contains an error.
 ///
 /// This is mostly useful in generic contexts.
@@ -124,14 +97,3 @@ impl<T> GuaranteedValue for Guaranteed<T> {
        self.unwrap()
    }
 }
-
-pub fn ensure_or<E>(b: bool, err: E) -> Result<(), E> {
-    match b {
-        true => Ok(()),
-        false => Err(err),
-    }
-}
-
-pub fn bail_if<E>(b: bool, err: E) -> Result<(), E> {
-    ensure_or(!b, err)
-}
--- a/util/src/time.rs
+++ b/util/src/time.rs
@@ -1,53 +1,20 @@
-use std::time::Instant;
-
-/// A timebase.
-///
-/// This is a simple wrapper around `std::time::Instant` that provides a
-/// convenient way to get the seconds elapsed since the creation of the
-/// `Timebase` instance.
+use std::time::{Duration, Instant};

 #[derive(Clone, Debug)]
 pub struct Timebase(Instant);

 impl Default for Timebase {
-    // TODO: Implement new()?
    fn default() -> Self {
        Self(Instant::now())
    }
 }

 impl Timebase {
-    /// Returns the seconds elapsed since the creation of the `Timebase`
    pub fn now(&self) -> f64 {
        self.0.elapsed().as_secs_f64()
    }
-}

-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::thread::sleep;
-    use std::time::Duration;
-
-    #[test]
-    fn test_timebase() {
-        let timebase = Timebase::default();
-        let now = timebase.now();
-        assert!(now > 0.0);
-    }
-
-    #[test]
-    fn test_timebase_clone() {
-        let timebase = Timebase::default();
-        let timebase_clone = timebase.clone();
-        assert_eq!(timebase.0, timebase_clone.0);
-    }
-
-    #[test]
-    fn test_timebase_sleep() {
-        let timebase = Timebase::default();
-        sleep(Duration::from_secs(1));
-        let now = timebase.now();
-        assert!(now > 1.0);
+    pub fn dur(&self, t: f64) -> Duration {
+        Duration::from_secs_f64(t)
    }
 }
--- a/util/src/typenum.rs
+++ b/util/src/typenum.rs
@@ -19,22 +19,15 @@ pub trait IntoConst<T> {
    const VALUE: T;
 }

-#[allow(dead_code)]
 struct ConstApplyNegSign<T: AssociatedUnsigned, Param: IntoConst<<T as AssociatedUnsigned>::Type>>(
    *const T,
    *const Param,
 );
-
-#[allow(dead_code)]
 struct ConstApplyPosSign<T: AssociatedUnsigned, Param: IntoConst<<T as AssociatedUnsigned>::Type>>(
    *const T,
    *const Param,
 );
-
-#[allow(dead_code)]
 struct ConstLshift<T, Param: IntoConst<T>, const SHIFT: i32>(*const T, *const Param); // impl IntoConst<T>
-
-#[allow(dead_code)]
 struct ConstAdd<T, Lhs: IntoConst<T>, Rhs: IntoConst<T>>(*const T, *const Lhs, *const Rhs); // impl IntoConst<T>

 /// Assigns an unsigned type to a signed type
--- a/util/src/zerocopy/mod.rs
+++ b/util/src/zerocopy/mod.rs
@@ -1,7 +0,0 @@
-mod ref_maker;
-mod zerocopy_ref_ext;
-mod zerocopy_slice_ext;
-
-pub use ref_maker::*;
-pub use zerocopy_ref_ext::*;
-pub use zerocopy_slice_ext::*;
--- a/util/src/zerocopy/ref_maker.rs
+++ b/util/src/zerocopy/ref_maker.rs
@@ -1,107 +0,0 @@
-use std::marker::PhantomData;
-
-use anyhow::{ensure, Context};
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-use zeroize::Zeroize;
-
-use crate::zeroize::ZeroizedExt;
-
-#[derive(Clone, Copy, Debug)]
-pub struct RefMaker<B: Sized, T> {
-    buf: B,
-    _phantom_t: PhantomData<T>,
-}
-
-impl<B, T> RefMaker<B, T> {
-    pub fn new(buf: B) -> Self {
-        let _phantom_t = PhantomData;
-        Self { buf, _phantom_t }
-    }
-
-    pub const fn target_size() -> usize {
-        std::mem::size_of::<T>()
-    }
-
-    pub fn into_buf(self) -> B {
-        self.buf
-    }
-
-    pub fn buf(&self) -> &B {
-        &self.buf
-    }
-
-    pub fn buf_mut(&mut self) -> &mut B {
-        &mut self.buf
-    }
-}
-
-impl<B: ByteSlice, T> RefMaker<B, T> {
-    pub fn parse(self) -> anyhow::Result<Ref<B, T>> {
-        self.ensure_fit()?;
-        Ref::<B, T>::new(self.buf).context("Parser error!")
-    }
-
-    pub fn from_prefix_with_tail(self) -> anyhow::Result<(Self, B)> {
-        self.ensure_fit()?;
-        let (head, tail) = self.buf.split_at(Self::target_size());
-        Ok((Self::new(head), tail))
-    }
-
-    pub fn split_prefix(self) -> anyhow::Result<(Self, Self)> {
-        self.ensure_fit()?;
-        let (head, tail) = self.buf.split_at(Self::target_size());
-        Ok((Self::new(head), Self::new(tail)))
-    }
-
-    pub fn from_prefix(self) -> anyhow::Result<Self> {
-        Ok(Self::from_prefix_with_tail(self)?.0)
-    }
-
-    pub fn from_suffix_with_head(self) -> anyhow::Result<(Self, B)> {
-        self.ensure_fit()?;
-        let point = self.bytes().len() - Self::target_size();
-        let (head, tail) = self.buf.split_at(point);
-        Ok((Self::new(tail), head))
-    }
-
-    pub fn split_suffix(self) -> anyhow::Result<(Self, Self)> {
-        self.ensure_fit()?;
-        let point = self.bytes().len() - Self::target_size();
-        let (head, tail) = self.buf.split_at(point);
-        Ok((Self::new(head), Self::new(tail)))
-    }
-
-    pub fn from_suffix(self) -> anyhow::Result<Self> {
-        Ok(Self::from_suffix_with_head(self)?.0)
-    }
-
-    pub fn bytes(&self) -> &[u8] {
-        self.buf().deref()
-    }
-
-    pub fn ensure_fit(&self) -> anyhow::Result<()> {
-        let have = self.bytes().len();
-        let need = Self::target_size();
-        ensure!(
-            need <= have,
-            "Buffer is undersized at {have} bytes (need {need} bytes)!"
-        );
-        Ok(())
-    }
-}
-
-impl<B: ByteSliceMut, T> RefMaker<B, T> {
-    pub fn make_zeroized(self) -> anyhow::Result<Ref<B, T>> {
-        self.zeroized().parse()
-    }
-
-    pub fn bytes_mut(&mut self) -> &mut [u8] {
-        self.buf_mut().deref_mut()
-    }
-}
-
-impl<B: ByteSliceMut, T> Zeroize for RefMaker<B, T> {
-    fn zeroize(&mut self) {
-        self.bytes_mut().zeroize()
-    }
-}
--- a/util/src/zerocopy/zerocopy_ref_ext.rs
+++ b/util/src/zerocopy/zerocopy_ref_ext.rs
@@ -1,27 +0,0 @@
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-
-pub trait ZerocopyEmancipateExt<B, T> {
-    fn emancipate(&self) -> Ref<&[u8], T>;
-}
-
-pub trait ZerocopyEmancipateMutExt<B, T> {
-    fn emancipate_mut(&mut self) -> Ref<&mut [u8], T>;
-}
-
-impl<B, T> ZerocopyEmancipateExt<B, T> for Ref<B, T>
-where
-    B: ByteSlice,
-{
-    fn emancipate(&self) -> Ref<&[u8], T> {
-        Ref::new(self.bytes()).unwrap()
-    }
-}
-
-impl<B, T> ZerocopyEmancipateMutExt<B, T> for Ref<B, T>
-where
-    B: ByteSliceMut,
-{
-    fn emancipate_mut(&mut self) -> Ref<&mut [u8], T> {
-        Ref::new(self.bytes_mut()).unwrap()
-    }
-}
--- a/util/src/zerocopy/zerocopy_slice_ext.rs
+++ b/util/src/zerocopy/zerocopy_slice_ext.rs
@@ -1,39 +0,0 @@
-use zerocopy::{ByteSlice, ByteSliceMut, Ref};
-
-use super::RefMaker;
-
-pub trait ZerocopySliceExt: Sized + ByteSlice {
-    fn zk_ref_maker<T>(self) -> RefMaker<Self, T> {
-        RefMaker::<Self, T>::new(self)
-    }
-
-    fn zk_parse<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().parse()
-    }
-
-    fn zk_parse_prefix<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().from_prefix()?.parse()
-    }
-
-    fn zk_parse_suffix<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().from_suffix()?.parse()
-    }
-}
-
-impl<B: ByteSlice> ZerocopySliceExt for B {}
-
-pub trait ZerocopyMutSliceExt: ZerocopySliceExt + Sized + ByteSliceMut {
-    fn zk_zeroized<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().make_zeroized()
-    }
-
-    fn zk_zeroized_from_prefix<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().from_prefix()?.make_zeroized()
-    }
-
-    fn zk_zeroized_from_suffix<T>(self) -> anyhow::Result<Ref<Self, T>> {
-        self.zk_ref_maker().from_suffix()?.make_zeroized()
-    }
-}
-
-impl<B: ByteSliceMut> ZerocopyMutSliceExt for B {}
--- a/util/src/zeroize/mod.rs
+++ b/util/src/zeroize/mod.rs
@@ -1,2 +0,0 @@
-mod zeroized_ext;
-pub use zeroized_ext::*;
--- a/util/src/zeroize/zeroized_ext.rs
+++ b/util/src/zeroize/zeroized_ext.rs
@@ -1,10 +0,0 @@
-use zeroize::Zeroize;
-
-pub trait ZeroizedExt: Zeroize + Sized {
-    fn zeroized(mut self) -> Self {
-        self.zeroize();
-        self
-    }
-}
-
-impl<T: Zeroize + Sized> ZeroizedExt for T {}
--- a/wireguard-broker/Cargo.toml
+++ b/wireguard-broker/Cargo.toml
@@ -19,17 +19,13 @@ wireguard-uapi = { workspace = true }

 # Socket handler only
 rosenpass-to = { workspace = true }
-tokio = { version = "1.39.3", features = ["sync", "full", "mio"] }
+tokio = { version = "1.38.1", features = ["sync", "full", "mio"] }
 anyhow = { workspace = true }
 clap = { workspace = true }
 env_logger = { workspace = true }
 log = { workspace = true }
 derive_builder = {workspace = true}
 postcard = {workspace = true}
-# Problem in CI, unknown reasons: dependency (libc) specified without providing a local path, Git repository, version, or workspace dependency to use
-# Maybe something about the combination of features and optional crates?
-rustix = { version = "0.38.27", optional = true } 
-libc = { version = "0.2", optional = true } 

 # Mio broker client
 mio = { workspace = true }
@@ -40,15 +36,14 @@ rand = {workspace = true}
 procspawn = {workspace = true}

 [features]
-experiment_api = ["rustix", "libc"]
-experiment_memfd_secret = []
+enable_broker_api=[]

 [[bin]]
 name = "rosenpass-wireguard-broker-privileged"
 path = "src/bin/priviledged.rs"
 test = false
 doc = false
-required-features = ["experiment_api"]
+required-features=["enable_broker_api"]
 cfg = { target_os = "linux" } 

 [[bin]]
@@ -56,5 +51,5 @@ name = "rosenpass-wireguard-broker-socket-handler"
 test = false
 path = "src/bin/socket_handler.rs"
 doc = false
-required-features = ["experiment_api"]
+required-features=["enable_broker_api"]
 cfg = { target_os = "linux" } 
--- a/wireguard-broker/src/api/client.rs
+++ b/wireguard-broker/src/api/client.rs
@@ -88,7 +88,7 @@ where
            None => return Ok(None),
        };

-        let typ = res.first().ok_or(invalid_msg_poller())?;
+        let typ = res.get(0).ok_or(invalid_msg_poller())?;
        let typ = msgs::MsgType::try_from(*typ)?;
        let msgs::MsgType::SetPsk = typ; // Assert type

@@ -113,7 +113,7 @@ where

    fn set_psk(&mut self, config: SerializedBrokerConfig) -> Result<(), Self::Error> {
        let config: Result<NetworkBrokerConfig, NetworkBrokerConfigErr> = config.try_into();
-        let config = config.map_err(BrokerClientSetPskError::BrokerError)?;
+        let config = config.map_err(|e| BrokerClientSetPskError::BrokerError(e))?;

        use BrokerClientSetPskError::*;
        const BUF_SIZE: usize = REQUEST_MSG_BUFFER_SIZE;
--- a/wireguard-broker/src/api/config.rs
+++ b/wireguard-broker/src/api/config.rs
@@ -2,7 +2,7 @@ use crate::{SerializedBrokerConfig, WG_KEY_LEN, WG_PEER_LEN};
 use derive_builder::Builder;
 use rosenpass_secret_memory::{Public, Secret};

-#[derive(Builder, Debug)]
+#[derive(Builder)]
 #[builder(pattern = "mutable")]
 //TODO: Use generics for iface, add additional params
 pub struct NetworkBrokerConfig<'a> {
@@ -11,12 +11,12 @@ pub struct NetworkBrokerConfig<'a> {
    pub psk: &'a Secret<WG_KEY_LEN>,
 }

-impl<'a> From<NetworkBrokerConfig<'a>> for SerializedBrokerConfig<'a> {
-    fn from(src: NetworkBrokerConfig<'a>) -> SerializedBrokerConfig<'a> {
-        Self {
-            interface: src.iface.as_bytes(),
-            peer_id: src.peer_id,
-            psk: src.psk,
+impl<'a> Into<SerializedBrokerConfig<'a>> for NetworkBrokerConfig<'a> {
+    fn into(self) -> SerializedBrokerConfig<'a> {
+        SerializedBrokerConfig {
+            interface: self.iface.as_bytes(),
+            peer_id: self.peer_id,
+            psk: self.psk,
            additional_params: &[],
        }
    }
--- a/wireguard-broker/src/api/msgs.rs
+++ b/wireguard-broker/src/api/msgs.rs
@@ -1,3 +1,4 @@
+use std::result::Result;
 use std::str::{from_utf8, Utf8Error};

 use zerocopy::{AsBytes, FromBytes, FromZeroes};
@@ -20,8 +21,8 @@ pub struct Envelope<M: AsBytes + FromBytes> {
 #[repr(packed)]
 #[derive(AsBytes, FromBytes, FromZeroes)]
 pub struct SetPskRequest {
-    pub psk: [u8; 32],
    pub peer_id: [u8; 32],
+    pub psk: [u8; 32],
    pub iface_size: u8, // TODO: We should have variable length strings in lenses
    pub iface_buf: [u8; 255],
 }
@@ -42,7 +43,7 @@ impl SetPskRequest {
        self.iface_size = iface.len() as u8;

        self.iface_buf = [0; 255];
-        self.iface_buf[..iface.len()].copy_from_slice(iface);
+        (&mut self.iface_buf[..iface.len()]).copy_from_slice(iface);

        Some(())
    }
--- a/wireguard-broker/src/api/server.rs
+++ b/wireguard-broker/src/api/server.rs
@@ -1,4 +1,5 @@
 use std::borrow::BorrowMut;
+use std::result::Result;

 use rosenpass_secret_memory::{Public, Secret};

@@ -36,7 +37,6 @@ impl<Err, Inner> BrokerServer<Err, Inner>
 where
    Inner: WireGuardBroker<Error = Err>,
    msgs::SetPskError: From<Err>,
-    Err: std::fmt::Debug,
 {
    pub fn new(inner: Inner) -> Self {
        Self { inner }
@@ -49,7 +49,7 @@ where
    ) -> Result<usize, BrokerServerError> {
        use BrokerServerError::*;

-        let typ = req.first().ok_or(InvalidMessage)?;
+        let typ = req.get(0).ok_or(InvalidMessage)?;
        let typ = msgs::MsgType::try_from(*typ)?;
        let msgs::MsgType::SetPsk = typ; // Assert type

@@ -57,9 +57,9 @@ where
            .ok_or(BrokerServerError::InvalidMessage)?;
        let mut res = zerocopy::Ref::<&mut [u8], Envelope<SetPskResponse>>::new(res)
            .ok_or(BrokerServerError::InvalidMessage)?;
-        res.msg_type = msgs::MsgType::SetPsk as u8;
-        self.handle_set_psk(&req.payload, &mut res.payload)?;

+        res.payload.return_code = msgs::MsgType::SetPsk as u8;
+        self.handle_set_psk(&req.payload, &mut res.payload)?;
        Ok(res.bytes().len())
    }

@@ -84,10 +84,6 @@ where
            .build()
            .unwrap();
        let r: Result<(), Err> = self.inner.borrow_mut().set_psk(config.into());
-        if let Err(e) = &r {
-            eprintln!("Error setting PSK: {e:?}"); // TODO: Use rust log
-        }
-
        let r: msgs::SetPskResult = r.map_err(|e| e.into());
        let r: msgs::SetPskResponseReturnCode = r.into();
        res.return_code = r as u8;
--- a/wireguard-broker/src/bin/priviledged.rs
+++ b/wireguard-broker/src/bin/priviledged.rs
@@ -9,6 +9,7 @@ fn main() {
 #[cfg(target_os = "linux")]
 pub mod linux {
    use std::io::{stdin, stdout, Read, Write};
+    use std::result::Result;

    use rosenpass_wireguard_broker::api::msgs;
    use rosenpass_wireguard_broker::api::server::BrokerServer;
@@ -27,14 +28,6 @@ pub mod linux {
    }

    pub fn main() -> Result<(), BrokerAppError> {
-        {
-            use rosenpass_secret_memory as SM;
-            #[cfg(feature = "experiment_memfd_secret")]
-            SM::secret_policy_try_use_memfd_secrets();
-            #[cfg(not(feature = "experiment_memfd_secret"))]
-            SM::secret_policy_use_only_malloc_secrets();
-        }
-
        let mut broker = BrokerServer::new(wg::NetlinkWireGuardBroker::new()?);

        let mut stdin = stdin().lock();
@@ -67,7 +60,7 @@ pub mod linux {

            // Write the response
            stdout.write_all(&(res.len() as u64).to_le_bytes())?;
-            stdout.write_all(res)?;
+            stdout.write_all(&res)?;
            stdout.flush()?;
        }
    }
--- a/wireguard-broker/src/bin/socket_handler.rs
+++ b/wireguard-broker/src/bin/socket_handler.rs
@@ -121,7 +121,7 @@ async fn direct_broker_process(

        // Read the message itself
        let mut res_buf = request; // Avoid allocating memory if we don't have to
-        res_buf.resize(len, 0);
+        res_buf.resize(len as usize, 0);
        stdout.read_exact(&mut res_buf[..len]).await?;

        // Return to the unix socket connection worker
@@ -148,14 +148,6 @@ async fn listen_for_clients(queue: mpsc::Sender<BrokerRequest>, sock: UnixListen
 async fn on_accept(queue: mpsc::Sender<BrokerRequest>, mut stream: UnixStream) -> Result<()> {
    let mut req_buf = Vec::new();

-    {
-        use rosenpass_secret_memory as SM;
-        #[cfg(feature = "experiment_memfd_secret")]
-        SM::secret_policy_try_use_memfd_secrets();
-        #[cfg(not(feature = "experiment_memfd_secret"))]
-        SM::secret_policy_use_only_malloc_secrets();
-    }
-
    loop {
        stream.readable().await?;

@@ -171,7 +163,7 @@ async fn on_accept(queue: mpsc::Sender<BrokerRequest>, mut stream: UnixStream) -
        );

        // Read the message itself
-        req_buf.resize(len, 0);
+        req_buf.resize(len as usize, 0);
        stream.read_exact(&mut req_buf[..len]).await?;

        // Handle the message
--- a/wireguard-broker/src/brokers/mio_client.rs
+++ b/wireguard-broker/src/brokers/mio_client.rs
@@ -1,93 +1,74 @@
-use anyhow::{bail, Context};
+use anyhow::{bail, ensure};
 use mio::Interest;
-use rosenpass_secret_memory::Secret;
-use rosenpass_to::{ops::copy_slice_least_src, To};
-use rosenpass_util::io::{IoResultKindHintExt, TryIoResultKindHintExt};
-use rosenpass_util::length_prefix_encoding::decoder::LengthPrefixDecoder;
-use rosenpass_util::length_prefix_encoding::encoder::LengthPrefixEncoder;
-use rustix::fd::AsFd;
-use std::borrow::{Borrow, BorrowMut};
+use std::collections::VecDeque;
+use std::io::{ErrorKind, Read, Write};
+
+use crate::{SerializedBrokerConfig, WireGuardBroker, WireguardBrokerMio};

 use crate::api::client::{
    BrokerClient, BrokerClientIo, BrokerClientPollResponseError, BrokerClientSetPskError,
 };
-use crate::{SerializedBrokerConfig, WireGuardBroker, WireguardBrokerMio};
+use crate::api::msgs::{self, RESPONSE_MSG_BUFFER_SIZE};

 #[derive(Debug)]
 pub struct MioBrokerClient {
    inner: BrokerClient<MioBrokerClientIo>,
-    mio_token: Option<mio::Token>,
 }

-#[derive(Debug)]
-struct SecretBuffer<const N: usize>(pub Secret<N>);
-
-impl<const N: usize> SecretBuffer<N> {
-    fn new() -> Self {
-        Self(Secret::zero())
-    }
-}
-
-impl<const N: usize> Borrow<[u8]> for SecretBuffer<N> {
-    fn borrow(&self) -> &[u8] {
-        self.0.secret()
-    }
-}
-
-impl<const N: usize> BorrowMut<[u8]> for SecretBuffer<N> {
-    fn borrow_mut(&mut self) -> &mut [u8] {
-        self.0.secret_mut()
-    }
-}
-
-type ReadBuffer = LengthPrefixDecoder<SecretBuffer<4096>>;
-type WriteBuffer = LengthPrefixEncoder<SecretBuffer<4096>>;
+const LEN_SIZE: usize = 8;
+const RECV_BUF_SIZE: usize = RESPONSE_MSG_BUFFER_SIZE;

 #[derive(Debug)]
 struct MioBrokerClientIo {
    socket: mio::net::UnixStream,
-    read_buffer: ReadBuffer,
-    write_buffer: WriteBuffer,
+    send_buf: VecDeque<u8>,
+    recv_state: RxState,
+    expected_state: RxState,
+    recv_buf: [u8; RECV_BUF_SIZE],
+}
+
+#[derive(Debug, Clone, Copy)]
+enum RxState {
+    //Recieving size with buffer offset
+    RxSize(usize),
+    RxBuffer(usize),
 }

 impl MioBrokerClient {
    pub fn new(socket: mio::net::UnixStream) -> Self {
-        let read_buffer = LengthPrefixDecoder::new(SecretBuffer::new());
-        let write_buffer = LengthPrefixEncoder::from_buffer(SecretBuffer::new());
        let io = MioBrokerClientIo {
            socket,
-            read_buffer,
-            write_buffer,
+            send_buf: VecDeque::new(),
+            recv_state: RxState::RxSize(0),
+            recv_buf: [0u8; RECV_BUF_SIZE],
+            expected_state: RxState::RxSize(LEN_SIZE),
        };
        let inner = BrokerClient::new(io);
-        Self {
-            inner,
-            mio_token: None,
-        }
+        Self { inner }
    }

-    fn poll(&mut self) -> anyhow::Result<()> {
+    fn poll(&mut self) -> anyhow::Result<Option<msgs::SetPskResult>> {
        self.inner.io_mut().flush()?;

        // This sucks
-        let res = self.inner.poll_response();
-        match res {
-            Ok(None) => Ok(()),
-            Ok(Some(Ok(()))) => Ok(()),
-            Ok(Some(Err(e))) => {
-                log::warn!("Error from PSK broker: {e:?}");
-                Ok(())
+        match self.inner.poll_response() {
+            Ok(res) => {
+                return Ok(res);
            }
-            Err(BrokerClientPollResponseError::IoError(e)) => Err(e),
-            Err(BrokerClientPollResponseError::InvalidMessage) => bail!("Invalid message"),
-        }
+            Err(BrokerClientPollResponseError::IoError(e)) => {
+                return Err(e);
+            }
+            Err(BrokerClientPollResponseError::InvalidMessage) => {
+                bail!("Invalid message");
+            }
+        };
    }
 }

 impl WireGuardBroker for MioBrokerClient {
    type Error = anyhow::Error;

-    fn set_psk(&mut self, config: SerializedBrokerConfig<'_>) -> anyhow::Result<()> {
+    fn set_psk<'a>(&mut self, config: SerializedBrokerConfig<'a>) -> anyhow::Result<()> {
        use BrokerClientSetPskError::*;
        let e = self.inner.set_psk(config);
        match e {
@@ -108,7 +89,6 @@ impl WireguardBrokerMio for MioBrokerClient {
        registry: &mio::Registry,
        token: mio::Token,
    ) -> Result<(), Self::MioError> {
-        self.mio_token = Some(token);
        registry.register(
            &mut self.inner.io_mut().socket,
            token,
@@ -123,14 +103,9 @@ impl WireguardBrokerMio for MioBrokerClient {
    }

    fn unregister(&mut self, registry: &mio::Registry) -> Result<(), Self::MioError> {
-        self.mio_token = None;
        registry.deregister(&mut self.inner.io_mut().socket)?;
        Ok(())
    }
-
-    fn mio_token(&self) -> Option<mio::Token> {
-        self.mio_token
-    }
 }

 impl BrokerClientIo for MioBrokerClientIo {
@@ -138,101 +113,147 @@ impl BrokerClientIo for MioBrokerClientIo {
    type RecvError = anyhow::Error;

    fn send_msg(&mut self, buf: &[u8]) -> Result<(), Self::SendError> {
-        // Clear write buffer (blocking write)
-        self.flush_blocking()?;
-        assert!(self.write_buffer.exhausted(), "flush_blocking() should have put the write buffer in exhausted state. Developer error!");
-
-        // Emplace new message in write buffer
-        copy_slice_least_src(buf).to(self.write_buffer.buffer_bytes_mut());
-        self.write_buffer
-            .restart_write_with_new_message(buf.len())?;
-
-        // Give the write buffer a chance to clear
+        self.flush()?;
+        self.send_or_buffer(&(buf.len() as u64).to_le_bytes())?;
+        self.send_or_buffer(&buf)?;
        self.flush()?;

        Ok(())
    }

    fn recv_msg(&mut self) -> Result<Option<&[u8]>, Self::RecvError> {
-        use std::io::ErrorKind as K;
        loop {
-            match self
-                .read_buffer
-                .read_from_stdio(&self.socket)
-                .try_io_err_kind_hint()
-            {
-                Ok(_) => {} // Moved down in the loop
-                Err((_, Some(K::WouldBlock))) => break Ok(None),
-                Err((_, Some(K::Interrupted))) => continue,
-                Err((e, _)) => break Err(e)?,
-            }
+            match (self.recv_state, self.expected_state) {
+                //Stale Buffer state or recieved everything
+                (RxState::RxSize(x), RxState::RxSize(y))
+                | (RxState::RxBuffer(x), RxState::RxBuffer(y))
+                    if x == y =>
+                {
+                    match self.recv_state {
+                        RxState::RxSize(s) => {
+                            let len: &[u8; LEN_SIZE] = self.recv_buf[0..s].try_into().unwrap();
+                            let len: usize = u64::from_le_bytes(*len) as usize;

-            // OK case moved here to appease borrow checker
-            break Ok(self.read_buffer.message()?);
+                            ensure!(
+                                len <= msgs::RESPONSE_MSG_BUFFER_SIZE,
+                                "Oversized buffer ({len}) in psk buffer response."
+                            );
+
+                            self.recv_state = RxState::RxBuffer(0);
+                            self.expected_state = RxState::RxBuffer(len);
+                            continue;
+                        }
+                        RxState::RxBuffer(s) => {
+                            self.recv_state = RxState::RxSize(0);
+                            self.expected_state = RxState::RxSize(LEN_SIZE);
+                            return Ok(Some(&self.recv_buf[0..s]));
+                        }
+                    }
+                }
+
+                //Recieve if x < y
+                (RxState::RxSize(x), RxState::RxSize(y))
+                | (RxState::RxBuffer(x), RxState::RxBuffer(y))
+                    if x < y =>
+                {
+                    let bytes = raw_recv(&self.socket, &mut self.recv_buf[x..y])?;
+
+                    if x + bytes == y {
+                        return Ok(Some(&self.recv_buf[0..y]));
+                    }
+                    //We didn't recieve everything so let's assume something went wrong
+                    self.recv_state = RxState::RxSize(0);
+                    self.expected_state = RxState::RxSize(LEN_SIZE);
+                    bail!("Invalid state");
+                }
+                _ => {
+                    //Reset states
+                    self.recv_state = RxState::RxSize(0);
+                    self.expected_state = RxState::RxSize(LEN_SIZE);
+                    bail!("Invalid state");
+                }
+            };
        }
    }
 }

 impl MioBrokerClientIo {
-    fn flush_blocking(&mut self) -> anyhow::Result<()> {
-        self.flush()?;
-        if self.write_buffer.exhausted() {
-            return Ok(());
-        }
+    fn flush(&mut self) -> anyhow::Result<()> {
+        let (fst, snd) = self.send_buf.as_slices();

-        log::warn!("Could not flush PSK broker write buffer in non-blocking mode. Flushing in blocking mode!");
-        use rustix::io::{fcntl_getfd, fcntl_setfd, FdFlags};
-
-        // Build O_NONBLOCK
-        let o_nonblock = {
-            let v = libc::O_NONBLOCK;
-            let v = v.try_into().context(
-                "Could not cast O_NONBLOCK (`{v}`) from libc int (i32?) to rustix int (u32?)",
-            )?;
-            FdFlags::from_bits(v).context(
-                "Could not cast O_NONBLOCK (`{v}`) from rustix int to rustix::io::FdFlags",
-            )?
+        let (written, res) = match raw_send(&self.socket, fst) {
+            Ok(w1) if w1 >= fst.len() => match raw_send(&self.socket, snd) {
+                Ok(w2) => (w1 + w2, Ok(())),
+                Err(e) => (w1, Err(e)),
+            },
+            Ok(w1) => (w1, Ok(())),
+            Err(e) => (0, Err(e)),
        };

-        // Determine previous and new file descriptor flags
-        let flags_orig = fcntl_getfd(self.socket.as_fd())?;
-        let mut flags_blocking = flags_orig;
-        flags_blocking.insert(o_nonblock);
+        self.send_buf.drain(..written);

-        // Set file descriptor flags
-        fcntl_setfd(self.socket.as_fd(), flags_blocking)?;
+        (&self.socket).try_io(|| (&self.socket).flush())?;

-        // Blocking write
-        let res = loop {
-            if self.write_buffer.exhausted() {
-                break Ok(());
-            }
-
-            match self.flush() {
-                Ok(_) => {}
-                Err(e) => break Err(e),
-            }
-        };
-
-        // Restore file descriptor flags
-        fcntl_setfd(self.socket.as_fd(), flags_orig)?;
-
-        Ok(res?)
+        res
    }

-    fn flush(&mut self) -> std::io::Result<()> {
-        use std::io::ErrorKind as K;
-        loop {
-            match self
-                .write_buffer
-                .write_to_stdio(&self.socket)
-                .io_err_kind_hint()
-            {
-                Ok(_) => break Ok(()),
-                Err((_, K::WouldBlock)) => break Ok(()),
-                Err((_, K::Interrupted)) => continue,
-                Err((e, _)) => return Err(e)?,
-            }
+    fn send_or_buffer(&mut self, buf: &[u8]) -> anyhow::Result<()> {
+        let mut off = 0;
+
+        if self.send_buf.is_empty() {
+            off += raw_send(&self.socket, buf)?;
        }
+
+        self.send_buf.extend((&buf[off..]).iter());
+
+        Ok(())
    }
 }
+
+fn raw_send(mut socket: &mio::net::UnixStream, data: &[u8]) -> anyhow::Result<usize> {
+    let mut off = 0;
+
+    socket.try_io(|| {
+        loop {
+            if off == data.len() {
+                return Ok(());
+            }
+            match socket.write(&data[off..]) {
+                Ok(n) => {
+                    off += n;
+                }
+                Err(e) if e.kind() == ErrorKind::Interrupted => {
+                    // pass – retry
+                }
+                Err(e) if off > 0 || e.kind() == ErrorKind::WouldBlock => return Ok(()),
+                Err(e) => return Err(e),
+            }
+        }
+    })?;
+
+    return Ok(off);
+}
+
+fn raw_recv(mut socket: &mio::net::UnixStream, out: &mut [u8]) -> anyhow::Result<usize> {
+    let mut off = 0;
+
+    socket.try_io(|| {
+        loop {
+            if off == out.len() {
+                return Ok(());
+            }
+            match socket.read(&mut out[off..]) {
+                Ok(n) => {
+                    off += n;
+                }
+                Err(e) if e.kind() == ErrorKind::Interrupted => {
+                    // pass – retry
+                }
+                Err(e) if off > 0 || e.kind() == ErrorKind::WouldBlock => return Ok(()),
+                Err(e) => return Err(e),
+            }
+        }
+    })?;
+
+    return Ok(off);
+}
--- a/wireguard-broker/src/brokers/mod.rs
+++ b/wireguard-broker/src/brokers/mod.rs
@@ -1,6 +1,6 @@
-#[cfg(feature = "experiment_api")]
+#[cfg(feature = "enable_broker_api")]
 pub mod mio_client;
-#[cfg(all(feature = "experiment_api", target_os = "linux"))]
+#[cfg(all(feature = "enable_broker_api", target_os = "linux"))]
 pub mod netlink;

 pub mod native_unix;
--- a/wireguard-broker/src/brokers/native_unix.rs
+++ b/wireguard-broker/src/brokers/native_unix.rs
@@ -16,9 +16,7 @@ const MAX_B64_KEY_SIZE: usize = WG_KEY_LEN * 5 / 3;
 const MAX_B64_PEER_ID_SIZE: usize = WG_PEER_LEN * 5 / 3;

 #[derive(Debug)]
-pub struct NativeUnixBroker {
-    mio_token: Option<mio::Token>,
-}
+pub struct NativeUnixBroker {}

 impl Default for NativeUnixBroker {
    fn default() -> Self {
@@ -28,7 +26,7 @@ impl Default for NativeUnixBroker {

 impl NativeUnixBroker {
    pub fn new() -> Self {
-        Self { mio_token: None }
+        Self {}
    }
 }

@@ -90,9 +88,8 @@ impl WireguardBrokerMio for NativeUnixBroker {
    fn register(
        &mut self,
        _registry: &mio::Registry,
-        token: mio::Token,
+        _token: mio::Token,
    ) -> Result<(), Self::MioError> {
-        self.mio_token = Some(token);
        Ok(())
    }

@@ -101,13 +98,8 @@ impl WireguardBrokerMio for NativeUnixBroker {
    }

    fn unregister(&mut self, _registry: &mio::Registry) -> Result<(), Self::MioError> {
-        self.mio_token = None;
        Ok(())
    }
-
-    fn mio_token(&self) -> Option<mio::Token> {
-        self.mio_token
-    }
 }

 #[derive(Debug, Builder)]
--- a/wireguard-broker/src/brokers/netlink.rs
+++ b/wireguard-broker/src/brokers/netlink.rs
@@ -79,7 +79,6 @@ impl WireGuardBroker for NetlinkWireGuardBroker {
    fn set_psk(&mut self, config: SerializedBrokerConfig) -> Result<(), Self::Error> {
        let config: NetworkBrokerConfig = config
            .try_into()
-            // TODO: I think this is the wrong error
            .map_err(|_e| SetPskError::NoSuchInterface)?;
        // Ensure that the peer exists by querying the device configuration
        // TODO: Use InvalidInterfaceError
@@ -88,20 +87,21 @@ impl WireGuardBroker for NetlinkWireGuardBroker {
            .sock
            .get_device(wg::DeviceInterface::from_name(config.iface))?;

-        if !state
+        if state
            .peers
            .iter()
-            .any(|p| p.public_key == config.peer_id.value)
+            .find(|p| &p.public_key == &config.peer_id.value)
+            .is_none()
        {
            return Err(SetPskError::NoSuchPeer);
        }

        // Peer update description
-        let mut set_peer = wireguard_uapi::set::Peer::from_public_key(config.peer_id);
+        let mut set_peer = wireguard_uapi::set::Peer::from_public_key(&config.peer_id);
        set_peer
            .flags
            .push(wireguard_uapi::linux::set::WgPeerF::UpdateOnly);
-        set_peer.preshared_key = Some(config.psk.secret());
+        set_peer.preshared_key = Some(&config.psk.secret());

        // Device update description
        let mut set_dev = wireguard_uapi::set::Device::from_ifname(config.iface);
--- a/wireguard-broker/src/lib.rs
+++ b/wireguard-broker/src/lib.rs
@@ -1,5 +1,5 @@
 use rosenpass_secret_memory::{Public, Secret};
-use std::fmt::Debug;
+use std::{fmt::Debug, result::Result};

 pub const WG_KEY_LEN: usize = 32;
 pub const WG_PEER_LEN: usize = 32;
@@ -28,15 +28,13 @@ pub trait WireguardBrokerMio: WireGuardBroker {
        registry: &mio::Registry,
        token: mio::Token,
    ) -> Result<(), Self::MioError>;
-    fn mio_token(&self) -> Option<mio::Token>;
-
    /// Run after a mio::poll operation
    fn process_poll(&mut self) -> Result<(), Self::MioError>;

    fn unregister(&mut self, registry: &mio::Registry) -> Result<(), Self::MioError>;
 }

-#[cfg(feature = "experiment_api")]
+#[cfg(feature = "enable_broker_api")]
 pub mod api;

 pub mod brokers;
--- a/wireguard-broker/tests/integration.rs
+++ b/wireguard-broker/tests/integration.rs
@@ -0,0 +1,140 @@
+#[cfg(feature = "enable_broker_api")]
+#[cfg(test)]
+mod integration_tests {
+
+    use rand::Rng;
+    use rosenpass_secret_memory::{Public, Secret};
+    use rosenpass_wireguard_broker::api::msgs::{
+        SetPskError, REQUEST_MSG_BUFFER_SIZE, RESPONSE_MSG_BUFFER_SIZE,
+    };
+    use rosenpass_wireguard_broker::api::server::{BrokerServer, BrokerServerError};
+    use rosenpass_wireguard_broker::brokers::mio_client::MioBrokerClient;
+    use rosenpass_wireguard_broker::WG_KEY_LEN;
+    use rosenpass_wireguard_broker::WG_PEER_LEN;
+    use rosenpass_wireguard_broker::{SerializedBrokerConfig, WireGuardBroker};
+    use std::io::Read;
+    use std::sync::{Arc, Mutex};
+
+    #[derive(Default, Debug)]
+    struct MockServerBrokerInner {
+        psk: Option<Secret<WG_KEY_LEN>>,
+        peer_id: Option<Public<WG_PEER_LEN>>,
+        interface: Option<String>,
+    }
+
+    #[derive(Debug)]
+    struct MockServerBroker {
+        inner: Arc<Mutex<MockServerBrokerInner>>,
+    }
+
+    impl MockServerBroker {
+        fn new(inner: Arc<Mutex<MockServerBrokerInner>>) -> Self {
+            Self { inner }
+        }
+    }
+
+    impl WireGuardBroker for MockServerBroker {
+        type Error = SetPskError;
+
+        fn set_psk(&mut self, config: SerializedBrokerConfig) -> Result<(), Self::Error> {
+            loop {
+                let mut lock = self.inner.try_lock();
+
+                if let Ok(ref mut mutex) = lock {
+                    **mutex = MockServerBrokerInner {
+                        psk: Some(config.psk.clone()),
+                        peer_id: Some(config.peer_id.clone()),
+                        interface: Some(std::str::from_utf8(config.interface).unwrap().to_string()),
+                    };
+                    break;
+                }
+            }
+            Ok(())
+        }
+    }
+
+    procspawn::enable_test_support!();
+
+    #[test]
+    fn test_psk_exchanges() {
+        const TEST_RUNS: usize = 100;
+
+        use rosenpass_secret_memory::test_spawn_process_provided_policies;
+
+        test_spawn_process_provided_policies!({
+            let server_broker_inner = Arc::new(Mutex::new(MockServerBrokerInner::default()));
+            // Create a mock BrokerServer
+            let server_broker = MockServerBroker::new(server_broker_inner.clone());
+
+            let mut server = BrokerServer::<SetPskError, MockServerBroker>::new(server_broker);
+
+            let (client_socket, mut server_socket) = mio::net::UnixStream::pair().unwrap();
+
+            // Spawn a new thread to connect to the unix socket
+            let handle = std::thread::spawn(move || {
+                for _ in 0..TEST_RUNS {
+                    // Wait for 8 bytes of length to come in
+                    let mut length_buffer = [0; 8];
+
+                    while let Err(_err) = server_socket.read_exact(&mut length_buffer) {}
+
+                    let length = u64::from_le_bytes(length_buffer) as usize;
+
+                    // Read the amount of length bytes into a buffer
+                    let mut data_buffer = [0; REQUEST_MSG_BUFFER_SIZE];
+                    while let Err(_err) = server_socket.read_exact(&mut data_buffer[0..length]) {}
+
+                    let mut response = [0; RESPONSE_MSG_BUFFER_SIZE];
+                    server.handle_message(&data_buffer[0..length], &mut response)?;
+                }
+                Ok::<(), BrokerServerError>(())
+            });
+
+            // Create a MioBrokerClient and send a psk
+            let mut client = MioBrokerClient::new(client_socket);
+
+            for _ in 0..TEST_RUNS {
+                //Create psk of random 32 bytes
+                let psk = Secret::random();
+                let peer_id = Public::random();
+                let interface = "test";
+                let config = SerializedBrokerConfig {
+                    psk: &psk,
+                    peer_id: &peer_id,
+                    interface: interface.as_bytes(),
+                    additional_params: &[],
+                };
+                client.set_psk(config).unwrap();
+
+                //Sleep for a while to allow the server to process the message
+                std::thread::sleep(std::time::Duration::from_millis(
+                    rand::thread_rng().gen_range(100..500),
+                ));
+
+                let psk = psk.secret().to_owned();
+
+                loop {
+                    let mut lock = server_broker_inner.try_lock();
+
+                    if let Ok(ref mut inner) = lock {
+                        // Check if the psk is received by the server
+                        let received_psk = &inner.psk;
+                        assert_eq!(
+                            received_psk.as_ref().map(|psk| psk.secret().to_owned()),
+                            Some(psk)
+                        );
+
+                        let recieved_peer_id = inner.peer_id;
+                        assert_eq!(recieved_peer_id, Some(peer_id));
+
+                        let target_interface = &inner.interface;
+                        assert_eq!(target_interface.as_deref(), Some(interface));
+
+                        break;
+                    }
+                }
+            }
+            handle.join().unwrap().unwrap();
+        });
+    }
+}