proxy: include priority field in push notification JSON payload

The HTTP Urgency header set on WebPush requests is not exposed to UnifiedPush Android clients by the connector library. Include a "priority" field ("high" or "normal") directly in the JSON body so that clients can determine whether a push notification requires immediate wake-up processing or can be deferred until the next natural activity. This complements the daemon-side priority assignment (Gerrit #34059) and allows UnifiedPush (F-Droid) builds to benefit from the same battery savings as FCM builds. Change-Id: Id316ff89e64e59d1b224f5b4e14da6b36dc62c95 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
proxy: fix resource leaks and improve mobile battery life
2026-11-11 22:07:10 +00:00 · 2026-05-20 18:55:12 -04:00 · 2026-05-16 18:47:07 -04:00
52 changed files with 517 additions and 890 deletions
@@ -16,7 +16,7 @@ jobs:
    name: Ubuntu/GCC Meson build
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      - name: Install Dependencies
        run: |
@@ -40,7 +40,7 @@ jobs:
      matrix:
        cxx_standard: [17, 20, 23]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      - name: Install Minimal Dependencies
        run: |
@@ -78,7 +78,7 @@ jobs:
        DEBIAN_FRONTEND: noninteractive

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      - name: Install Dependencies
        run: |
@@ -131,7 +131,7 @@ jobs:
      matrix:
        cxx_standard: [17, 20, 23]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      - name: Install Homebrew Dependencies
        run: brew install msgpack-cxx asio gnutls nettle readline fmt jsoncpp argon2 openssl cppunit
@@ -6,7 +6,7 @@ jobs:
    name: Clang Static Analysis
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
      - name: deps
        run: |
          sudo apt update && \
@@ -27,7 +27,7 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v7
+      uses: actions/checkout@v6

    - name: Initialize CodeQL
      uses: github/codeql-action/init@v4
@@ -16,14 +16,14 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15]
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest]

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      # Run locally with: pipx run cibuildwheel --platform linux python
      - name: Build wheels
-        uses: pypa/cibuildwheel@v4.1.1
+        uses: pypa/cibuildwheel@v3.4.1
        with:
          package-dir: python

@@ -36,7 +36,7 @@ jobs:
    name: Build wheels on Windows
    runs-on: windows-latest
    env:
-      VCPKG_VERSION: "2026.06.01"
+      VCPKG_VERSION: "2025.07.25"
      VCPKG_INSTALLATION_ROOT: "C:\\vcpkg"
      VCPKG_DISABLE_METRICS: "1"
      VCPKG_DEFAULT_TRIPLET: x64-windows-release
@@ -44,11 +44,11 @@ jobs:
      VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}\vcpkg_binary_cache

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6

      - name: Cache vcpkg installed packages
        id: cache-vcpkg
-        uses: actions/cache@v6
+        uses: actions/cache@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -25,7 +25,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -66,7 +66,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -107,7 +107,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -148,7 +148,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -190,7 +190,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -231,7 +231,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -273,7 +273,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -309,7 +309,7 @@ jobs:
    name: Build Windows MSI Installer
    runs-on: windows-latest
    env:
-      VCPKG_VERSION: "2026.06.01"
+      VCPKG_VERSION: "2025.07.25"
      VCPKG_INSTALLATION_ROOT: "C:\\vcpkg"
      VCPKG_DISABLE_METRICS: "1"
      VCPKG_DEFAULT_TRIPLET: x64-windows
@@ -319,7 +319,7 @@ jobs:
      contents: read
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
        with:
          submodules: recursive

@@ -334,7 +334,7 @@ jobs:

      - name: Cache vcpkg installed packages
        id: cache-vcpkg
-        uses: actions/cache@v6
+        uses: actions/cache@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -413,7 +413,7 @@ jobs:
    name: Build Windows dhtnode
    runs-on: windows-latest
    env:
-      VCPKG_VERSION: "2026.06.01"
+      VCPKG_VERSION: "2025.07.25"
      VCPKG_INSTALLATION_ROOT: "C:\\vcpkg"
      VCPKG_DISABLE_METRICS: "1"
      VCPKG_DEFAULT_TRIPLET: x64-windows-static-release
@@ -423,7 +423,7 @@ jobs:
      contents: read
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
        with:
          submodules: recursive

@@ -432,7 +432,7 @@ jobs:

      - name: Cache vcpkg static installed packages
        id: cache-vcpkg-static
-        uses: actions/cache@v6
+        uses: actions/cache@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -499,7 +499,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Download Windows MSI artifact
        uses: actions/download-artifact@v8
@@ -9,7 +9,7 @@ on:
    branches: [ main, master ]

 env:
-  VCPKG_VERSION: "2026.06.01"
+  VCPKG_VERSION: "2026.01.16"
  VCPKG_INSTALLATION_ROOT: "C:\\vcpkg"
  VCPKG_DISABLE_METRICS: "1"
  VCPKG_INSTALLED_DIR: ${{ github.workspace }}\vcpkg_installed
@@ -27,7 +27,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up MSVC
        uses: microsoft/setup-msbuild@v3
@@ -41,7 +41,7 @@ jobs:

      - name: Cache vcpkg installed packages
        id: cache-vcpkg
-        uses: actions/cache@v6
+        uses: actions/cache@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -75,7 +75,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up MSVC
        uses: microsoft/setup-msbuild@v3
@@ -89,7 +89,7 @@ jobs:

      - name: Cache vcpkg static installed packages
        id: cache-vcpkg-static
-        uses: actions/cache@v6
+        uses: actions/cache@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -125,14 +125,14 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up MSVC
        uses: microsoft/setup-msbuild@v3

      - name: Restore vcpkg installed packages
        id: cache-vcpkg-restore
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -202,14 +202,14 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up MSVC
        uses: microsoft/setup-msbuild@v3

      - name: Restore vcpkg static installed packages
        id: cache-vcpkg-static-restore
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -275,7 +275,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Setup MinGW
        uses: msys2/setup-msys2@v2
@@ -69,3 +69,4 @@ build-*/
 install/
 vcpkg_installed/

+jamid.log
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.21...4.4)
+cmake_minimum_required (VERSION 3.21...3.31)
 if(POLICY CMP0091)
    cmake_policy(SET CMP0091 NEW)
 endif()
@@ -9,8 +9,8 @@ if(POLICY CMP0167)
    cmake_policy(SET CMP0167 NEW)
 endif()

-set (opendht_VERSION_MAJOR 4)
-set (opendht_VERSION_MINOR 2.0)
+set (opendht_VERSION_MAJOR 3)
+set (opendht_VERSION_MINOR 7.9)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -600,7 +600,7 @@ dht_runner_put_signed(
 void
 dht_runner_put_encrypted(dht_runner* r,
                         const dht_infohash* h,
-                         const dht_pkid* to,
+                         const dht_infohash* to,
                         const dht_value* v,
                         dht_done_cb done_cb,
                         void* cb_user_data,
@@ -608,7 +608,7 @@ dht_runner_put_encrypted(dht_runner* r,
 {
    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
    auto hash = reinterpret_cast<const dht::InfoHash*>(h);
-    auto toHash = reinterpret_cast<const dht::PkId*>(to);
+    auto toHash = reinterpret_cast<const dht::InfoHash*>(to);
    auto value = reinterpret_cast<const ValueSp*>(v);
    runner->putEncrypted(
        *hash,
@@ -195,7 +195,7 @@ OPENDHT_C_PUBLIC void dht_runner_put_signed(dht_runner* runner,
                                            bool permanent);
 OPENDHT_C_PUBLIC void dht_runner_put_encrypted(dht_runner* runner,
                                               const dht_infohash* hash,
-                                               const dht_pkid* to,
+                                               const dht_infohash* to,
                                               const dht_value* value,
                                               dht_done_cb done_cb,
                                               void* cb_user_data,
@@ -1,193 +1,102 @@
-.TH DHTNODE 1 2026-04-18
+.TH DHTNODE 1 2019-06-08
 .SH NAME
 .B dhtnode
 - a simple OpenDHT command line node runner.
 .SH SYNOPSIS
 .B dhtnode
 [\fB\-h\fR]
-[\fB\-V\fR]
 [\fB\-v\fR [\fB\-l\fR \fIlogfile\fR] [\fB\-L\fR]]
-[\fB\-i\fR [\fB\-I\fR \fIfile\fR]]
-[\fB\-c\fR \fIfile\fR]
-[\fB\-k\fR \fIfile\fR]
-[\fB\-m\fR \fIpassword\fR]
+[\fB\-i\fR [\fB\-\-save\-identity\fR \fIfile\fR]]
 [\fB\-d\fR] [\fB\-s\fR]
-[\fB\-D\fR] [\fB\-U\fR] [\fB\-P\fR]
 [\fB\-n\fR \fInetwork_id\fR]
 [\fB\-p\fR \fIlocal_port\fR]
 [\fB\-b\fR \fIbootstrap_host\fR[:\fIport\fR]]
-[\fB\-f\fR \fIpath\fR]
-[\fB\-S\fR \fIport\fR]
-[\fB\-e\fR \fIport\fR]
-[\fB\-a\fR \fIaddress\fR]
-[\fB\-w\fR \fIfile\fR]
-[\fB\-K\fR \fIfile\fR]
-[\fB\-M\fR \fIpassword\fR]
-[\fB\-C\fR \fIserver\fR]
-[\fB\-y\fR \fIendpoint\fR]
-[\fB\-z\fR \fIkey\fR]
-[\fB\-u\fR \fIbundleid\fR]
+[\fB\-\-certificate\fR \fIfile\fR]
+[\fB\-\-privkey\fR \fIfile\fR]
+[\fB\-\-privkey\-password\fR \fIpassword\fR]
+[\fB\-\-proxyserver\fR \fIport\fR]
+[\fB\-\-proxyclient\fR \fIserver\fR]
 .SH DESCRIPTION
-Runs an OpenDHT node, with an interactive CLI (default) or as a daemon (with \fB'-d'\fP or \fB'-s'\fP).
+Runs an OpenDHT node, with a CLI (default) or as a daemon (with \fB'-d'\fP or \fB'-s'\fP).
 Commands available in the interactive shell are:
 .EX
    h, help    Print this help message.
-    x, quit    Quit the program.
+    q, quit    Quit the program.
    log        Start/stop printing DHT logs.

    Node information:
    ll         Print basic information and stats about the current node.
-    ls [key]   Print basic information about current search(es).
-    ld [key]   Print basic information about currenty stored values on this
-               node (or for a specific key).
-    lr         Print the full current routing table of this node.
+    ls         Print basic information about current searches.
+    ld         Print basic information about currenty stored values on this node.
+    lr         Print the full current routing table of this node

    Operations on the DHT:
-    b <ip:port>            Ping potential node at given IP address/port.
-    g <key>                Get values at <key>.
-    l <key>                Listen for value changes at <key>.
-    cl <key> <token>       Cancel listen for <token> and <key>.
-    p <key> <str>          Put string value at <key>.
-    pp <key> <str>         Put string value at <key> (persistent version).
-    cpp <key> <id>         Cancel persistent put operation for <key> and
-                           value <id>.
-    s <key> <str>          Put string value at <key>, signed with our
-                           generated private key.
-    e <key> <dest> <str>   Put string value at <key>, encrypted for <dest>
-                           with its public key (if found).
-    cc                     Trigger connectivity changed signal.
-
-    Operations with the proxy (if compiled with proxy server support):
-    pst [port] <pushServer>  Start the proxy interface on port.
-    psx [port]               Start the proxy SSL interface on port.
-    psp [port]               Stop the proxy interface on port.
-
-    Operations with the proxy (if compiled with proxy client support):
-    stt [server_address] <device_key>  Start the proxy client.
-    stp                                Stop the proxy client.
-    rs  [token]                        Resubscribe to opendht.
-    rp  [token]                        Inject a push notification.
+    b ip:port             Ping potential node at given IP address/port.
+    g [key]               Get values at [key].
+    l [key]               Listen for value changes at [key].
+    p [key] [str]         Put string value at [key].
+    s [key] [str]         Put string value at [key], signed with our generated
+                          private key.
+    e [key] [dest] [str]  Put string value at [key], encrypted for [dest] with
+                          its public key (if found).
 .EE
 .SH OPTIONS
 .TP
-\fB\-h\fP, \fB\-\-help\fP
-Prints help and exits.
+\fB\-h\fP
+Prints some help.
 .TP
-\fB\-V\fP, \fB\-\-version\fP
-Prints version information and exits.
+\fB\-v\fP
+Enable the verbose mode (log to stdout/stderr by default)
 .TP
-\fB\-v\fP, \fB\-\-verbose\fP
-Enable verbose mode (log to stdout/stderr by default).
+\fB\-l\fP \fIlog_file\fP
+Write log to file instead of stdout/stderr
 .TP
-\fB\-l\fP \fIlogfile\fP, \fB\-\-logfile\fP \fIlogfile\fP
-Write log to file instead of stdout/stderr.
+\fB\-L\fP
+Write log to syslog instead of stdout/stderr
 .TP
-\fB\-L\fP, \fB\-\-syslog\fP
-Write log to syslog instead of stdout/stderr (enables verbose mode).
+\fB\-i\fP
+Generate cryptographic identity for the node.
 .TP
-\fB\-i\fP, \fB\-\-identity\fP
-Generate a cryptographic identity (RSA key pair and self-signed certificate)
-for the node. Required to perform cryptographic operations (encrypt/sign values)
-if no private key file is provided.
-.TP
-\fB\-I\fP \fIfile\fP, \fB\-\-save\-identity\fP \fIfile\fP
+\fB\-\-save\-identity\fP \fIfile\fP
 Save generated identity (certificate and private key) to given file prefix.
-Files are saved as \fIfile\fP and \fIfile\fP_ca.
 .TP
-\fB\-c\fP \fIfile\fP, \fB\-\-certificate\fP \fIfile\fP
-Load identity certificate from given file. If specified, the certificate is
-published on the DHT.
+\fB\-\-certificate\fP \fIfile\fP
+Load identity certificate from given file.
 .TP
-\fB\-k\fP \fIfile\fP, \fB\-\-privkey\fP \fIfile\fP
-Load identity private key from given file. Required to perform cryptographic
-operations if no identity is generated.
+\fB\-\-privkey\fP \fIfile\fP
+Load identity private key from given file.
 .TP
-\fB\-m\fP \fIpassword\fP, \fB\-\-privkey\-password\fP \fIpassword\fP
+\fB\-\-privkey\-password\fP \fIpassword\fP
 Password to use for private key encryption or decryption (optional).
 .TP
-\fB\-d\fP, \fB\-\-daemonize\fP
-Run the program in daemon mode (will fork in the background). When verbose mode
-is enabled, logs to syslog by default.
+\fB\-d\fP
+Run the program in daemon mode (will fork in the background).
 .TP
-\fB\-s\fP, \fB\-\-service\fP
+\fB\-s\fP
 Run the program in service mode (non\-forking daemon).
 .TP
-\fB\-D\fP, \fB\-\-peer\-discovery\fP
+\fB\-D\fP
 Enables multicast automatic local peer discovery.
 .TP
-\fB\-U\fP, \fB\-\-no\-rate\-limit\fP
-Disable rate limiting (allows unlimited requests and storage).
+\fB\-f\fP \fIfile\fP
+Specify a file path to persist/load the node state.
 .TP
-\fB\-P\fP, \fB\-\-public\-stable\fP
-Enable public stable mode.
+\fB\-n\fP \fInetwork_id\fP
+Specify the network id. This let you connect to distinct networks and prevents
+the merge of two different networks (available since OpenDHT v0.6.1).
 .TP
-\fB\-f\fP \fIpath\fP, \fB\-\-persist\fP \fIpath\fP
-Specify a file path to persist/load the node state (routing table and values).
+\fB\-p\fP \fIlocal_port\fP
+Use UDP port \fIlocal_port\fP for the program to bind to.
 .TP
-\fB\-n\fP \fInetwork_id\fP, \fB\-\-net\fP \fInetwork_id\fP
-Specify the network id. This lets you connect to distinct networks and prevents
-the merge of two different networks. Defaults to 0 (the main public network).
+\fB\-b\fP \fIbootstrap_host\fP[:\fIport\fP]
+The program needs to be given a node to connect to the network. You use this
+option to provide the ip address of that node.
 .TP
-\fB\-p\fP \fIlocal_port\fP, \fB\-\-port\fP \fIlocal_port\fP
-Use UDP port \fIlocal_port\fP for the program to bind to. If not set, will use
-any available port. The default OpenDHT port for public nodes is 4222.
+\fB\-\-proxyserver\fP \fIlocal_port\fP
+Run a proxy server bound to this DHT node on HTTP port \fIlocal_port\fP
 .TP
-\fB\-b\fP \fIbootstrap_host\fP[:\fIport\fP], \fB\-\-bootstrap\fP \fIbootstrap_host\fP[:\fIport\fP]
-Specify a bootstrap node address to connect to the network.
-.TP
-\fB\-S\fP \fIlocal_port\fP, \fB\-\-proxyserver\fP \fIlocal_port\fP
-Run a REST API proxy server bound to this DHT node on HTTP port \fIlocal_port\fP.
-.TP
-\fB\-e\fP \fIlocal_port\fP, \fB\-\-proxyserverssl\fP \fIlocal_port\fP
-Run a REST API proxy server with SSL bound to this DHT node on HTTPS port \fIlocal_port\fP.
-.TP
-\fB\-a\fP \fIaddress\fP, \fB\-\-proxy\-addr\fP \fIaddress\fP
-Proxy server bind address.
-.TP
-\fB\-w\fP \fIfile\fP, \fB\-\-proxy\-certificate\fP \fIfile\fP
-Load proxy SSL certificate from given file.
-.TP
-\fB\-K\fP \fIfile\fP, \fB\-\-proxy\-privkey\fP \fIfile\fP
-Load proxy SSL private key from given file.
-.TP
-\fB\-M\fP \fIpassword\fP, \fB\-\-proxy\-privkey\-password\fP \fIpassword\fP
-Password for the proxy private key encryption or decryption (optional).
-.TP
-\fB\-C\fP \fIserver\fP, \fB\-\-proxyclient\fP \fIserver\fP
-Run this DHT node in proxy client mode, and connect to \fIserver\fP.
-.TP
-\fB\-y\fP \fIendpoint\fP, \fB\-\-pushserver\fP \fIendpoint\fP
-Push notification server endpoint.
-.TP
-\fB\-z\fP \fIkey\fP, \fB\-\-devicekey\fP \fIkey\fP
-Device key for push notifications.
-.TP
-\fB\-u\fP \fIbundleid\fP, \fB\-\-bundleid\fP \fIbundleid\fP
-Bundle ID for push notifications.
-.SH EXAMPLES
-Run a node using bootstrap.jami.net as a bootstrap:
-.PP
-.EX
-dhtnode -b bootstrap.jami.net:4222
-.EE
-.PP
-Run a node as a non-forking daemon on port 4222:
-.PP
-.EX
-dhtnode -b bootstrap.jami.net -p 4222 -s
-.EE
-.PP
-Run a proxy server on port 8000:
-.PP
-.EX
-dhtnode -b bootstrap.jami.net:4222 --proxyserver 8000
-.EE
-.PP
-Use a proxy client to connect to a proxy server:
-.PP
-.EX
-dhtnode --proxyclient dhtproxy.jami.net:80
-.EE
+\fB\-\-proxyclient\fP \fIserver\fP
+Run this DHT node in proxy client mode, and connect to \fIserver\fP
 .SH AUTHORS
 .TP
 Program written by
@@ -187,6 +187,8 @@ using ShutdownCallback = std::function<void()>;
 using IdentityAnnouncedCb = std::function<void(bool)>;
 using PublicAddressChangedCb = std::function<void(std::vector<SockAddr>)>;

+using CertificateStoreQueryLegacy
+    = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;
 using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const PkId& pk_id)>;

 using DoneCallback = std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)>;
@@ -267,14 +267,9 @@ public:
    /**
     * Sign this revocation list using provided key and certificate.
     * Validity_period sets the duration until next update (default to no next update).
-     * If `number` is non-zero, it is stored verbatim (big-endian) as the CRL Number
-     * extension. Otherwise the number is initialized randomly on the first signature
-     * and incremented on subsequent ones.
     */
-    void sign(const PrivateKey&, const Certificate&, duration validity_period = {}, uint64_t number = 0);
-    void sign(const Identity& id, duration validity_period = {}, uint64_t number = 0) {
-        sign(*id.first, *id.second, validity_period, number);
-    }
+    void sign(const PrivateKey&, const Certificate&, duration validity_period = {});
+    void sign(const Identity& id) { sign(*id.first, *id.second); }

    bool isSignedBy(const Certificate& issuer) const;

@@ -159,13 +159,7 @@ public:
    {}

    static Value::Filter getFilter() { return EncryptedValue::getFilter(); }
-    virtual void unpackValue(const dht::Value& v) override
-    {
-        BaseClass::unpackValue(v);
-        id = v.id;
-    }

-    dht::Value::Id id {0}; /// Value ID of the trust request, used for deserialization only.
    std::string service;
    std::string conversationId;
    Blob payload;
@@ -429,6 +429,10 @@ private:
    std::unique_ptr<asio::steady_timer> nextProxyConfirmationTimer_;
    std::unique_ptr<asio::steady_timer> listenerRestartTimer_;

+    // Exponential backoff for proxy reconnection (1 min → 2 → 4 → ... → 30 min)
+    std::chrono::minutes proxyRetryDelay_ {1};
+    static constexpr std::chrono::minutes MAX_PROXY_RETRY_DELAY {30};
+
    /**
     * Relaunch LISTEN requests if the client disconnect/reconnect.
     */
@@ -61,7 +61,8 @@ public:
        std::unique_ptr<net::DatagramSocket> sock;
        std::shared_ptr<PeerDiscovery> peerDiscovery {};
        StatusCallback statusChangedCallback {};
-        CertificateStoreQuery certificateStore {};
+        CertificateStoreQueryLegacy certificateStore {};
+        CertificateStoreQuery certificateStorePkId {};
        IdentityAnnouncedCb identityAnnouncedCb {};
        PublicAddressChangedCb publicAddressChangedCb {};
        std::unique_ptr<std::mt19937_64> rng {};
@@ -285,6 +286,21 @@ public:
    }
    void putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb = {}, bool permanent = false);

+    void putEncrypted(
+        InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb = {}, bool permanent = false);
+    void putEncrypted(
+        InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallbackSimple cb, bool permanent = false)
+    {
+        putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
+    }
+
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb = {}, bool permanent = false);
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallbackSimple cb, bool permanent = false)
+    {
+        putEncrypted(hash, to, std::forward<Value>(value), bindDoneCb(cb), permanent);
+    }
+    void putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb = {}, bool permanent = false);
+
    void putEncrypted(InfoHash hash,
                      const std::shared_ptr<crypto::PublicKey>& to,
                      std::shared_ptr<Value> value,
@@ -299,11 +315,13 @@ public:
        putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
    }

+    [[deprecated("Use the shared_ptr version instead")]]
    void putEncrypted(InfoHash hash,
                      const std::shared_ptr<crypto::PublicKey>& to,
                      Value&& value,
                      DoneCallback cb = {},
                      bool permanent = false);
+    [[deprecated("Use the shared_ptr version instead")]]
    void putEncrypted(InfoHash hash,
                      const std::shared_ptr<crypto::PublicKey>& to,
                      Value&& value,
@@ -320,14 +338,6 @@ public:
    {
        putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
    }
-    void putEncrypted(InfoHash hash, const PkId& to, Value&& value, DoneCallback cb = {}, bool permanent = false)
-    {
-        putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
-    }
-    void putEncrypted(InfoHash hash, const PkId& to, Value&& value, DoneCallbackSimple cb, bool permanent = false)
-    {
-        putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), bindDoneCb(cb), permanent);
-    }

    /**
     * Insert known nodes to the routing table, without necessarly ping them.
@@ -440,9 +450,13 @@ public:
    void getPublicAddress(std::function<void(std::vector<SockAddr>&&)>, sa_family_t af = AF_UNSPEC);

    // securedht methods
+
+    [[deprecated("Use PkId version")]] void findCertificate(
+        InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);
    void findCertificate(PkId hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);

    void registerCertificate(const std::shared_ptr<crypto::Certificate>& cert);
+    void setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method);
    void setLocalCertificateStore(CertificateStoreQuery&& query_method);

    /**
@@ -51,11 +51,11 @@ using ConnectHandlerCb = std::function<void(const asio::error_code& ec, const as
 using ssl_socket_t = restinio::impl::tls_socket_t;
 using socket_t = asio::ip::tcp::socket;

-struct OPENDHT_PUBLIC Url
+class OPENDHT_PUBLIC Url
 {
+public:
    Url() = default;
-    Url(std::string url);
-
+    Url(std::string_view url);
    std::string url;
    std::string protocol {"http"};
    std::string_view user;
@@ -149,7 +149,7 @@ public:
    using ResolverCb
        = std::function<void(const asio::error_code& ec, const std::vector<asio::ip::tcp::endpoint>& endpoints)>;

-    Resolver(asio::io_context& ctx, std::string url, std::shared_ptr<log::Logger> logger = {});
+    Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::Logger> logger = {});
    Resolver(asio::io_context& ctx,
             std::string_view host,
             std::string_view service,
@@ -161,6 +161,10 @@ public:
             std::vector<asio::ip::tcp::endpoint> endpoints,
             const bool ssl = false,
             std::shared_ptr<log::Logger> logger = {});
+    Resolver(asio::io_context& ctx,
+             const std::string& url,
+             std::vector<asio::ip::tcp::endpoint> endpoints,
+             std::shared_ptr<log::Logger> logger = {});

    ~Resolver();

@@ -212,19 +216,19 @@ public:

    // resolves implicitly
    Request(asio::io_context& ctx,
-            std::string url,
+            const std::string& url,
            const Json::Value& json,
            OnJsonCb jsoncb,
            std::shared_ptr<log::Logger> logger = {});
-    Request(asio::io_context& ctx, std::string url, OnJsonCb jsoncb, std::shared_ptr<log::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb, std::shared_ptr<log::Logger> logger = {});

-    Request(asio::io_context& ctx, std::string url, std::shared_ptr<log::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::Logger> logger = {});
    Request(asio::io_context& ctx,
            std::string_view host,
            std::string_view service,
            const bool ssl = false,
            std::shared_ptr<log::Logger> logger = {});
-    Request(asio::io_context& ctx, std::string url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});

    // user defined resolver
    Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, sa_family_t family = AF_UNSPEC);
@@ -340,6 +344,8 @@ private:

    dht::crypto::Identity client_identity_;
    std::shared_ptr<dht::crypto::Certificate> server_ca_;
+    std::string service_;
+    std::string host_;

    unsigned int id_;
    static std::atomic_uint ids_;
@@ -113,6 +113,14 @@ public:
     * and put it in the DHT.
     * The operation will be immediate if the recipient' public key is known (otherwise it will be retrived first).
     */
+    void putEncrypted(
+        const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent = false);
+
+    [[deprecated("Use the shared_ptr version instead")]]
+    void putEncrypted(const InfoHash& hash, const InfoHash& to, Value&& v, DoneCallback callback, bool permanent = false)
+    {
+        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
+    }
    void putEncrypted(const InfoHash& hash,
                      const crypto::PublicKey& to,
                      Sp<Value> val,
@@ -137,11 +145,19 @@ public:

    Value decrypt(const Value& v);

+    [[deprecated("Use PkId version")]] void findCertificate(
+        const InfoHash& node, const std::function<void(const Sp<crypto::Certificate>)>& cb);
+    [[deprecated("Use PkId version")]] void findPublicKey(const InfoHash& node,
+                                                          const std::function<void(const Sp<crypto::PublicKey>)>& cb);
+
    void findCertificate(const PkId& id, const std::function<void(const Sp<crypto::Certificate>)>& cb);
    void findPublicKey(const PkId& id, const std::function<void(const Sp<crypto::PublicKey>)>& cb);

    void registerCertificate(const Sp<crypto::Certificate>& cert);

+    [[deprecated("Use PkId version")]] Sp<crypto::Certificate> getCertificate(const InfoHash& node) const;
+    [[deprecated("Use PkId version")]] Sp<crypto::PublicKey> getPublicKey(const InfoHash& node) const;
+
    Sp<crypto::Certificate> getCertificate(const PkId& node) const;
    Sp<crypto::PublicKey> getPublicKey(const PkId& node) const;

@@ -150,6 +166,10 @@ public:
     * The search key used is the public key ID, so there may be multiple certificates retured, signed with
     * the same private key.
     */
+    void setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method)
+    {
+        localQueryMethodLegacy_ = std::move(query_method);
+    }
    void setLocalCertificateStore(CertificateStoreQuery&& query_method) { localQueryMethod_ = std::move(query_method); }
    void setOnPublicAddressChanged(PublicAddressChangedCb cb) override { dht_->setOnPublicAddressChanged(cb); }

@@ -327,10 +347,13 @@ private:

    // method to query the local certificate store
    CertificateStoreQuery localQueryMethod_ {};
+    CertificateStoreQueryLegacy localQueryMethodLegacy_ {};

    // our certificate cache
-    std::map<PkId, Sp<crypto::Certificate>> nodesCertificates_ {};
-    std::map<PkId, Sp<crypto::PublicKey>> nodesPubKeys_ {};
+    std::map<InfoHash, Sp<crypto::Certificate>> nodesCertificates_ {};
+    std::map<InfoHash, Sp<crypto::PublicKey>> nodesPubKeys_ {};
+    std::map<PkId, Sp<crypto::Certificate>> nodesCertificatesLong_ {};
+    std::map<PkId, Sp<crypto::PublicKey>> nodesPubKeysLong_ {};

    std::atomic_bool forward_all_ {false};
    bool enableCache_ {false};
@@ -10,9 +10,7 @@
 #include <future>
 #include <functional>

-#if __cplusplus < 202002L
-#include <ciso646>
-#endif
+#include <ciso646> // fix windows compiler bug

 namespace dht {

@@ -57,12 +55,10 @@ public:
 private:
    std::mutex lock_;
    std::condition_variable cv_ {};
-    std::condition_variable stopCv_ {};
    std::queue<std::function<void()>> tasks_ {};
    std::vector<std::unique_ptr<std::thread>> threads_;
    unsigned readyThreads_ {0};
    bool running_ {true};
-    bool stopping_ {false};

    unsigned minThreads_;
    const unsigned maxThreads_;
@@ -85,14 +85,6 @@ using system_clock = std::chrono::system_clock;
 using time_point = clock::time_point;
 using duration = clock::duration;

-OPENDHT_PUBLIC time_point from_system_time(system_clock::time_point t,
-                                           time_point steady_now,
-                                           system_clock::time_point system_now);
-OPENDHT_PUBLIC time_point from_system_time(system_clock::time_point t);
-OPENDHT_PUBLIC system_clock::time_point to_system_time(time_point t,
-                                                       time_point steady_now,
-                                                       system_clock::time_point system_now);
-OPENDHT_PUBLIC system_clock::time_point to_system_time(time_point t);
 OPENDHT_PUBLIC time_point from_time_t(std::time_t t);
 OPENDHT_PUBLIC std::time_t to_time_t(time_point t);

@@ -5,7 +5,7 @@ project(
    'cython',
    license: 'MIT',
    license_files: 'LICENSE',
-    version: '4.2.0',
+    version: '3.7.9',
    meson_version: '>=1.1.0',
    default_options: ['cpp_std=c++20', 'warning_level=3'],
 )
@@ -15,23 +15,10 @@ nettle = dependency('nettle')
 msgpack = dependency('msgpack-cxx', required: false)
 argon2 = dependency('libargon2')
 fmt = dependency('fmt')
-
-proxy_enabled = get_option('proxy_client').enabled() or get_option('proxy_server').enabled()
-
-openssl = dependency('openssl', required: proxy_enabled)
-jsoncpp = dependency('jsoncpp', required: proxy_enabled)
-llhttp = dependency('llhttp', 'libllhttp', required: proxy_enabled)
-simdutf = dependency('simdutf', required: proxy_enabled)
-
-# restinio is a header-only library that may not ship a pkg-config file
-restinio_dep = dependency('restinio', required: false)
-if not restinio_dep.found()
-    cpp = meson.get_compiler('cpp')
-    if cpp.has_header('restinio/all.hpp', required: proxy_enabled)
-        restinio_dep = declare_dependency()
-    endif
-endif
-
+openssl = dependency('openssl', required: get_option('proxy_client'))
+jsoncpp = dependency('jsoncpp', required: get_option('proxy_client'))
+llhttp = dependency('llhttp', 'libllhttp', required: get_option('proxy_client'))
+simdutf = dependency('simdutf', required: get_option('proxy_client'))
 io_uring = host_machine.system() == 'linux' ? dependency('liburing', required: false) : disabler()

 deps = [
@@ -46,10 +33,6 @@ deps = [
    llhttp,
 ]

-if restinio_dep.found()
-    deps += restinio_dep
-endif
-
 if host_machine.system() == 'linux' and io_uring.found()
    deps += io_uring
 endif
@@ -96,7 +79,7 @@ if get_option('indexation').enabled()
    opendht_src += 'src/indexation/pht.cpp'
    add_project_arguments('-DOPENDHT_INDEXATION', language: 'cpp')
 endif
-if jsoncpp.found() and simdutf.found()
+if jsoncpp.found()
    opendht_src += ['src/base64.cpp']
    add_project_arguments('-DOPENDHT_JSONCPP', language: 'cpp')
    conf_data.set('jsoncpp_lib', ', jsoncpp')
@@ -820,8 +820,13 @@ cdef class DhtRunner(_WithID):
                        key._infohash, (<PkId>to)._pkid, val._value,
                        cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent
                    )
+                elif isinstance(to, InfoHash):
+                    self.thisptr.get().putEncrypted(
+                        key._infohash, (<InfoHash>to)._infohash, val._value,
+                        cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent
+                    )
                else:
-                    raise TypeError("'to' must be PublicKey or PkId")
+                    raise TypeError("'to' must be PublicKey, PkId, or InfoHash")
            except:
                ref.Py_DECREF(cb_obj)
                raise
@@ -282,6 +282,7 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
        void get(InfoHash key, GetCallback get_cb, DoneCallback done_cb, nullptr_t f, Where w)
        void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, time_point created, bool permanent)
        void putSigned(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, bool permanent) 
+        void putEncrypted(InfoHash key, InfoHash to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
        void putEncrypted(InfoHash key, PkId to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
        void putEncrypted(InfoHash key, shared_ptr[PublicKey] to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
        void cancelPut(InfoHash key, shared_ptr[Value] val)
@@ -226,7 +226,7 @@ impl DhtRunner {
    pub fn put_encrypted<'a>(
        &mut self,
        h: &InfoHash,
-        to: &PkId,
+        to: &InfoHash,
        v: Box<Value>,
        done_cb: &'a mut (dyn FnMut(bool)),
        permanent: bool,
@@ -190,7 +190,7 @@ extern {
                                 cb_user_data: *mut c_void,
                                 permanent: bool);
    pub fn dht_runner_put_encrypted(dht: *mut DhtRunner, h: *const InfoHash,
-                                    to: *const PkId, v: *const Value,
+                                    to: *const InfoHash, v: *const Value,
                                    done_cb: extern fn(bool, *mut c_void),
                                    cb_user_data: *mut c_void,
                                    permanent: bool);
@@ -36,19 +36,4 @@ base64_decode(std::string_view str)
    return buffer;
 }

-std::vector<unsigned char>
-base64_default_or_url_decode(std::string_view str)
-{
-    std::vector<unsigned char> buffer(simdutf::maximal_binary_length_from_base64(str.data(), str.size()));
-    simdutf::result r = simdutf::base64_to_binary(str.data(),
-                                                  str.size(),
-                                                  (char*) buffer.data(),
-                                                  simdutf::base64_options::base64_default_or_url);
-    if (r.error) {
-        throw std::invalid_argument(concat("Invalid base64 input: "sv, simdutf::error_to_string(r.error)));
-    } else {
-        buffer.resize(r.count);
-    }
-    return buffer;
-}
 } // namespace dht
@@ -21,12 +21,5 @@ std::string base64_encode(const std::vector<unsigned char>& str);
 * @return a base64-decoded buffer
 */
 std::vector<unsigned char> base64_decode(std::string_view str);
-/**
- * Decode a buffer in base64 or url style base64 (including '-' '_' ).
- *
- * @param str the input buffer
- * @return a base64-decoded buffer
- */
-std::vector<unsigned char> base64_default_or_url_decode(std::string_view str);

-} // namespace dht
+} // namespace dht
@@ -11,7 +11,6 @@ extern "C" {
 #include <nettle/gcm.h>
 #include <nettle/aes.h>
 #include <nettle/hmac.h>
-#include <nettle/version.h>
 #include <gnutls/crypto.h>

 #include <argon2.h>
@@ -99,46 +98,6 @@ private:
 #define GCM_DIGEST_SIZE GCM_BLOCK_SIZE
 #endif

-static void
-gcmAes128Digest(gcm_aes128_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes128_digest(ctx, digest);
-#else
-    gcm_aes128_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-gcmAes192Digest(gcm_aes192_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes192_digest(ctx, digest);
-#else
-    gcm_aes192_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-gcmAes256Digest(gcm_aes256_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes256_digest(ctx, digest);
-#else
-    gcm_aes256_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-hmacSha256Digest(hmac_sha256_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    hmac_sha256_digest(ctx, digest);
-#else
-    hmac_sha256_digest(ctx, SHA256_DIGEST_SIZE, digest);
-#endif
-}
-
 Blob
 aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
 {
@@ -156,19 +115,19 @@ aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
        gcm_aes128_set_key(&aes, key.data());
        gcm_aes128_set_iv(&aes, GCM_IV_SIZE, ret.data());
        gcm_aes128_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes128Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
    } else if (key.size() == AES_LENGTHS[1]) {
        struct gcm_aes192_ctx aes;
        gcm_aes192_set_key(&aes, key.data());
        gcm_aes192_set_iv(&aes, GCM_IV_SIZE, ret.data());
        gcm_aes192_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes192Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
    } else if (key.size() == AES_LENGTHS[2]) {
        struct gcm_aes256_ctx aes;
        gcm_aes256_set_key(&aes, key.data());
        gcm_aes256_set_iv(&aes, GCM_IV_SIZE, ret.data());
        gcm_aes256_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes256Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
    }

    return ret;
@@ -201,19 +160,19 @@ aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key)
        gcm_aes128_set_key(&aes, key.data());
        gcm_aes128_set_iv(&aes, GCM_IV_SIZE, data);
        gcm_aes128_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes128Digest(&aes, digest.data());
+        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, digest.data());
    } else if (key.size() == AES_LENGTHS[1]) {
        struct gcm_aes192_ctx aes;
        gcm_aes192_set_key(&aes, key.data());
        gcm_aes192_set_iv(&aes, GCM_IV_SIZE, data);
        gcm_aes192_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes192Digest(&aes, digest.data());
+        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, digest.data());
    } else if (key.size() == AES_LENGTHS[2]) {
        struct gcm_aes256_ctx aes;
        gcm_aes256_set_key(&aes, key.data());
        gcm_aes256_set_iv(&aes, GCM_IV_SIZE, data);
        gcm_aes256_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes256Digest(&aes, digest.data());
+        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, digest.data());
    }

    if (not std::equal(digest.begin(), digest.end(), data + data_length - GCM_DIGEST_SIZE)) {
@@ -571,12 +530,6 @@ PublicKey::toString() const
    }
    if (err != GNUTLS_E_SUCCESS)
        throw CryptoException(std::string("Could not print public key: ") + gnutls_strerror(err));
-    // GnuTLS reports the PEM size including the terminating null byte, which
-    // does not belong to the text and would end up embedded in whatever the
-    // string is copied into, such as the "owner" field of a serialized value.
-    ret.resize(sz);
-    if (not ret.empty() and ret.back() == '\0')
-        ret.pop_back();
    return ret;
 }

@@ -1402,11 +1355,8 @@ setRandomSerial(gnutls_x509_crt_t cert)
 {
    std::random_device rdev;
    std::uniform_int_distribution<int64_t> dist {1};
-    const auto cert_serial = dist(rdev);
-    std::array<uint8_t, sizeof(cert_serial)> packed_serial;
-    for (size_t i = 0; i < packed_serial.size(); i++)
-        packed_serial[i] = cert_serial >> (8 * (packed_serial.size() - 1 - i));
-    gnutls_x509_crt_set_serial(cert, packed_serial.data(), packed_serial.size());
+    int64_t cert_serial = dist(rdev);
+    gnutls_x509_crt_set_serial(cert, &cert_serial, sizeof(cert_serial));
 }

 Certificate
@@ -1882,8 +1832,34 @@ RevocationList::getUpdateTime() const
    return std::chrono::system_clock::from_time_t(t);
 }

+enum class Endian : uint32_t { LITTLE = 0, BIG = 1 };
+
+template<typename T>
+T
+endian(T w, Endian endian = Endian::BIG)
+{
+    // this gets optimized out into if (endian == host_endian) return w;
+    union {
+        uint64_t quad;
+        uint32_t islittle;
+    } t;
+    t.quad = 1;
+    if (t.islittle ^ (uint32_t) endian)
+        return w;
+    T r = 0;
+
+    // decent compilers will unroll this (gcc)
+    // or even convert straight into single bswap (clang)
+    for (size_t i = 0; i < sizeof(r); i++) {
+        r <<= 8;
+        r |= w & 0xff;
+        w >>= 8;
+    }
+    return r;
+}
+
 void
-RevocationList::sign(const PrivateKey& key, const Certificate& ca, duration validity, uint64_t crlNumber)
+RevocationList::sign(const PrivateKey& key, const Certificate& ca, duration validity)
 {
    if (auto err = gnutls_x509_crl_set_version(crl, 2))
        throw CryptoException(std::string("Unable to set CRL version: ") + gnutls_strerror(err));
@@ -1893,28 +1869,19 @@ RevocationList::sign(const PrivateKey& key, const Certificate& ca, duration vali
        throw CryptoException(std::string("Unable to set CRL update time: ") + gnutls_strerror(err));
    if (auto err = gnutls_x509_crl_set_next_update(crl, std::chrono::system_clock::to_time_t(next_update)))
        throw CryptoException(std::string("Unable to set CRL next update time: ") + gnutls_strerror(err));
-    uint64_t number {crlNumber};
+    uint64_t number {0};
+    size_t number_sz {sizeof(number)};
+    unsigned critical {0};
+    gnutls_x509_crl_get_number(crl, &number, &number_sz, &critical);
    if (number == 0) {
-        // The CRL Number extension holds a DER integer of variable length, so it must be
-        // read as a big-endian byte string rather than straight into an uint64_t.
-        auto current = getNumber();
-        for (uint8_t byte : current)
-            number = (number << 8) | byte;
-        if (number == 0) {
-            // Initialize to a random number.
-            std::random_device rdev;
-            do {
-                std::generate_n((uint8_t*) &number, sizeof(number), std::bind(rand_byte, std::ref(rdev)));
-            } while (number == 0);
-        } else
-            number++;
-    }
-    // Store the number in network byte order.
-    uint8_t packedNumber[sizeof(number)];
-    for (size_t i = 0; i < sizeof(packedNumber); i++)
-        packedNumber[i] = (uint8_t) ((number >> (8 * (sizeof(packedNumber) - 1 - i))) & 0xff);
-    if (auto err = gnutls_x509_crl_set_number(crl, packedNumber, sizeof(packedNumber)))
-        throw CryptoException(std::string("Unable to set CRL number: ") + gnutls_strerror(err));
+        // initialize to a random number
+        number_sz = sizeof(number);
+        std::random_device rdev;
+        std::generate_n((uint8_t*) &number, sizeof(number), std::bind(rand_byte, std::ref(rdev)));
+    } else
+        number = endian(endian(number) + 1);
+    if (auto err = gnutls_x509_crl_set_number(crl, &number, sizeof(number)))
+        throw CryptoException(std::string("Unable to set CRL update time: ") + gnutls_strerror(err));
    if (auto err = gnutls_x509_crl_sign2(crl, ca.cert, key.x509_key, GNUTLS_DIG_SHA512, 0))
        throw CryptoException(std::string("Unable to sign certificate revocation list: ") + gnutls_strerror(err));
    // to be able to actually use the CRL we need to serialize/deserialize it
@@ -2078,7 +2045,7 @@ hkdf_extract(const Blob& salt, const Blob& ikm)
    hmac_sha256_set_key(&ctx, salt.size(), salt.data());
    hmac_sha256_update(&ctx, ikm.size(), ikm.data());
    Blob prk(SHA256_DIGEST_SIZE);
-    hmacSha256Digest(&ctx, prk.data());
+    hmac_sha256_digest(&ctx, SHA256_DIGEST_SIZE, prk.data());
    return prk;
 }

@@ -2096,7 +2063,7 @@ hkdf_expand(const Blob& prk, const uint8_t* info, size_t info_len, size_t len)
        hmac_sha256_update(&ctx, info_len, info);
        hmac_sha256_update(&ctx, 1, &i);
        T.resize(SHA256_DIGEST_SIZE);
-        hmacSha256Digest(&ctx, T.data());
+        hmac_sha256_digest(&ctx, SHA256_DIGEST_SIZE, T.data());
        okm.insert(okm.end(), T.begin(), T.end());
        i++;
    }
@@ -2256,7 +2223,7 @@ webPushEncrypt(const Blob& p256dh,

    Blob ciphertext(plaintext.size() + GCM_DIGEST_SIZE);
    gcm_aes128_encrypt(&aes, plaintext.size(), ciphertext.data(), plaintext.data());
-    gcmAes128Digest(&aes, ciphertext.data() + plaintext.size());
+    gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, ciphertext.data() + plaintext.size());

    // 6. Construct Output
    Blob output;
@@ -2270,16 +2270,8 @@ Dht::onDisconnected()
 void
 Dht::bootstrap()
 {
-    if (dht4.status != NodeStatus::Disconnected || dht6.status != NodeStatus::Disconnected) {
-        // The job that led here has already run, and the scheduler does not
-        // clear the handle to a job it has executed. onDisconnected() reads a
-        // set handle as "a bootstrap is already scheduled" and does nothing,
-        // so leaving it set here means the node never tries to rejoin the
-        // network once it has lost it. Clearing it is what says that no
-        // bootstrap is pending any more.
-        bootstrapJob.reset();
+    if (dht4.status != NodeStatus::Disconnected || dht6.status != NodeStatus::Disconnected)
        return;
-    }
    if (logger_)
        logger_->debug("[{}] Bootstraping", myid.to_view());
    bootstrap_pending = false;
@@ -2363,9 +2355,6 @@ Dht::confirmNodes()
 std::vector<ValuesExport>
 Dht::exportValues() const
 {
-    const auto& now = scheduler.time();
-    const auto system_now = system_clock::now();
-
    std::vector<ValuesExport> e {};
    e.reserve(store.size());
    for (const auto& h : store) {
@@ -2378,7 +2367,7 @@ Dht::exportValues() const
        pk.pack_array(vals.size());
        for (const auto& v : vals) {
            pk.pack_array(4);
-            pk.pack(to_system_time(v.created, now, system_now));
+            pk.pack(v.created.time_since_epoch().count());
            v.data->msgpack_pack(pk);
            if (const auto& store_addr = v.store_bucket ? v.store_bucket->getAddr() : SockAddr {}) {
                pk.pack_bin(store_addr.getLength());
@@ -2386,7 +2375,7 @@ Dht::exportValues() const
            } else {
                pk.pack_bin(0);
            }
-            pk.pack(to_system_time(v.expiration, now, system_now));
+            pk.pack(v.expiration.time_since_epoch().count());
        }
        ve.second = {buffer.data(), buffer.data() + buffer.size()};
        e.push_back(std::move(ve));
@@ -2398,7 +2387,6 @@ void
 Dht::importValues(const std::vector<ValuesExport>& import)
 {
    const auto& now = scheduler.time();
-    const auto system_now = system_clock::now();

    unsigned imported = 0, ignored = 0;
    size_t imported_size = 0;
@@ -2423,15 +2411,8 @@ Dht::importValues(const std::vector<ValuesExport>& import)
                Value tmp_val;
                SockAddr store_addr;
                try {
-                    const bool uses_system_time = valel.via.array.ptr[0].type == msgpack::type::EXT;
-                    if (uses_system_time) {
-                        val_time = from_system_time(valel.via.array.ptr[0].as<system_clock::time_point>(),
-                                                    now,
-                                                    system_now);
-                    } else {
-                        val_time = time_point {
-                            time_point::duration {valel.via.array.ptr[0].as<time_point::duration::rep>()}};
-                    }
+                    val_time = time_point {
+                        time_point::duration {valel.via.array.ptr[0].as<time_point::duration::rep>()}};
                    tmp_val.msgpack_unpack(valel.via.array.ptr[1]);
                    if (valel.via.array.size >= 3) {
                        auto addr_blob = valel.via.array.ptr[2].as<Blob>();
@@ -2441,14 +2422,8 @@ Dht::importValues(const std::vector<ValuesExport>& import)
                        }
                    }
                    if (valel.via.array.size >= 4) {
-                        if (uses_system_time) {
-                            expiration = from_system_time(valel.via.array.ptr[3].as<system_clock::time_point>(),
-                                                          now,
-                                                          system_now);
-                        } else {
-                            expiration = time_point {
-                                time_point::duration {valel.via.array.ptr[3].as<time_point::duration::rep>()}};
-                        }
+                        expiration = time_point {
+                            time_point::duration {valel.via.array.ptr[3].as<time_point::duration::rep>()}};
                    }
                } catch (const std::exception&) {
                    if (logger_)
@@ -782,7 +782,10 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
    if (newStatus == NodeStatus::Connected) {
        if (oldStatus == NodeStatus::Disconnected || oldStatus == NodeStatus::Connecting || launchConnectedCbs_) {
            launchConnectedCbs_ = false;
-            listenerRestartTimer_->expires_at(std::chrono::steady_clock::now());
+            // Small random delay (0-2s) to avoid resubscription burst
+            auto jitter = std::chrono::milliseconds(
+                std::rand() % 2000);
+            listenerRestartTimer_->expires_at(std::chrono::steady_clock::now() + jitter);
            listenerRestartTimer_->async_wait(std::bind(&DhtProxyClient::restartListeners, this, std::placeholders::_1));
            if (not onConnectCallbacks_.empty()) {
                std::lock_guard lock(lockCallbacks_);
@@ -794,11 +797,18 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
                });
            }
        }
+        // Reset backoff on successful connection
+        proxyRetryDelay_ = std::chrono::minutes(1);
        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + std::chrono::minutes(15));
        nextProxyConfirmationTimer_->async_wait(
            std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
    } else if (newStatus == NodeStatus::Disconnected) {
-        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + std::chrono::minutes(1));
+        // Exponential backoff: 1 → 2 → 4 → 8 → 16 → 30 min (capped)
+        auto delay = proxyRetryDelay_;
+        proxyRetryDelay_ = std::min(proxyRetryDelay_ * 2, MAX_PROXY_RETRY_DELAY);
+        if (logger_)
+            logger_->warn("[proxy:client] disconnected, retrying in {} min", delay.count());
+        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + delay);
        nextProxyConfirmationTimer_->async_wait(
            std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
    }
@@ -1166,6 +1176,8 @@ DhtProxyClient::getConnectivityStatus()
 {
    if (logger_)
        logger_->d("[proxy:client] [connectivity] get status");
+    // Reset backoff on explicit connectivity change (e.g., WiFi/cellular switch)
+    proxyRetryDelay_ = std::chrono::minutes(1);
    if (!isDestroying_)
        getProxyInfos();
 }
@@ -594,8 +594,10 @@ DhtProxyServer::addServerSettings(ServerSettings& settings, const unsigned int m
    settings.logger(logger_);
    settings.protocol(restinio::asio_ns::ip::tcp::v6());
    settings.request_handler(createRestRouter());
-    // time limits                                              // ~ 0.8 month
-    std::chrono::milliseconds timeout_request(std::numeric_limits<int>::max());
+    // time limits
+    // Use 1-hour timeout for idle connections so that dead mobile clients
+    // are cleaned up promptly instead of lingering for ~24 days.
+    constexpr auto timeout_request = std::chrono::hours(1);
    settings.read_next_http_message_timelimit(timeout_request);
    settings.write_http_response_timelimit(60s);
    settings.handle_request_timeout(timeout_request);
@@ -1189,7 +1191,13 @@ DhtProxyServer::handlePushListen(const InfoHash& infoHash,
                       minPriority,
                       values.size());

-    sendPushNotification(pushToken, std::move(json), type, !expired and minPriority == 0, topic);
+    // Include priority in the JSON payload so that UnifiedPush clients
+    // (which don't have access to the HTTP Urgency header) can determine
+    // whether a push requires immediate processing or can be deferred.
+    bool highPriority = !expired and minPriority == 0;
+    json["priority"] = highPriority ? "high" : "normal";
+
+    sendPushNotification(pushToken, std::move(json), type, highPriority, topic);

    return true;
 }
@@ -1205,7 +1213,14 @@ DhtProxyServer::sendPushNotification(
    try {
        std::shared_ptr<http::Request> request;
        if (type == PushType::UnifiedPush) {
-            request = std::make_shared<http::Request>(io_context(), token, logger_);
+            http::Url tokenUrl(token);
+            request = std::make_shared<http::Request>(io_context(),
+                                                      concat(tokenUrl.protocol, "://"sv, tokenUrl.host),
+                                                      tokenUrl.service,
+                                                      tokenUrl.protocol.find("https") == 0,
+                                                      logger_);
+            request->set_target(tokenUrl.target);
+            request->set_header_field(restinio::http_field_t::host, std::string(tokenUrl.host));
        } else {
            request = std::make_shared<http::Request>(io_context(),
                                                      pushHostPort_.first,
@@ -1224,8 +1239,8 @@ DhtProxyServer::sendPushNotification(
            Blob auth;   ///< Auth secret
            auto delim = topicView.find('|');
            if (delim != std::string_view::npos) {
-                pubKey = base64_default_or_url_decode(topicView.substr(0, delim));
-                auth = base64_default_or_url_decode(topicView.substr(delim + 1));
+                pubKey = base64_decode(topicView.substr(0, delim));
+                auth = base64_decode(topicView.substr(delim + 1));
            }

            request->set_header_field(restinio::http_field_t::ttl, "86400");
@@ -99,11 +99,6 @@ DhtRunner::run(const Config& config, Context&& context)
        auto state_path = config.dht_config.node_config.persist_path;
        if (not state_path.empty())
            state_path += "_port.txt";
-        // Ports loaded from the persisted state are a best-effort hint to keep a
-        // stable identity across restarts; remember which ones we set so that we
-        // can fall back to random ports if they are already in use (e.g. a fast
-        // restart while the previous instance still holds them).
-        bool triedSavedPort = false;
        if (not state_path.empty() && (local4.getPort() == 0 || local6.getPort() == 0)) {
            std::ifstream inConfig(state_path);
            if (inConfig.is_open()) {
@@ -115,7 +110,6 @@ DhtRunner::run(const Config& config, Context&& context)
                                              fmt::ptr(this),
                                              port);
                        local4.setPort(port);
-                        triedSavedPort = true;
                    }
                }
                if (inConfig >> port) {
@@ -125,7 +119,6 @@ DhtRunner::run(const Config& config, Context&& context)
                                              fmt::ptr(this),
                                              port);
                        local6.setPort(port);
-                        triedSavedPort = true;
                    }
                }
            }
@@ -143,20 +136,7 @@ DhtRunner::run(const Config& config, Context&& context)

        if (config.proxy_server.empty()) {
            if (not context.sock) {
-                try {
-                    context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
-                } catch (const DhtException&) {
-                    if (not triedSavedPort)
-                        throw;
-                    // The saved ports are unavailable (typically still held by a
-                    // previous instance): fall back to OS-assigned ports.
-                    if (context.logger)
-                        context.logger->w("[runner %p] Saved ports unavailable, falling back to random ports",
-                                          fmt::ptr(this));
-                    local4.setPort(0);
-                    local6.setPort(0);
-                    context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
-                }
+                context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
            }
            context.sock->setOnReceive([&](net::PacketList&& pkts) {
                net::PacketList ret;
@@ -206,6 +186,9 @@ DhtRunner::run(const Config& config, Context&& context)
    if (context.certificateStore) {
        dht_->setLocalCertificateStore(std::move(context.certificateStore));
    }
+    if (context.certificateStorePkId) {
+        dht_->setLocalCertificateStore(std::move(context.certificateStorePkId));
+    }
    if (context.publicAddressChangedCb) {
        dht_->setOnPublicAddressChanged(std::move(context.publicAddressChangedCb));
    }
@@ -684,6 +667,14 @@ DhtRunner::registerCertificate(const std::shared_ptr<crypto::Certificate>& cert)
    dht_->registerCertificate(cert);
 }

+void
+DhtRunner::setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method)
+{
+    std::lock_guard lck(dht_mtx);
+    if (dht_)
+        dht_->setLocalCertificateStore(std::forward<CertificateStoreQueryLegacy>(query_method));
+}
+
 void
 DhtRunner::setLocalCertificateStore(CertificateStoreQuery&& query_method)
 {
@@ -964,6 +955,35 @@ DhtRunner::putEncrypted(InfoHash hash, const PkId& to, std::shared_ptr<Value> va
    cv.notify_all();
 }

+void
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
+{
+    std::unique_lock lck(storage_mtx);
+    if (running != State::Running) {
+        lck.unlock();
+        if (cb)
+            cb(false, {});
+        return;
+    }
+    ongoing_ops++;
+    pending_ops.emplace([=, cb = std::move(cb), value = std::move(value)](SecureDht& dht) mutable {
+        dht.putEncrypted(hash, to, value, bindOpDoneCallback(std::move(cb)), permanent);
+    });
+    cv.notify_all();
+}
+
+void
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb, bool permanent)
+{
+    putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
+}
+
+void
+DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb, bool permanent)
+{
+    putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), std::move(cb), permanent);
+}
+
 void
 DhtRunner::putEncrypted(InfoHash hash,
                        const std::shared_ptr<crypto::PublicKey>& to,
@@ -1099,6 +1119,25 @@ DhtRunner::connectivityChanged()
    cv.notify_all();
 }

+void
+DhtRunner::findCertificate(InfoHash hash, std::function<void(const Sp<crypto::Certificate>&)> cb)
+{
+    std::unique_lock lck(storage_mtx);
+    if (running != State::Running) {
+        lck.unlock();
+        cb({});
+        return;
+    }
+    ongoing_ops++;
+    pending_ops.emplace([this, hash, cb = std::move(cb)](SecureDht& dht) {
+        dht.findCertificate(hash, [this, cb = std::move(cb)](const Sp<crypto::Certificate>& crt) {
+            cb(crt);
+            opEnded();
+        });
+    });
+    cv.notify_all();
+}
+
 void
 DhtRunner::findCertificate(PkId hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)> cb)
 {
@@ -42,8 +42,8 @@ constexpr std::string_view ORIGIN_PROTOCOL {"//"sv};
 constexpr const char HTTP_HEADER_DELIM[] = "\r\n\r\n";
 constexpr unsigned MAX_REDIRECTS {5};

-Url::Url(std::string url_str)
-    : url(std::move(url_str))
+Url::Url(std::string_view url_str)
+    : url(url_str)
 {
    std::string_view u = url;
    if (u.empty())
@@ -302,7 +302,7 @@ static X509*
 issuer_from_chain(STACK_OF(X509) * fullchain)
 {
    X509 *cert, *issuer;
-    const X509_NAME* issuer_name;
+    X509_NAME* issuer_name;

    cert = cert_from_chain(fullchain);
    if ((issuer_name = X509_get_issuer_name(cert)) == nullptr)
@@ -830,8 +830,8 @@ Connection::timeout(const std::chrono::seconds& timeout, HandlerCb cb)

 // Resolver

-Resolver::Resolver(asio::io_context& ctx, std::string url, std::shared_ptr<dht::Logger> logger)
-    : url_(std::move(url))
+Resolver::Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger)
+    : url_(url)
    , resolver_(ctx)
    , destroyed_(std::make_shared<bool>(false))
    , logger_(logger)
@@ -917,16 +917,8 @@ Resolver::add_callback(ResolverCb cb, sa_family_t family)
                                               else
                                                   cb(ec, filter(endpoints, family));
                                           });
-    else {
-        // Always dispatch the callback on the io_context thread. Invoking it
-        // synchronously would run the caller's continuation (e.g. the whole
-        // connect chain of Request::send) on the calling thread, mutating asio
-        // objects concurrently with the io thread running the io_context.
-        asio::post(resolver_.get_executor(),
-                   [cb = std::move(cb),
-                    ec = ec_,
-                    endpoints = family == AF_UNSPEC ? endpoints_ : filter(endpoints_, family)] { cb(ec, endpoints); });
-    }
+    else
+        cb(ec_, family == AF_UNSPEC ? endpoints_ : filter(endpoints_, family));
 }

 void
@@ -975,14 +967,14 @@ Resolver::resolve(std::string_view host, std::string_view service)
 std::atomic_uint Request::ids_ {1};

 Request::Request(asio::io_context& ctx,
-                 std::string url,
+                 const std::string& url,
                 const Json::Value& json,
                 OnJsonCb jsoncb,
                 std::shared_ptr<dht::Logger> logger)
    : logger_(std::move(logger))
    , id_(Request::ids_++)
    , ctx_(ctx)
-    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
+    , resolver_(std::make_shared<Resolver>(ctx, url, logger))
 {
    init_default_headers();
    set_header_field(restinio::http_field_t::content_type, std::string(HTTP_HEADER_CONTENT_TYPE_JSON));
@@ -1005,11 +997,11 @@ Request::Request(asio::io_context& ctx,
    });
 }

-Request::Request(asio::io_context& ctx, std::string url, OnJsonCb jsoncb, std::shared_ptr<dht::Logger> logger)
+Request::Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb, std::shared_ptr<dht::Logger> logger)
    : logger_(std::move(logger))
    , id_(Request::ids_++)
    , ctx_(ctx)
-    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
+    , resolver_(std::make_shared<Resolver>(ctx, url, logger))
 {
    init_default_headers();
    set_header_field(restinio::http_field_t::accept, std::string(HTTP_HEADER_CONTENT_TYPE_JSON));
@@ -1030,20 +1022,20 @@ Request::Request(asio::io_context& ctx, std::string url, OnJsonCb jsoncb, std::s
    });
 }

-Request::Request(asio::io_context& ctx, std::string url, std::shared_ptr<dht::Logger> logger)
+Request::Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger)
    : logger_(logger)
    , id_(Request::ids_++)
    , ctx_(ctx)
-    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
+    , resolver_(std::make_shared<Resolver>(ctx, url, logger))
 {
    init_default_headers();
 }

-Request::Request(asio::io_context& ctx, std::string url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger)
+Request::Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger)
    : logger_(logger)
    , id_(Request::ids_++)
    , ctx_(ctx)
-    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
+    , resolver_(std::make_shared<Resolver>(ctx, url, logger))
 {
    init_default_headers();
    add_on_done_callback(std::move(onDone));
@@ -1094,6 +1086,7 @@ Request::Request(asio::io_context& ctx,
    , family_(family)
    , resolver_(resolver)
 {
+    set_header_field(restinio::http_field_t::host, concat(get_url().host, ":", get_url().service));
    set_target(Url(target).target);
 }

@@ -224,7 +224,7 @@ SearchCache::expire(const time_point& now, const std::function<void(size_t)>& on
    auto ret = nextExpiration_;
    for (auto it = ops.begin(); it != ops.end();) {
        auto expiration = it->second->getExpiration();
-        if (expiration <= now) {
+        if (expiration < now) {
            auto cache = std::move(it->second);
            it = ops.erase(it);
            onCancel(cache->searchToken);
@@ -96,13 +96,37 @@ SecureDht::secureType(ValueType&& type)
    return type;
 }

+Sp<crypto::Certificate>
+SecureDht::getCertificate(const InfoHash& node) const
+{
+    if (node == getId())
+        return certificate_;
+    auto it = nodesCertificates_.find(node);
+    if (it == nodesCertificates_.end())
+        return nullptr;
+    else
+        return it->second;
+}
+
+Sp<crypto::PublicKey>
+SecureDht::getPublicKey(const InfoHash& node) const
+{
+    if (node == getId())
+        return certificate_->getSharedPublicKey();
+    auto it = nodesPubKeys_.find(node);
+    if (it == nodesPubKeys_.end())
+        return nullptr;
+    else
+        return it->second;
+}
+
 Sp<crypto::Certificate>
 SecureDht::getCertificate(const PkId& node) const
 {
    if (node == getLongId())
        return certificate_;
-    auto it = nodesCertificates_.find(node);
-    if (it == nodesCertificates_.end())
+    auto it = nodesCertificatesLong_.find(node);
+    if (it == nodesCertificatesLong_.end())
        return nullptr;
    else
        return it->second;
@@ -113,8 +137,8 @@ SecureDht::getPublicKey(const PkId& node) const
 {
    if (node == getLongId())
        return certificate_->getSharedPublicKey();
-    auto it = nodesPubKeys_.find(node);
-    if (it == nodesPubKeys_.end())
+    auto it = nodesPubKeysLong_.find(node);
+    if (it == nodesPubKeysLong_.end())
        return nullptr;
    else
        return it->second;
@@ -167,10 +191,85 @@ void
 SecureDht::registerCertificate(const Sp<crypto::Certificate>& cert)
 {
    if (cert) {
-        nodesCertificates_[cert->getLongId()] = cert;
+        nodesCertificates_[cert->getId()] = cert;
+        nodesCertificatesLong_[cert->getLongId()] = cert;
    }
 }

+void
+SecureDht::findCertificate(const InfoHash& node, const std::function<void(const Sp<crypto::Certificate>)>& cb)
+{
+    Sp<crypto::Certificate> b = getCertificate(node);
+    if (b && *b) {
+        if (logger_)
+            logger_->debug("Using certificate from cache for {}", node.toString());
+        if (cb)
+            cb(b);
+        return;
+    }
+    if (localQueryMethodLegacy_) {
+        auto res = localQueryMethodLegacy_(node);
+        if (not res.empty()) {
+            if (logger_)
+                logger_->debug("Registering certificate from local store for {}", node.toString());
+            nodesCertificates_.emplace(node, res.front());
+            nodesCertificatesLong_.emplace(res.front()->getLongId(), res.front());
+            if (cb)
+                cb(res.front());
+            return;
+        }
+    }
+
+    auto found = std::make_shared<bool>(false);
+    dht_->get(
+        node,
+        [cb, node, found, this](const std::vector<Sp<Value>>& vals) {
+            for (const auto& v : vals) {
+                if (auto cert = registerCertificate(node, v->data)) {
+                    *found = true;
+                    if (logger_)
+                        logger_->debug("Found certificate for {}", node.toString());
+                    if (cb)
+                        cb(cert);
+                    return false;
+                }
+            }
+            return !*found;
+        },
+        [cb, found](bool) {
+            if (!*found and cb)
+                cb(nullptr);
+        },
+        Value::TypeFilter(CERTIFICATE_TYPE));
+}
+
+void
+SecureDht::findPublicKey(const InfoHash& node, const std::function<void(const Sp<crypto::PublicKey>)>& cb)
+{
+    auto pk = getPublicKey(node);
+    if (pk && *pk) {
+        if (logger_)
+            logger_->debug("Found public key from cache for {}", node.toString());
+        if (cb)
+            cb(pk);
+        return;
+    }
+    findCertificate(node, [=](const Sp<crypto::Certificate>& crt) {
+        if (crt && *crt) {
+            auto pk = crt->getSharedPublicKey();
+            if (*pk) {
+                nodesPubKeys_[pk->getId()] = pk;
+                nodesPubKeysLong_[pk->getLongId()] = pk;
+                if (cb)
+                    cb(pk);
+                return;
+            }
+        }
+        if (cb)
+            cb(nullptr);
+    });
+}
+
 void
 SecureDht::findCertificate(const PkId& node, const std::function<void(const Sp<crypto::Certificate>)>& cb)
 {
@@ -188,7 +287,8 @@ SecureDht::findCertificate(const PkId& node, const std::function<void(const Sp<c
        if (not res.empty()) {
            if (logger_)
                logger_->debug("Registering certificate from local store for {}", node.to_c_str());
-            nodesCertificates_.emplace(node, res.front());
+            nodesCertificates_.emplace(res.front()->getId(), res.front());
+            nodesCertificatesLong_.emplace(node, res.front());
            if (cb)
                cb(res.front());
            return;
@@ -233,7 +333,8 @@ SecureDht::findPublicKey(const PkId& node, const std::function<void(const Sp<cry
        if (crt && *crt) {
            auto pk = crt->getSharedPublicKey();
            if (*pk) {
-                nodesPubKeys_[pk->getLongId()] = pk;
+                nodesPubKeys_[pk->getId()] = pk;
+                nodesPubKeysLong_[pk->getLongId()] = pk;
                if (cb)
                    cb(pk);
                return;
@@ -261,7 +362,8 @@ SecureDht::checkValue(const Sp<Value>& v)
            if (auto decrypted_val = v->decrypt(*key_)) {
                auto cacheValue = not isDecrypted and decrypted_val->owner;
                if (cacheValue) {
-                    nodesPubKeys_[decrypted_val->owner->getLongId()] = decrypted_val->owner;
+                    nodesPubKeys_[decrypted_val->owner->getId()] = decrypted_val->owner;
+                    nodesPubKeysLong_[decrypted_val->owner->getLongId()] = decrypted_val->owner;
                }
                return decrypted_val;
            }
@@ -275,7 +377,8 @@ SecureDht::checkValue(const Sp<Value>& v)
        auto cacheValue = not v->isSignatureChecked() and enableCache_ and v->owner;
        if (v->checkSignature()) {
            if (cacheValue) {
-                nodesPubKeys_[v->owner->getLongId()] = v->owner;
+                nodesPubKeys_[v->owner->getId()] = v->owner;
+                nodesPubKeysLong_[v->owner->getLongId()] = v->owner;
            }
            return v;
        } else if (logger_)
@@ -389,6 +492,35 @@ SecureDht::putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback,
        Where().id(val->id));
 }

+void
+SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent)
+{
+    if (not key_) {
+        if (callback)
+            callback(false, {});
+        return;
+    }
+    findPublicKey(to,
+                  [this, hash, val = std::move(val), callback = std::move(callback), permanent](
+                      const Sp<crypto::PublicKey>& pk) {
+                      if (!pk || !*pk) {
+                          if (callback)
+                              callback(false, {});
+                          return;
+                      }
+                      if (logger_)
+                          logger_->warn("Encrypting data for PK: {}", pk->getId().toString());
+                      try {
+                          dht_->put(hash, encrypt(*val, *pk), callback, time_point::max(), permanent);
+                      } catch (const std::exception& e) {
+                          if (logger_)
+                              logger_->error("Error putting encrypted data: {}", e.what());
+                          if (callback)
+                              callback(false, {});
+                      }
+                  });
+}
+
 void
 SecureDht::putEncrypted(const InfoHash& hash, const PkId& to, Sp<Value> val, DoneCallback callback, bool permanent)
 {
@@ -6,10 +6,8 @@
 #include <atomic>
 #include <thread>
 #include <iostream>
-#include <cmath> // std::pow
-#if __cplusplus < 202002L
-#include <ciso646>
-#endif
+#include <ciso646> // fix windows compiler bug
+#include <cmath>   // std::pow

 namespace dht {

@@ -80,8 +78,6 @@ ThreadPool::run(std::function<void()>&& cb)
                            break;
                        task = std::move(tasks_.front());
                        tasks_.pop();
-                        if (tasks_.empty() && stopping_)
-                            stopCv_.notify_one();
                    }

                    // run task
@@ -139,9 +135,7 @@ ThreadPool::stop(bool wait)
 {
    std::unique_lock l(lock_);
    if (wait) {
-        stopping_ = true;
-        stopCv_.wait(l, [&]() { return tasks_.empty(); });
-        stopping_ = false;
+        cv_.wait(l, [&]() { return tasks_.empty(); });
    }
    running_ = false;
    tasks_ = {};
@@ -238,58 +238,28 @@ operator==(const SockAddr& a, const SockAddr& b)
    return a.equals(b);
 }

-time_point
-from_system_time(system_clock::time_point t, time_point steady_now, system_clock::time_point system_now)
-{
-    if (t == system_clock::time_point::min())
-        return time_point::min();
-    if (t == system_clock::time_point::max())
-        return time_point::max();
-    auto dt = t - system_now;
-    if (dt > system_clock::duration(0) and steady_now > time_point::max() - dt)
-        return time_point::max();
-    else if (dt < system_clock::duration(0) and steady_now < time_point::min() - dt)
-        return time_point::min();
-    return steady_now + dt;
-}
-
-time_point
-from_system_time(system_clock::time_point t)
-{
-    return from_system_time(t, clock::now(), system_clock::now());
-}
-
-system_clock::time_point
-to_system_time(time_point t, time_point steady_now, system_clock::time_point system_now)
-{
-    if (t == time_point::min())
-        return system_clock::time_point::min();
-    if (t == time_point::max())
-        return system_clock::time_point::max();
-    auto dt = t - steady_now;
-    if (dt > duration(0) and system_now >= system_clock::time_point::max() - dt)
-        return system_clock::time_point::max();
-    else if (dt < duration(0) and system_now <= system_clock::time_point::min() - dt)
-        return system_clock::time_point::min();
-    return system_now + std::chrono::duration_cast<system_clock::duration>(dt);
-}
-
-system_clock::time_point
-to_system_time(time_point t)
-{
-    return to_system_time(t, clock::now(), system_clock::now());
-}
-
 time_point
 from_time_t(std::time_t t)
 {
-    return from_system_time(system_clock::from_time_t(t));
+    auto dt = system_clock::from_time_t(t) - system_clock::now();
+    auto now = clock::now();
+    if (dt > system_clock::duration(0) and now > time_point::max() - dt)
+        return time_point::max();
+    else if (dt < system_clock::duration(0) and now < time_point::min() - dt)
+        return time_point::min();
+    return now + dt;
 }

 std::time_t
 to_time_t(time_point t)
 {
-    return system_clock::to_time_t(to_system_time(t));
+    auto dt = t - clock::now();
+    auto now = system_clock::now();
+    if (dt > duration(0) and now >= system_clock::time_point::max() - dt)
+        return system_clock::to_time_t(system_clock::time_point::max());
+    else if (dt < duration(0) and now <= system_clock::time_point::min() - dt)
+        return system_clock::to_time_t(system_clock::time_point::min());
+    return system_clock::to_time_t(now + std::chrono::duration_cast<system_clock::duration>(dt));
 }

 Blob
@@ -202,9 +202,6 @@ Value::Value(const Json::Value& json)
    const auto& jprio = json["prio"];
    if (jprio.isIntegral())
        priority = jprio.asUInt();
-    const auto& jpt = json[VALUE_KEY_PUSHTYPE];
-    if (jpt.isString())
-        pushType = jpt.asString();
 }

 Json::Value
@@ -231,8 +228,6 @@ Value::toJson() const
    }
    if (priority)
        val["prio"] = priority;
-    if (not pushType.empty())
-        val[VALUE_KEY_PUSHTYPE] = pushType;
    return val;
 }

@@ -59,24 +59,6 @@ CryptoTester::testSignatureEncryption()
    }
 }

-void
-CryptoTester::testPublicKeyPemIsPlainText()
-{
-    auto key = dht::crypto::PrivateKey::generate();
-    auto pem = key.getPublicKey().toString();
-
-    // The exported key is PEM text: it must not carry the terminating null
-    // byte GnuTLS counts in the exported size, which would otherwise be
-    // embedded in anything the string is serialized into.
-    CPPUNIT_ASSERT(not pem.empty());
-    CPPUNIT_ASSERT_EQUAL(std::string::npos, pem.find('\0'));
-    CPPUNIT_ASSERT_EQUAL('\n', pem.back());
-
-    // The exported text still reads back as the same key.
-    dht::crypto::PublicKey reloaded(dht::Blob(pem.begin(), pem.end()));
-    CPPUNIT_ASSERT_EQUAL(key.getPublicKey().getId(), reloaded.getId());
-}
-
 void
 CryptoTester::testCertificateRevocation()
 {
@@ -113,159 +95,10 @@ CryptoTester::testCertificateRevocation()
    CPPUNIT_ASSERT_MESSAGE(v.toString(), v);
 }

-namespace {
-
-/** Read a CRL Number extension blob (big-endian, variable length) as an integer. */
-uint64_t
-crlNumberValue(const dht::Blob& number)
-{
-    uint64_t value {0};
-    for (uint8_t byte : number)
-        value = (value << 8) | byte;
-    return value;
-}
-
-} // namespace
-
-void
-CryptoTester::testRevocationListNumber()
-{
-    auto ca = dht::crypto::generateIdentity("ca");
-    auto device = dht::crypto::generateIdentity("dev", ca);
-
-    dht::crypto::RevocationList crl;
-    CPPUNIT_ASSERT_EQUAL(uint64_t(0), crlNumberValue(crl.getNumber()));
-
-    crl.revoke(*device.second);
-    crl.sign(ca);
-    auto first = crl.getNumber();
-    // An unnumbered list gets a random number on its first signature.
-    CPPUNIT_ASSERT(not first.empty());
-    CPPUNIT_ASSERT(crlNumberValue(first) != 0);
-
-    // Re-signing keeps the same lineage and moves the number forward.
-    crl.sign(ca);
-    auto second = crl.getNumber();
-    CPPUNIT_ASSERT_EQUAL(crlNumberValue(first) + 1, crlNumberValue(second));
-
-    crl.sign(ca);
-    CPPUNIT_ASSERT_EQUAL(crlNumberValue(first) + 2, crlNumberValue(crl.getNumber()));
-
-    // The number is a DER integer, so it is stored with leading zeros stripped.
-    // Incrementing must still work for numbers shorter than 8 bytes.
-    for (uint64_t start : {uint64_t(1), uint64_t(0x7f), uint64_t(0x80), uint64_t(0xffff)}) {
-        dht::crypto::RevocationList small;
-        small.revoke(*device.second);
-        small.sign(ca, {}, start);
-        CPPUNIT_ASSERT_EQUAL(start, crlNumberValue(small.getNumber()));
-        small.sign(ca);
-        CPPUNIT_ASSERT_EQUAL(start + 1, crlNumberValue(small.getNumber()));
-        small.sign(ca);
-        CPPUNIT_ASSERT_EQUAL(start + 2, crlNumberValue(small.getNumber()));
-    }
-}
-
-void
-CryptoTester::testRevocationListExplicitNumber()
-{
-    auto ca = dht::crypto::generateIdentity("ca");
-    auto device = dht::crypto::generateIdentity("dev", ca);
-
-    // Values chosen to cover leading zero bytes, a full-width number and the largest
-    // value that still encodes as a positive 8-byte DER integer.
-    const std::vector<uint64_t> numbers {1,
-                                         42,
-                                         0xff,
-                                         0x100,
-                                         0x0000'0001'0000'0000ull,
-                                         0x0000'02a1'0000'0001ull,
-                                         0x7fff'ffff'ffff'ffffull};
-    for (auto number : numbers) {
-        dht::crypto::RevocationList crl;
-        crl.revoke(*device.second);
-        crl.sign(ca, {}, number);
-        CPPUNIT_ASSERT_EQUAL(number, crlNumberValue(crl.getNumber()));
-        CPPUNIT_ASSERT(crl.isSignedBy(*ca.second));
-        CPPUNIT_ASSERT(crl.isRevoked(*device.second));
-
-        // The number must survive a pack/unpack round-trip.
-        dht::crypto::RevocationList unpacked(crl.getPacked());
-        CPPUNIT_ASSERT_EQUAL(number, crlNumberValue(unpacked.getNumber()));
-    }
-
-    // An explicit number overrides the increment, in both directions.
-    dht::crypto::RevocationList crl;
-    crl.revoke(*device.second);
-    crl.sign(ca, {}, 1000);
-    CPPUNIT_ASSERT_EQUAL(uint64_t(1000), crlNumberValue(crl.getNumber()));
-    crl.sign(ca, {}, 5);
-    CPPUNIT_ASSERT_EQUAL(uint64_t(5), crlNumberValue(crl.getNumber()));
-
-    // Passing 0 falls back to the default behavior: increment the current number.
-    crl.sign(ca, {}, 0);
-    CPPUNIT_ASSERT_EQUAL(uint64_t(6), crlNumberValue(crl.getNumber()));
-}
-
-void
-CryptoTester::testRevocationListPartitionedNumber()
-{
-    // Two devices holding the same authority issue revocation lists independently.
-    // RFC 5280 5.2.3 requires CRL numbers to increase monotonically for a given CRL
-    // scope and issuer; partitioning the low bits by device keeps each sequence
-    // monotonic while making collisions between devices impossible.
-    constexpr unsigned TAG_BITS = 24;
-    constexpr uint64_t TAG_A = 0x0a0b0c;
-    constexpr uint64_t TAG_B = 0x0a0b0d;
-
-    auto ca = dht::crypto::generateIdentity("ca");
-    auto account = dht::crypto::generateIdentity("acc", ca, 4096, true);
-    auto deviceA = dht::crypto::generateIdentity("devA", account);
-    auto deviceB = dht::crypto::generateIdentity("devB", account);
-
-    uint64_t previous {0};
-    dht::crypto::RevocationList crlA;
-    for (unsigned i = 1; i <= 4; i++) {
-        crlA.revoke(*deviceA.second);
-        crlA.sign(account, {}, (uint64_t(i) << TAG_BITS) | TAG_A);
-        auto number = crlNumberValue(crlA.getNumber());
-        CPPUNIT_ASSERT_EQUAL(TAG_A, number & ((uint64_t(1) << TAG_BITS) - 1));
-        CPPUNIT_ASSERT(number > previous);
-        CPPUNIT_ASSERT_EQUAL(uint64_t(0), number >> 63);
-        previous = number;
-    }
-
-    // Both devices branch from the same counter but never mint the same number.
-    dht::crypto::RevocationList branchA;
-    branchA.revoke(*deviceA.second);
-    branchA.sign(account, {}, (uint64_t(9) << TAG_BITS) | TAG_A);
-    dht::crypto::RevocationList branchB;
-    branchB.revoke(*deviceB.second);
-    branchB.sign(account, {}, (uint64_t(9) << TAG_BITS) | TAG_B);
-    CPPUNIT_ASSERT(crlNumberValue(branchA.getNumber()) != crlNumberValue(branchB.getNumber()));
-
-    // Both are valid and revoke only their own target.
-    CPPUNIT_ASSERT(branchA.isSignedBy(*account.second));
-    CPPUNIT_ASSERT(branchB.isSignedBy(*account.second));
-    CPPUNIT_ASSERT(branchA.isRevoked(*deviceA.second));
-    CPPUNIT_ASSERT(not branchA.isRevoked(*deviceB.second));
-    CPPUNIT_ASSERT(branchB.isRevoked(*deviceB.second));
-    CPPUNIT_ASSERT(not branchB.isRevoked(*deviceA.second));
-
-    // A number minted by an older client is fully random, so bit 63 may be set. Masking
-    // it out and taking the counter part still yields a strictly greater number.
-    constexpr uint64_t legacy = 0xdead'beef'0123'4567ull;
-    dht::crypto::RevocationList legacyCrl;
-    legacyCrl.revoke(*deviceA.second);
-    legacyCrl.sign(account, {}, legacy);
-    auto counter = ((crlNumberValue(legacyCrl.getNumber()) & ~(uint64_t(1) << 63)) >> TAG_BITS) + 1;
-    legacyCrl.sign(account, {}, (counter << TAG_BITS) | TAG_A);
-    CPPUNIT_ASSERT(crlNumberValue(legacyCrl.getNumber()) > (legacy & ~(uint64_t(1) << 63)));
-    CPPUNIT_ASSERT_EQUAL(uint64_t(0), crlNumberValue(legacyCrl.getNumber()) >> 63);
-}
-
 void
 CryptoTester::testCertificateRequest()
-{    // Generate CA
+{
+    // Generate CA
    auto ca = dht::crypto::generateIdentity("Test CA");

    // Generate signed request
@@ -316,15 +149,6 @@ CryptoTester::testCertificateSerialNumber()
    };
    auto serial = dht::crypto::Certificate(cert_pem).getSerialNumber();
    CPPUNIT_ASSERT(std::equal(SERIAL.begin(), SERIAL.end(), serial.begin(), serial.end()));
-
-    auto key = dht::crypto::PrivateKey::generateEC();
-    for (unsigned i = 0; i < 32; i++) {
-        auto generated = dht::crypto::Certificate::generate(key, "generated", {});
-        auto generatedSerial = generated.getSerialNumber();
-        CPPUNIT_ASSERT(not generatedSerial.empty());
-        CPPUNIT_ASSERT_EQUAL(uint8_t {0}, uint8_t(generatedSerial.front() & 0x80));
-        CPPUNIT_ASSERT(std::any_of(generatedSerial.begin(), generatedSerial.end(), [](uint8_t byte) { return byte != 0; }));
-    }
 }

 void
@@ -12,11 +12,7 @@ class CryptoTester : public CppUnit::TestFixture
 {
    CPPUNIT_TEST_SUITE(CryptoTester);
    CPPUNIT_TEST(testSignatureEncryption);
-    CPPUNIT_TEST(testPublicKeyPemIsPlainText);
    CPPUNIT_TEST(testCertificateRevocation);
-    CPPUNIT_TEST(testRevocationListNumber);
-    CPPUNIT_TEST(testRevocationListExplicitNumber);
-    CPPUNIT_TEST(testRevocationListPartitionedNumber);
    CPPUNIT_TEST(testCertificateRequest);
    CPPUNIT_TEST(testCertificateSerialNumber);
    CPPUNIT_TEST(testOcsp);
@@ -40,26 +36,10 @@ public:
     * Test data signature, encryption and decryption
     */
    void testSignatureEncryption();
-    /**
-     * Test that an exported public key is text only, with no embedded null byte
-     */
-    void testPublicKeyPemIsPlainText();
    /**
     * Test certificate generation, validation and revocation
     */
    void testCertificateRevocation();
-    /**
-     * Test the default CRL Number behavior: random on first signature, incremented after
-     */
-    void testRevocationListNumber();
-    /**
-     * Test signing a revocation list with a caller-provided CRL Number
-     */
-    void testRevocationListExplicitNumber();
-    /**
-     * Test that issuers sharing an authority can partition the CRL Number space
-     */
-    void testRevocationListPartitionedNumber();
    /**
     * Test certificate requests
     */
@@ -9,8 +9,6 @@
 #include <future>
 #include <mutex>
 #include <condition_variable>
-#include <fstream>
-#include <cstdio>
 using namespace std::chrono_literals;
 using namespace std::literals;

@@ -210,42 +208,6 @@ DhtRunnerTester::testImportValuesPreservesRemoteQuota()
    restored.join();
 }

-void
-DhtRunnerTester::testExportValuesUsesSystemTime()
-{
-    auto key = dht::InfoHash::get("export-system-time");
-    const auto created = dht::clock::now();
-    msgpack::sbuffer importBuffer;
-    msgpack::packer<msgpack::sbuffer> pk(&importBuffer);
-    pk.pack_array(1);
-    pk.pack_array(2);
-    pk.pack(created.time_since_epoch().count());
-    dht::Value {std::string("persisted")}.msgpack_pack(pk);
-    node1.importValues({
-        dht::ValuesExport {key, {importBuffer.data(), importBuffer.data() + importBuffer.size()}}
-    });
-
-    auto exported = node1.exportValues();
-    CPPUNIT_ASSERT_EQUAL(size_t(1), exported.size());
-
-    msgpack::unpacked msg;
-    msgpack::unpack(msg, reinterpret_cast<const char*>(exported.front().second.data()), exported.front().second.size());
-    const auto values = msg.get();
-    CPPUNIT_ASSERT(values.type == msgpack::type::ARRAY);
-    CPPUNIT_ASSERT_EQUAL(uint32_t(1), values.via.array.size);
-    const auto& persistedValue = values.via.array.ptr[0];
-    CPPUNIT_ASSERT_EQUAL(uint32_t(4), persistedValue.via.array.size);
-    CPPUNIT_ASSERT(persistedValue.via.array.ptr[0].type == msgpack::type::EXT);
-    CPPUNIT_ASSERT(persistedValue.via.array.ptr[3].type == msgpack::type::EXT);
-
-    const auto persistedCreated = persistedValue.via.array.ptr[0].as<std::chrono::system_clock::time_point>();
-    const auto persistedExpiration = persistedValue.via.array.ptr[3].as<std::chrono::system_clock::time_point>();
-    const auto delta = std::chrono::system_clock::now() - persistedCreated;
-    CPPUNIT_ASSERT(delta >= std::chrono::system_clock::duration::zero());
-    CPPUNIT_ASSERT(delta < 5s);
-    CPPUNIT_ASSERT(persistedExpiration > persistedCreated);
-}
-
 void
 DhtRunnerTester::testImportValuesPreservesStoredExpiration()
 {
@@ -578,34 +540,6 @@ DhtRunnerTester::testShutdownCompletesWithPendingPut()
    clientNode.join();
 }

-void
-DhtRunnerTester::testSavedPortFallback()
-{
-    // A saved port that is already taken by another process (e.g. fast
-    // application restart while the old instance still holds it) must not
-    // prevent the node from starting: it should fall back to a random port.
-    dht::DhtRunner::Config config;
-    config.dht_config.node_config.persist_path = "/tmp/opendht_test_port_fallback";
-    std::string portFile = config.dht_config.node_config.persist_path + "_port.txt";
-
-    // node1 (from setUp) holds a port; save it as our persisted port.
-    auto takenPort = node1.getBoundPort();
-    {
-        std::ofstream out(portFile);
-        out << takenPort << std::endl << takenPort << std::endl;
-    }
-
-    dht::DhtRunner testNode;
-    CPPUNIT_ASSERT_NO_THROW(testNode.run(0, config));
-    CPPUNIT_ASSERT(testNode.getBoundPort());
-    CPPUNIT_ASSERT(testNode.getBoundPort() != takenPort);
-
-    testNode.shutdown();
-    testNode.join();
-    std::remove(portFile.c_str());
-    std::remove((config.dht_config.node_config.persist_path + "_port.txt").c_str());
-}
-
 void
 DhtRunnerTester::testListen()
 {
@@ -21,14 +21,12 @@ class DhtRunnerTester : public CppUnit::TestFixture
    CPPUNIT_TEST(testListenLotOfBytes);
    CPPUNIT_TEST(testIdOps);
    CPPUNIT_TEST(testImportValuesPreservesRemoteQuota);
-    CPPUNIT_TEST(testExportValuesUsesSystemTime);
    CPPUNIT_TEST(testImportValuesPreservesStoredExpiration);
    CPPUNIT_TEST(testImportPermanentValueExpires);
    CPPUNIT_TEST(testBootstrapSetsConnectingState);
    CPPUNIT_TEST(testBootstrapThenPutNoRace);
    CPPUNIT_TEST(testBootstrapMissingNodeThenPutFails);
    CPPUNIT_TEST(testShutdownCompletesWithPendingPut);
-    CPPUNIT_TEST(testSavedPortFallback);
    CPPUNIT_TEST_SUITE_END();

    dht::DhtRunner node1 {};
@@ -68,14 +66,12 @@ public:
     */
    void testIdOps();
    void testImportValuesPreservesRemoteQuota();
-    void testExportValuesUsesSystemTime();
    void testImportValuesPreservesStoredExpiration();
    void testImportPermanentValueExpires();
    void testBootstrapSetsConnectingState();
    void testBootstrapThenPutNoRace();
    void testBootstrapMissingNodeThenPutFails();
    void testShutdownCompletesWithPendingPut();
-    void testSavedPortFallback();
    /**
     * Test listen method with lot of datas
     */
@@ -8,7 +8,6 @@

 #include <iostream>
 #include <string>
-#include <atomic>
 #include <chrono>
 #include <condition_variable>

@@ -333,36 +332,6 @@ HttpTester::test_parse_url_just_slash()
    CPPUNIT_ASSERT_EQUAL(std::string("/"), parsed.target);
 }

-void
-HttpTester::test_completed_resolver_callback_uses_io_thread()
-{
-    asio::io_context ioContext;
-    const asio::ip::tcp::endpoint endpoint(asio::ip::address_v4::loopback(), 80);
-    dht::http::Resolver resolver(ioContext, {endpoint});
-    const auto callerThread = std::this_thread::get_id();
-    std::thread::id callbackThread;
-    asio::error_code callbackError;
-    std::vector<asio::ip::tcp::endpoint> resolvedEndpoints;
-    std::atomic_bool callbackCalled {false};
-
-    resolver.add_callback([&](const asio::error_code& ec, const auto& endpoints) {
-        callbackError = ec;
-        callbackThread = std::this_thread::get_id();
-        resolvedEndpoints = endpoints;
-        callbackCalled = true;
-    });
-
-    CPPUNIT_ASSERT(!callbackCalled);
-    std::thread ioThread([&] { ioContext.run(); });
-    ioThread.join();
-
-    CPPUNIT_ASSERT(callbackCalled);
-    CPPUNIT_ASSERT(!callbackError);
-    CPPUNIT_ASSERT(callbackThread != callerThread);
-    CPPUNIT_ASSERT_EQUAL(size_t(1), resolvedEndpoints.size());
-    CPPUNIT_ASSERT_EQUAL(endpoint, resolvedEndpoints.front());
-}
-
 void
 HttpTester::test_send_json()
 {
@@ -39,7 +39,6 @@ class HttpTester : public CppUnit::TestFixture
    CPPUNIT_TEST(test_parse_url_complex_path_query_fragment);
    CPPUNIT_TEST(test_parse_url_empty);
    CPPUNIT_TEST(test_parse_url_just_slash);
-    CPPUNIT_TEST(test_completed_resolver_callback_uses_io_thread);
    // send
    CPPUNIT_TEST(test_send_json);
    CPPUNIT_TEST_SUITE_END();
@@ -83,7 +82,6 @@ public:
    void test_parse_url_complex_path_query_fragment();
    void test_parse_url_empty();
    void test_parse_url_just_slash();
-    void test_completed_resolver_callback_uses_io_thread();
    /**
     * Test send(json)
     */
@@ -80,46 +80,6 @@ ThreadPoolTester::testContext()
    CPPUNIT_ASSERT_EQUAL(N, count.load());
 }

-void
-ThreadPoolTester::testJoinNonEmptyTaskQueue()
-{
-    dht::ThreadPool pool(2);
-
-    constexpr unsigned N = 128;
-    std::atomic_uint count {0};
-
-    // Schedule enough work so that the task queue is non-empty when calling
-    // pool.join() below.
-    for (unsigned i = 0; i < N; i++)
-        pool.run([&] {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            count++;
-        });
-
-    std::atomic_bool joined {false};
-    std::condition_variable cv;
-    std::thread joinThread([&] {
-        CPPUNIT_ASSERT(count.load() < N);
-        pool.join();
-        joined = true;
-        cv.notify_one();
-    });
-
-    // After calling join(), all pending tasks should complete, and then all
-    // threads in the pool should join.
-    std::mutex mtx;
-    std::unique_lock lock(mtx);
-    bool poolJoined = cv.wait_for(lock, std::chrono::seconds(10), [&] { return joined.load(); });
-    if (!poolJoined) {
-        // Detach joinThread if we timed out, otherwise the test can crash.
-        joinThread.detach();
-    } else {
-        joinThread.join();
-    }
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Some tasks were not completed", N, count.load());
-    CPPUNIT_ASSERT_MESSAGE("Thread pool failed to join before timeout", poolJoined);
-}
-
 void
 ThreadPoolTester::tearDown()
 {}
@@ -14,7 +14,6 @@ class ThreadPoolTester : public CppUnit::TestFixture
    CPPUNIT_TEST(testThreadPool);
    CPPUNIT_TEST(testExecutor);
    CPPUNIT_TEST(testContext);
-    CPPUNIT_TEST(testJoinNonEmptyTaskQueue);
    CPPUNIT_TEST_SUITE_END();

 public:
@@ -30,7 +29,6 @@ public:
    void testThreadPool();
    void testExecutor();
    void testContext();
-    void testJoinNonEmptyTaskQueue();
 };

 } // namespace test
@@ -137,29 +137,4 @@ ValueTester::testPushTypePreservedAfterEncrypt()
    CPPUNIT_ASSERT(encrypted.isEncrypted());
 }

-void
-ValueTester::testPushTypeJsonRoundTrip()
-{
-#ifdef OPENDHT_JSONCPP
-    dht::Value original {(const uint8_t*) "hello", 5};
-    original.id = 42;
-    original.priority = 1;
-    original.pushType = "videoCall";
-
-    dht::Value restored(original.toJson());
-
-    CPPUNIT_ASSERT_EQUAL(original.id, restored.id);
-    CPPUNIT_ASSERT_EQUAL(original.priority, restored.priority);
-    CPPUNIT_ASSERT_EQUAL(original.pushType, restored.pushType);
-
-    // No pushType: the field must stay absent from the JSON and empty after parse.
-    dht::Value plain {(const uint8_t*) "data", 4};
-    plain.id = 7;
-    auto json = plain.toJson();
-    CPPUNIT_ASSERT(!json.isMember("pt"));
-    dht::Value plainRestored(json);
-    CPPUNIT_ASSERT_EQUAL(std::string(), plainRestored.pushType);
-#endif
-}
-
 } // namespace test
@@ -16,7 +16,6 @@ class ValueTester : public CppUnit::TestFixture
    CPPUNIT_TEST(testPushTypeMsgpackRoundTrip);
    CPPUNIT_TEST(testPushTypeAbsentAfterUnpack);
    CPPUNIT_TEST(testPushTypePreservedAfterEncrypt);
-    CPPUNIT_TEST(testPushTypeJsonRoundTrip);
    CPPUNIT_TEST_SUITE_END();

 public:
@@ -39,7 +38,6 @@ public:
    void testPushTypeMsgpackRoundTrip();
    void testPushTypeAbsentAfterUnpack();
    void testPushTypePreservedAfterEncrypt();
-    void testPushTypeJsonRoundTrip();
 };

 } // namespace test
@@ -123,7 +123,7 @@ main(int argc, char** argv)
                    iss >> idstr;
                    std::getline(iss, line);
                    dht.putEncrypted(room,
-                                     PkId(idstr),
+                                     InfoHash(idstr),
                                     dht::ImMessage(IdDist()(tools::rd), std::move(line), now),
                                     [](bool ok) {
                                         // dht.cancelPut(room, id);
@@ -481,7 +481,7 @@ cmd_loop(std::shared_ptr<DhtRunner>& node,
            auto value = std::make_shared<dht::Value>(dht::ValueType::USER_DATA.id,
                                                      std::vector<uint8_t> {v.begin(), v.end()});
            value->user_type = "text/plain";
-            node->putEncrypted(id, PkId(tostr), std::move(value), [start](bool ok) {
+            node->putEncrypted(id, InfoHash(tostr), std::move(value), [start](bool ok) {
                auto end = std::chrono::high_resolution_clock::now();
                std::cout << "Put encrypted: " << (ok ? "success" : "failure") << " (took "
                          << print_duration(end - start) << ')' << std::endl;
@@ -1,7 +1,7 @@
 {
  "default-registry": {
    "kind": "git",
-    "baseline": "f3e10653cc27d62a37a3763cd84b38bca07c6075",
+    "baseline": "66c0373dc7fca549e5803087b9487edfe3aca0a1",
    "repository": "https://github.com/microsoft/vcpkg"
  },
  "registries": [
@@ -1,6 +1,6 @@
 {
  "name": "opendht",
-  "version-string": "4.2.0",
+  "version-string": "3.7.9",
  "port-version": 1,
  "description": "OpenDHT: A lightweight C++17 Distributed Hash Table library.",
  "homepage": "https://opendht.net",