http: bound name resolution and reuse the endpoints it found

Request::send waits for Resolver before doing anything else, and the timeout a caller sets through Request::timeout is only armed later, in connect. A system resolver that never answers therefore holds the request for good: async_resolve has no deadline of its own, no timer covers the wait, and the callbacks queued in Resolver are never invoked. The proxy client reaches that path on every connectivity change, since connectivityChanged calls getProxyInfos, so a device coming back from sleep can sit there with no status, no listener and no error. getProxyInfos also builds a new Resolver each time and drops the previous one, discarding endpoints that were still perfectly usable. Resolution is then redone from scratch at the exact moment the network stack has just come up and is at its slowest. Give Resolver a deadline of its own, armed as soon as a query starts, and report timed_out to whoever is waiting. Let it also start from endpoints that were already resolved: those answer callbacks immediately so a connection begins without waiting, while the query still runs and replaces them as soon as it returns. An address that went stale in the meantime now costs one connection attempt, which Request retries against the pending query rather than reporting as a failure. A failed query no longer clears endpoints that are known to work, so a transient DNS outage leaves the client with something to connect to. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
utils: fix clock conversion overflow with mismatched durations
2026-11-08 12:28:42 +00:00 · 2026-09-03 07:50:51 -04:00 · 2026-09-01 22:56:16 -04:00 · 2026-09-01 21:34:36 -04:00 · 2026-08-06 14:05:48 -04:00 · 2026-08-06 13:59:48 -04:00
43 changed files with 1301 additions and 339 deletions
@@ -7,7 +7,7 @@ env:
  UBUNTU_FULL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
  UBUNTU_MESON_DEPS: "ninja-build libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-dev python3-setuptools python3-pip libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
  UBUNTU_MINIMAL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libfmt-dev libgnutls28-dev libcppunit-dev libmsgpack-dev libargon2-dev"
-  DEBIAN12_DEPS: "git libtool pkg-config wget cmake libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
+  DEBIAN13_DEPS: "git libtool pkg-config wget cmake libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"

 on: [push, pull_request]

@@ -16,7 +16,7 @@ jobs:
    name: Ubuntu/GCC Meson build
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7

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

      - name: Install Minimal Dependencies
        run: |
@@ -65,12 +65,12 @@ jobs:
      - name: Run Unit tests
        run: ctest --output-on-failure --test-dir build

-  build-debian12:
-    name: Debian 12/GCC build
+  build-debian13:
+    name: Debian 13/GCC build
    runs-on: ubuntu-latest

    container:
-      image: debian:12
+      image: debian:13
      volumes:
        - .:/workspace
      options: --workdir /workspace
@@ -78,12 +78,12 @@ jobs:
        DEBIAN_FRONTEND: noninteractive

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

      - name: Install Dependencies
        run: |
          apt-get update
-          apt-get install -y $DEBIAN12_DEPS
+          apt-get install -y $DEBIAN13_DEPS

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

      - 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@v6
+      - uses: actions/checkout@v7
      - name: deps
        run: |
          sudo apt update && \
@@ -27,7 +27,7 @@ jobs:

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

    - 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-latest]
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15]

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

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

@@ -36,7 +36,7 @@ jobs:
    name: Build wheels on Windows
    runs-on: windows-latest
    env:
-      VCPKG_VERSION: "2025.07.25"
+      VCPKG_VERSION: "2026.06.01"
      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@v6
+      - uses: actions/checkout@v7

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      - 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: "2025.07.25"
+      VCPKG_VERSION: "2026.06.01"
      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@v6
+        uses: actions/checkout@v7
        with:
          submodules: recursive

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

      - name: Cache vcpkg installed packages
        id: cache-vcpkg
-        uses: actions/cache@v5
+        uses: actions/cache@v6
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -413,7 +413,7 @@ jobs:
    name: Build Windows dhtnode
    runs-on: windows-latest
    env:
-      VCPKG_VERSION: "2025.07.25"
+      VCPKG_VERSION: "2026.06.01"
      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@v6
+        uses: actions/checkout@v7
        with:
          submodules: recursive

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

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

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

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

 env:
-  VCPKG_VERSION: "2026.01.16"
+  VCPKG_VERSION: "2026.06.01"
  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@v6
+        uses: actions/checkout@v7

      - 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@v5
+        uses: actions/cache@v6
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -75,7 +75,7 @@ jobs:

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

      - 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@v5
+        uses: actions/cache@v6
        with:
          path: |
            ${{ env.VCPKG_INSTALLED_DIR }}
@@ -125,14 +125,14 @@ jobs:

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

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

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

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

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

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

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

      - name: Setup MinGW
        uses: msys2/setup-msys2@v2
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.21...3.31)
+cmake_minimum_required (VERSION 3.21...4.4)
 if(POLICY CMP0091)
    cmake_policy(SET CMP0091 NEW)
 endif()
@@ -10,7 +10,7 @@ if(POLICY CMP0167)
 endif()

 set (opendht_VERSION_MAJOR 4)
-set (opendht_VERSION_MINOR 0.0)
+set (opendht_VERSION_MINOR 3.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -204,7 +204,13 @@ struct OPENDHT_PUBLIC PrivateKey
     * @param algo : the public key algorithm to use, GNUTLS_PK_RSA or GNUTLS_PK_RSA_OAEP
     */
    static PrivateKey generate(unsigned key_length = 4096, gnutls_pk_algorithm_t algo = GNUTLS_PK_RSA);
-    static PrivateKey generateEC();
+
+    /**
+     * Generate a new EC key pair
+     * @param curve : the elliptic curve to use. If GNUTLS_ECC_CURVE_INVALID is provided, the default curve will be used
+     * (currently GNUTLS_ECC_CURVE_SECP384R1).
+     */
+    static PrivateKey generateEC(gnutls_ecc_curve_t curve = GNUTLS_ECC_CURVE_INVALID);

    gnutls_privkey_t key {};
    gnutls_x509_privkey_t x509_key {};
@@ -267,9 +273,15 @@ 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 = {});
-    void sign(const Identity& id) { sign(*id.first, *id.second); }
+    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);
+    }

    bool isSignedBy(const Certificate& issuer) const;

@@ -159,7 +159,13 @@ 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;
@@ -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;

-class OPENDHT_PUBLIC Url
+struct OPENDHT_PUBLIC Url
 {
-public:
    Url() = default;
-    Url(std::string_view url);
+    Url(std::string 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, const std::string& url, std::shared_ptr<log::Logger> logger = {});
+    Resolver(asio::io_context& ctx, std::string url, std::shared_ptr<log::Logger> logger = {});
    Resolver(asio::io_context& ctx,
             std::string_view host,
             std::string_view service,
@@ -161,8 +161,15 @@ public:
             std::vector<asio::ip::tcp::endpoint> endpoints,
             const bool ssl = false,
             std::shared_ptr<log::Logger> logger = {});
+
+    /**
+     * Start from previously resolved endpoints while querying the url anyway.
+     * Callbacks are answered from the cached endpoints without waiting, and the
+     * query replaces them as soon as it returns, so an address that went stale
+     * costs a connection attempt rather than a resolution delay.
+     */
    Resolver(asio::io_context& ctx,
-             const std::string& url,
+             std::string url,
             std::vector<asio::ip::tcp::endpoint> endpoints,
             std::shared_ptr<log::Logger> logger = {});

@@ -170,7 +177,19 @@ public:

    inline const Url& get_url() const { return url_; }

-    void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC);
+    /** Endpoints known so far, either cached or resolved. May be empty. */
+    std::vector<asio::ip::tcp::endpoint> get_endpoints() const;
+
+    /** Whether a query is still running, so a different answer may still come. */
+    bool is_resolving() const;
+
+    /**
+     * Register a callback for the resolved endpoints.
+     * When freshOnly is set, a cached answer is not enough: the callback waits
+     * for the pending query, so a caller that failed to reach a cached address
+     * can retry against whatever the system resolver returns.
+     */
+    void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC, bool freshOnly = false);

    std::shared_ptr<log::Logger> getLogger() const { return logger_; }

@@ -178,17 +197,27 @@ public:

 private:
    void resolve(std::string_view host, std::string_view service);
+    void complete(const asio::error_code& ec, std::vector<asio::ip::tcp::endpoint>&& endpoints);
+
+    /**
+     * A stuck system resolver would otherwise hold every pending request for
+     * good: Request only arms its own timeout once resolution has answered.
+     */
+    static constexpr std::chrono::seconds RESOLVE_TIMEOUT {15};

    mutable std::mutex mutex_;

    Url url_;
    asio::error_code ec_;
    asio::ip::tcp::resolver resolver_;
+    std::unique_ptr<asio::steady_timer> timer_;
    std::shared_ptr<bool> destroyed_;
    std::vector<asio::ip::tcp::endpoint> endpoints_;

    bool completed_ {false};
+    bool resolving_ {false};
    std::queue<ResolverCb> cbs_;
+    std::queue<ResolverCb> freshCbs_;

    std::shared_ptr<log::Logger> logger_;
 };
@@ -216,19 +245,19 @@ public:

    // resolves implicitly
    Request(asio::io_context& ctx,
-            const std::string& url,
+            std::string url,
            const Json::Value& json,
            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, OnJsonCb jsoncb, 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 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, const std::string& url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});
+    Request(asio::io_context& ctx, 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);
@@ -321,6 +350,12 @@ private:

    void connect(std::vector<asio::ip::tcp::endpoint>&& endpoints, HandlerCb cb = {});

+    /**
+     * Resolve then connect. Retried once with freshOnly set when the endpoints
+     * that were handed out came from a cache and turned out to be unreachable.
+     */
+    void resolve_and_connect(bool freshOnly);
+
    void post();

    void handle_request(const asio::error_code& ec);
@@ -344,8 +379,6 @@ 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_;
@@ -489,8 +489,12 @@ private:
    static constexpr size_t MTU {1280};
    static constexpr size_t MAX_PACKET_VALUE_SIZE {600};
    static constexpr size_t MAX_MESSAGE_VALUE_SIZE {56 * 1024};
+    static constexpr size_t RX_MAX_EARLY_BYTES {MAX_MESSAGE_VALUE_SIZE + MAX_VALUE_SIZE + 32};
+    static constexpr size_t RX_MAX_EARLY_PARTS {RX_MAX_EARLY_BYTES / MTU + 2};

    void process(std::unique_ptr<ParsedMessage>&&, const SockAddr& from);
+    bool isExpectedReply(const ParsedMessage&, const SockAddr& from);
+    bool tryCompleteMessage(PartialMessage&, const SockAddr& from);

    bool rateLimit(const SockAddr& addr);

@@ -527,7 +531,8 @@ private:
    {
        return packValueHeader(buf, values.begin(), values.end());
    }
-    void maintainRxBuffer(Tid tid);
+    using PartialMessageKey = std::pair<SockAddr, Tid>;
+    void maintainRxBuffer(const PartialMessageKey& key);

    /*************
     *  Answers  *
@@ -573,7 +578,7 @@ private:

    // requests handling
    std::map<Tid, Sp<Request>> requests {};
-    std::map<Tid, PartialMessage> partial_messages;
+    std::map<PartialMessageKey, PartialMessage> partial_messages;

    MessageStats in_stats {}, out_stats {};
    std::set<SockAddr> blacklist {};
@@ -10,7 +10,9 @@
 #include <future>
 #include <functional>

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

 namespace dht {

@@ -85,6 +85,14 @@ 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.0.0',
+    version: '4.3.0',
    meson_version: '>=1.1.0',
    default_options: ['cpp_std=c++20', 'warning_level=3'],
 )
@@ -15,10 +15,23 @@ nettle = dependency('nettle')
 msgpack = dependency('msgpack-cxx', required: false)
 argon2 = dependency('libargon2')
 fmt = dependency('fmt')
-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'))
+
+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
+
 io_uring = host_machine.system() == 'linux' ? dependency('liburing', required: false) : disabler()

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

+if restinio_dep.found()
+    deps += restinio_dep
+endif
+
 if host_machine.system() == 'linux' and io_uring.found()
    deps += io_uring
 endif
@@ -79,7 +96,7 @@ if get_option('indexation').enabled()
    opendht_src += 'src/indexation/pht.cpp'
    add_project_arguments('-DOPENDHT_INDEXATION', language: 'cpp')
 endif
-if jsoncpp.found()
+if jsoncpp.found() and simdutf.found()
    opendht_src += ['src/base64.cpp']
    add_project_arguments('-DOPENDHT_JSONCPP', language: 'cpp')
    conf_data.set('jsoncpp_lib', ', jsoncpp')
@@ -28,18 +28,8 @@ install(CODE [[
        if(NOT _pip_check EQUAL 0)
            message(WARNING "Skipping Python package install: pip not available for ${Python3_EXECUTABLE}.")
        else()
-            set(_pip_install_args
-                install
-                --no-deps
-                --no-build-isolation
-                --break-system-packages
-                --prefix ${CMAKE_INSTALL_PREFIX})
-            if(DEFINED ENV{DESTDIR} AND NOT "$ENV{DESTDIR}" STREQUAL "")
-                list(APPEND _pip_install_args --root "$ENV{DESTDIR}")
-            endif()
-            list(APPEND _pip_install_args .)
            execute_process(
-                COMMAND ${Python3_EXECUTABLE} -m pip ${_pip_install_args}
+                COMMAND ${Python3_EXECUTABLE} -m pip install --no-deps --break-system-packages .
                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/python
                OUTPUT_VARIABLE _pip_output
                ERROR_VARIABLE _pip_error
@@ -36,4 +36,19 @@ 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,5 +21,12 @@ 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
@@ -571,6 +571,12 @@ 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;
 }

@@ -1288,14 +1294,16 @@ PrivateKey::generate(unsigned key_length, gnutls_pk_algorithm_t algo)
 }

 PrivateKey
-PrivateKey::generateEC()
+PrivateKey::generateEC(gnutls_ecc_curve_t curve)
 {
    gnutls_x509_privkey_t key;
    if (gnutls_x509_privkey_init(&key) != GNUTLS_E_SUCCESS)
        throw CryptoException("Unable to initialize private key.");
    int err = gnutls_x509_privkey_generate(key,
                                           GNUTLS_PK_EC,
-                                           gnutls_sec_param_to_pk_bits(GNUTLS_PK_EC, GNUTLS_SEC_PARAM_ULTRA),
+                                           curve == GNUTLS_ECC_CURVE_INVALID
+                                               ? gnutls_sec_param_to_pk_bits(GNUTLS_PK_EC, GNUTLS_SEC_PARAM_ULTRA)
+                                               : GNUTLS_CURVE_TO_BITS(curve),
                                           0);
    if (err != GNUTLS_E_SUCCESS) {
        gnutls_x509_privkey_deinit(key);
@@ -1396,8 +1404,11 @@ setRandomSerial(gnutls_x509_crt_t cert)
 {
    std::random_device rdev;
    std::uniform_int_distribution<int64_t> dist {1};
-    int64_t cert_serial = dist(rdev);
-    gnutls_x509_crt_set_serial(cert, &cert_serial, sizeof(cert_serial));
+    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());
 }

 Certificate
@@ -1873,34 +1884,8 @@ 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)
+RevocationList::sign(const PrivateKey& key, const Certificate& ca, duration validity, uint64_t crlNumber)
 {
    if (auto err = gnutls_x509_crl_set_version(crl, 2))
        throw CryptoException(std::string("Unable to set CRL version: ") + gnutls_strerror(err));
@@ -1910,19 +1895,28 @@ 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 {0};
-    size_t number_sz {sizeof(number)};
-    unsigned critical {0};
-    gnutls_x509_crl_get_number(crl, &number, &number_sz, &critical);
+    uint64_t number {crlNumber};
    if (number == 0) {
-        // 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));
+        // 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));
    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
@@ -2270,8 +2270,16 @@ Dht::onDisconnected()
 void
 Dht::bootstrap()
 {
-    if (dht4.status != NodeStatus::Disconnected || dht6.status != NodeStatus::Disconnected)
+    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();
        return;
+    }
    if (logger_)
        logger_->debug("[{}] Bootstraping", myid.to_view());
    bootstrap_pending = false;
@@ -2355,6 +2363,9 @@ 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) {
@@ -2367,7 +2378,7 @@ Dht::exportValues() const
        pk.pack_array(vals.size());
        for (const auto& v : vals) {
            pk.pack_array(4);
-            pk.pack(v.created.time_since_epoch().count());
+            pk.pack(to_system_time(v.created, now, system_now));
            v.data->msgpack_pack(pk);
            if (const auto& store_addr = v.store_bucket ? v.store_bucket->getAddr() : SockAddr {}) {
                pk.pack_bin(store_addr.getLength());
@@ -2375,7 +2386,7 @@ Dht::exportValues() const
            } else {
                pk.pack_bin(0);
            }
-            pk.pack(v.expiration.time_since_epoch().count());
+            pk.pack(to_system_time(v.expiration, now, system_now));
        }
        ve.second = {buffer.data(), buffer.data() + buffer.size()};
        e.push_back(std::move(ve));
@@ -2387,6 +2398,7 @@ 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;
@@ -2411,8 +2423,15 @@ Dht::importValues(const std::vector<ValuesExport>& import)
                Value tmp_val;
                SockAddr store_addr;
                try {
-                    val_time = time_point {
-                        time_point::duration {valel.via.array.ptr[0].as<time_point::duration::rep>()}};
+                    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>()}};
+                    }
                    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>();
@@ -2422,8 +2441,14 @@ Dht::importValues(const std::vector<ValuesExport>& import)
                        }
                    }
                    if (valel.via.array.size >= 4) {
-                        expiration = time_point {
-                            time_point::duration {valel.via.array.ptr[3].as<time_point::duration::rep>()}};
+                        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>()}};
+                        }
                    }
                } catch (const std::exception&) {
                    if (logger_)
@@ -652,7 +652,21 @@ DhtProxyClient::getProxyInfos()
    if (logger_)
        logger_->debug("[proxy:client] [status] sending request");

-    auto resolver = std::make_shared<http::Resolver>(httpContext_, proxyUrl_, logger_);
+    // Reuse what the previous resolver found: the query still runs, but a
+    // connection can start at once instead of waiting for the system resolver,
+    // which is the slowest step when the device wakes up from sleep.
+    std::vector<asio::ip::tcp::endpoint> knownEndpoints;
+    {
+        std::lock_guard l(resolverLock_);
+        if (resolver_)
+            knownEndpoints = resolver_->get_endpoints();
+    }
+    auto resolver = knownEndpoints.empty()
+                        ? std::make_shared<http::Resolver>(httpContext_, proxyUrl_, logger_)
+                        : std::make_shared<http::Resolver>(httpContext_,
+                                                           proxyUrl_,
+                                                           std::move(knownEndpoints),
+                                                           logger_);
    queryProxyInfo(infoState, resolver, AF_INET);
    queryProxyInfo(infoState, resolver, AF_INET6);
    std::lock_guard l(resolverLock_);
@@ -1205,14 +1205,7 @@ DhtProxyServer::sendPushNotification(
    try {
        std::shared_ptr<http::Request> request;
        if (type == PushType::UnifiedPush) {
-            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));
+            request = std::make_shared<http::Request>(io_context(), token, logger_);
        } else {
            request = std::make_shared<http::Request>(io_context(),
                                                      pushHostPort_.first,
@@ -1231,8 +1224,8 @@ DhtProxyServer::sendPushNotification(
            Blob auth;   ///< Auth secret
            auto delim = topicView.find('|');
            if (delim != std::string_view::npos) {
-                pubKey = base64_decode(topicView.substr(0, delim));
-                auth = base64_decode(topicView.substr(delim + 1));
+                pubKey = base64_default_or_url_decode(topicView.substr(0, delim));
+                auth = base64_default_or_url_decode(topicView.substr(delim + 1));
            }

            request->set_header_field(restinio::http_field_t::ttl, "86400");
@@ -99,6 +99,11 @@ 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()) {
@@ -110,6 +115,7 @@ DhtRunner::run(const Config& config, Context&& context)
                                              fmt::ptr(this),
                                              port);
                        local4.setPort(port);
+                        triedSavedPort = true;
                    }
                }
                if (inConfig >> port) {
@@ -119,6 +125,7 @@ DhtRunner::run(const Config& config, Context&& context)
                                              fmt::ptr(this),
                                              port);
                        local6.setPort(port);
+                        triedSavedPort = true;
                    }
                }
            }
@@ -136,7 +143,20 @@ DhtRunner::run(const Config& config, Context&& context)

        if (config.proxy_server.empty()) {
            if (not context.sock) {
-                context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
+                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->setOnReceive([&](net::PacketList&& pkts) {
                net::PacketList ret;
@@ -534,8 +554,14 @@ DhtRunner::registerInsecureType(const ValueType& type)
 void
 DhtRunner::importValues(const std::vector<ValuesExport>& values)
 {
-    std::lock_guard lck(dht_mtx);
-    dht_->importValues(values);
+    {
+        std::lock_guard lck(dht_mtx);
+        dht_->importValues(values);
+    }
+    // Recompute the runner wakeup after import schedules value expirations.
+    std::lock_guard lck(storage_mtx);
+    pending_ops_prio.emplace([](SecureDht&) {});
+    cv.notify_all();
 }

 unsigned
@@ -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_view url_str)
-    : url(url_str)
+Url::Url(std::string url_str)
+    : url(std::move(url_str))
 {
    std::string_view u = url;
    if (u.empty())
@@ -302,13 +302,13 @@ static X509*
 issuer_from_chain(STACK_OF(X509) * fullchain)
 {
    X509 *cert, *issuer;
-    X509_NAME* issuer_name;
+    const X509_NAME* issuer_name;

    cert = cert_from_chain(fullchain);
    if ((issuer_name = X509_get_issuer_name(cert)) == nullptr)
        return nullptr;

-    issuer = X509_find_by_subject(fullchain, issuer_name);
+    issuer = X509_find_by_subject(fullchain, const_cast<X509_NAME*>(issuer_name));
    return issuer;
 }

@@ -830,8 +830,8 @@ Connection::timeout(const std::chrono::seconds& timeout, HandlerCb cb)

 // Resolver

-Resolver::Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger)
-    : url_(url)
+Resolver::Resolver(asio::io_context& ctx, std::string url, std::shared_ptr<dht::Logger> logger)
+    : url_(std::move(url))
    , resolver_(ctx)
    , destroyed_(std::make_shared<bool>(false))
    , logger_(logger)
@@ -867,12 +867,31 @@ Resolver::Resolver(asio::io_context& ctx,
    completed_ = true;
 }

+Resolver::Resolver(asio::io_context& ctx,
+                   std::string url,
+                   std::vector<asio::ip::tcp::endpoint> endpoints,
+                   std::shared_ptr<dht::Logger> logger)
+    : url_(std::move(url))
+    , resolver_(ctx)
+    , destroyed_(std::make_shared<bool>(false))
+    , endpoints_(std::move(endpoints))
+    , logger_(logger)
+{
+    // Answer from the cached endpoints right away so a connection can start
+    // without waiting for the system resolver, and query anyway so a stale
+    // address is replaced as soon as the answer comes back.
+    completed_ = not endpoints_.empty();
+    resolve(url_.host, url_.service.empty() ? url_.protocol : url_.service);
+}
+
 Resolver::~Resolver()
 {
    decltype(cbs_) cbs;
+    decltype(freshCbs_) freshCbs;
    {
        std::lock_guard lock(mutex_);
        cbs = std::move(cbs_);
+        freshCbs = std::move(freshCbs_);
    }
    while (not cbs.empty()) {
        auto cb = cbs.front();
@@ -880,9 +899,29 @@ Resolver::~Resolver()
            cb(asio::error::operation_aborted, {});
        cbs.pop();
    }
+    while (not freshCbs.empty()) {
+        auto cb = freshCbs.front();
+        if (cb)
+            cb(asio::error::operation_aborted, {});
+        freshCbs.pop();
+    }
    *destroyed_ = true;
 }

+std::vector<asio::ip::tcp::endpoint>
+Resolver::get_endpoints() const
+{
+    std::lock_guard lock(mutex_);
+    return endpoints_;
+}
+
+bool
+Resolver::is_resolving() const
+{
+    std::lock_guard lock(mutex_);
+    return resolving_;
+}
+
 void
 Resolver::cancel()
 {
@@ -905,20 +944,69 @@ filter(const std::vector<asio::ip::tcp::endpoint>& epts, sa_family_t family)
 }

 void
-Resolver::add_callback(ResolverCb cb, sa_family_t family)
+Resolver::add_callback(ResolverCb cb, sa_family_t family, bool freshOnly)
 {
    std::lock_guard lock(mutex_);
+    auto wrapped = family == AF_UNSPEC
+                       ? std::move(cb)
+                       : ResolverCb {[cb, family](const asio::error_code& ec,
+                                                  const std::vector<asio::ip::tcp::endpoint>& endpoints) {
+                             if (ec)
+                                 cb(ec, endpoints);
+                             else
+                                 cb(ec, filter(endpoints, family));
+                         }};
    if (!completed_)
-        cbs_.emplace(family == AF_UNSPEC ? std::move(cb)
-                                         : [cb, family](const asio::error_code& ec,
-                                                        const std::vector<asio::ip::tcp::endpoint>& endpoints) {
-                                               if (ec)
-                                                   cb(ec, endpoints);
-                                               else
-                                                   cb(ec, filter(endpoints, family));
-                                           });
-    else
-        cb(ec_, family == AF_UNSPEC ? endpoints_ : filter(endpoints_, family));
+        cbs_.emplace(std::move(wrapped));
+    else if (freshOnly and resolving_)
+        // The cached endpoints already failed this caller, so hold the callback
+        // until the query that is still running has something else to offer.
+        freshCbs_.emplace(std::move(wrapped));
+    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(wrapped), ec = ec_, endpoints = endpoints_] { cb(ec, endpoints); });
+    }
+}
+
+void
+Resolver::complete(const asio::error_code& ec, std::vector<asio::ip::tcp::endpoint>&& endpoints)
+{
+    decltype(cbs_) cbs;
+    decltype(freshCbs_) freshCbs;
+    asio::error_code reportedEc;
+    std::vector<asio::ip::tcp::endpoint> reportedEndpoints;
+    {
+        std::lock_guard lock(mutex_);
+        resolving_ = false;
+        if (not ec) {
+            ec_ = ec;
+            endpoints_ = std::move(endpoints);
+        } else if (endpoints_.empty()) {
+            // Nothing cached to fall back on, so the failure has to be reported.
+            ec_ = ec;
+        }
+        completed_ = true;
+        cbs = std::move(cbs_);
+        freshCbs = std::move(freshCbs_);
+        reportedEc = ec_;
+        reportedEndpoints = endpoints_;
+    }
+    while (not cbs.empty()) {
+        auto cb = cbs.front();
+        if (cb)
+            cb(reportedEc, reportedEndpoints);
+        cbs.pop();
+    }
+    while (not freshCbs.empty()) {
+        auto cb = freshCbs.front();
+        if (cb)
+            cb(reportedEc, reportedEndpoints);
+        freshCbs.pop();
+    }
 }

 void
@@ -935,30 +1023,45 @@ Resolver::resolve(std::string_view host, std::string_view service)
    } else if (service == "https"sv) {
        service = "443"sv;
    }
+
+    {
+        std::lock_guard lock(mutex_);
+        resolving_ = true;
+    }
+
+    if (not timer_)
+        timer_ = std::make_unique<asio::steady_timer>(resolver_.get_executor());
+    timer_->expires_after(RESOLVE_TIMEOUT);
+    timer_->async_wait([this, destroyed = destroyed_](const asio::error_code& ec) {
+        if (ec == asio::error::operation_aborted or *destroyed)
+            return;
+        {
+            std::lock_guard lock(mutex_);
+            if (not resolving_)
+                return;
+            // Claim the completion under the lock so the query answering at the
+            // same moment cannot report a second time.
+            resolving_ = false;
+        }
+        if (logger_)
+            logger_->error("[http:client] [resolver] timed out resolving {:s}", url_.host);
+        resolver_.cancel();
+        complete(asio::error::timed_out, {});
+    });
+
    resolver_.async_resolve(host,
                            service,
                            [this, destroyed = destroyed_](const asio::error_code& ec,
                                                           asio::ip::tcp::resolver::results_type endpoints) {
                                if (ec == asio::error::operation_aborted or *destroyed)
                                    return;
+                                if (timer_)
+                                    timer_->cancel();
                                if (logger_) {
                                    logger_->debug("[http:client] [resolver] got result: {:s}", ec.message());
                                }
-                                decltype(cbs_) cbs;
-                                {
-                                    std::lock_guard lock(mutex_);
-                                    ec_ = ec;
-                                    endpoints_ = std::vector<asio::ip::tcp::endpoint> {endpoints.begin(),
-                                                                                       endpoints.end()};
-                                    completed_ = true;
-                                    cbs = std::move(cbs_);
-                                }
-                                while (not cbs.empty()) {
-                                    auto cb = cbs.front();
-                                    if (cb)
-                                        cb(ec, endpoints_);
-                                    cbs.pop();
-                                }
+                                complete(ec,
+                                         std::vector<asio::ip::tcp::endpoint> {endpoints.begin(), endpoints.end()});
                            });
 }

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

 Request::Request(asio::io_context& ctx,
-                 const std::string& url,
+                 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, url, logger))
+    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
 {
    init_default_headers();
    set_header_field(restinio::http_field_t::content_type, std::string(HTTP_HEADER_CONTENT_TYPE_JSON));
@@ -997,11 +1100,11 @@ Request::Request(asio::io_context& ctx,
    });
 }

-Request::Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb, std::shared_ptr<dht::Logger> logger)
+Request::Request(asio::io_context& ctx, 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, url, logger))
+    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
 {
    init_default_headers();
    set_header_field(restinio::http_field_t::accept, std::string(HTTP_HEADER_CONTENT_TYPE_JSON));
@@ -1022,20 +1125,20 @@ Request::Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb,
    });
 }

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

-Request::Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger)
+Request::Request(asio::io_context& ctx, std::string url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger)
    : logger_(logger)
    , id_(Request::ids_++)
    , ctx_(ctx)
-    , resolver_(std::make_shared<Resolver>(ctx, url, logger))
+    , resolver_(std::make_shared<Resolver>(ctx, std::move(url), logger))
 {
    init_default_headers();
    add_on_done_callback(std::move(onDone));
@@ -1086,7 +1189,6 @@ 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);
 }

@@ -1437,7 +1539,12 @@ void
 Request::send()
 {
    notify_state_change(State::CREATED);
+    resolve_and_connect(false);
+}

+void
+Request::resolve_and_connect(bool freshOnly)
+{
    std::weak_ptr<Request> wthis = shared_from_this();
    resolver_->add_callback(
        [wthis](const asio::error_code& ec, std::vector<asio::ip::tcp::endpoint> endpoints) {
@@ -1451,17 +1558,28 @@ Request::send()
                } else if (!this_.conn_ or !this_.conn_->is_open()) {
                    this_.connect(std::move(endpoints), [wthis](const asio::error_code& ec) {
                        if (auto sthis = wthis.lock()) {
-                            if (ec)
-                                sthis->terminate(asio::error::not_connected);
-                            else
+                            if (not ec) {
                                sthis->post();
+                            } else if (sthis->resolver_->is_resolving()) {
+                                // These endpoints came from a cache that no longer
+                                // points anywhere. The query is still running, so
+                                // wait for it rather than fail on a stale address.
+                                if (sthis->logger_)
+                                    sthis->logger_->debug(
+                                        "[http:request:{:d}] cached endpoints unreachable, awaiting resolution",
+                                        sthis->id_);
+                                sthis->resolve_and_connect(true);
+                            } else {
+                                sthis->terminate(asio::error::not_connected);
+                            }
                        }
                    });
                } else
                    this_.post();
            }
        },
-        family_);
+        family_,
+        freshOnly);
 }

 void
@@ -40,8 +40,44 @@ struct NetworkEngine::PartialMessage
    time_point start;
    time_point last_part;
    std::unique_ptr<ParsedMessage> msg;
+    std::vector<std::unique_ptr<ParsedMessage>> early_parts;
+    size_t early_bytes {};
+    bool request_quota_consumed {};
 };

+bool
+NetworkEngine::isExpectedReply(const ParsedMessage& msg, const SockAddr& from)
+{
+    auto request = requests.find(msg.tid);
+    if (request != requests.end() && request->second->pending() && !request->second->node->id
+        && request->second->node->getAddr() == from)
+        return true;
+
+    auto node = cache.getNode(msg.id, from.getFamily());
+    if (!node || node->getAddr() != from)
+        return false;
+
+    auto pending = node->getRequest(msg.tid);
+    return (pending && pending->pending()) || node->getSocket(msg.tid);
+}
+
+bool
+NetworkEngine::tryCompleteMessage(PartialMessage& partial, const SockAddr& from)
+{
+    try {
+        if (!partial.msg->complete())
+            return false;
+        process(std::move(partial.msg), from);
+    } catch (const std::exception& e) {
+        if (logger_)
+            logger_->warn("Error while processing partial message: {}", e.what());
+    } catch (...) {
+        if (logger_)
+            logger_->warn("Unknown error while processing partial message");
+    }
+    return true;
+}
+
 std::vector<Blob>
 serializeValues(const std::vector<Sp<Value>>& st)
 {
@@ -466,35 +502,58 @@ NetworkEngine::processMessage(const uint8_t* buf, size_t buflen, SockAddr f)

    // partial value data
    if (msg->type == MessageType::ValueData) {
-        auto pmsg_it = partial_messages.find(msg->tid);
-        if (pmsg_it == partial_messages.end()) {
-            if (logIncoming_)
-                if (logger_)
-                    logger_->debug("Unable to find partial message");
+        if (msg->fragment_parts.empty()
+            || std::any_of(msg->fragment_parts.begin(), msg->fragment_parts.end(), [](const auto& fragment) {
+                   return fragment.second.second.empty();
+               })) {
            rateLimit(from);
            return;
        }
-        if (!pmsg_it->second.from.equals(from)) {
-            if (logger_)
-                logger_->debug("Received partial message data from unexpected IP address");
-            rateLimit(from);
+        PartialMessageKey key {from, msg->tid};
+        auto pmsg_it = partial_messages.find(key);
+        if (pmsg_it == partial_messages.end()) {
+            if (!rateLimit(from))
+                return;
+            auto inserted = partial_messages.emplace(key, PartialMessage {});
+            pmsg_it = inserted.first;
+            pmsg_it->second.from = from;
+            pmsg_it->second.start = now;
+            pmsg_it->second.last_part = now;
+            pmsg_it->second.request_quota_consumed = true;
+            scheduler.add(now + RX_MAX_PACKET_TIME, std::bind(&NetworkEngine::maintainRxBuffer, this, key));
+        }
+        auto& pmsg = pmsg_it->second;
+        if (!pmsg.msg) {
+            if (pmsg.early_parts.size() >= RX_MAX_EARLY_PARTS) {
+                partial_messages.erase(pmsg_it);
+                return;
+            }
+            size_t fragment_bytes {};
+            for (const auto& [index, fragment] : msg->fragment_parts) {
+                (void) index;
+                if (fragment.second.size() > RX_MAX_EARLY_BYTES - fragment_bytes) {
+                    partial_messages.erase(pmsg_it);
+                    return;
+                }
+                fragment_bytes += fragment.second.size();
+            }
+            if (fragment_bytes > RX_MAX_EARLY_BYTES - pmsg.early_bytes) {
+                partial_messages.erase(pmsg_it);
+                return;
+            }
+            pmsg.early_bytes += fragment_bytes;
+            pmsg.early_parts.emplace_back(std::move(msg));
+            pmsg.last_part = now;
+            scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, key));
            return;
        }
        // append data block
-        if (pmsg_it->second.msg->append(*msg)) {
-            pmsg_it->second.last_part = now;
-            // check data completion
-            if (pmsg_it->second.msg->complete()) {
-                try {
-                    // process the full message
-                    process(std::move(pmsg_it->second.msg), from);
-                } catch (const std::exception& e) {
-                    if (logger_)
-                        logger_->warn("Error while processing partial message: {}", e.what());
-                }
+        if (pmsg.msg->append(*msg)) {
+            pmsg.last_part = now;
+            if (tryCompleteMessage(pmsg, from)) {
                partial_messages.erase(pmsg_it);
            } else
-                scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, msg->tid));
+                scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, key));
        }
        return;
    }
@@ -505,7 +564,32 @@ NetworkEngine::processMessage(const uint8_t* buf, size_t buflen, SockAddr f)
        return;
    }

-    if (msg->type > MessageType::Reply) {
+    if (msg->value_parts.empty()) {
+        if (msg->type > MessageType::Reply) {
+            /* Rate limit requests. */
+            if (!rateLimit(from)) {
+                if (logger_)
+                    logger_->warn("Dropping request due to rate limiting");
+                return;
+            }
+        }
+        try {
+            process(std::move(msg), from);
+        } catch (const std::exception& e) {
+            if (logger_)
+                logger_->warn("Error while processing message: {}", e.what());
+        }
+        return;
+    }
+
+    PartialMessageKey partial_key {from, msg->tid};
+    if (msg->type == MessageType::Reply && !isExpectedReply(*msg, from))
+        return;
+
+    const auto partial = partial_messages.find(partial_key);
+    const bool request_quota_consumed = partial != partial_messages.end() && !partial->second.msg
+                                        && partial->second.request_quota_consumed;
+    if (msg->type > MessageType::Reply && !request_quota_consumed) {
        /* Rate limit requests. */
        if (!rateLimit(from)) {
            if (logger_)
@@ -514,28 +598,28 @@ NetworkEngine::processMessage(const uint8_t* buf, size_t buflen, SockAddr f)
        }
    }

-    if (msg->value_parts.empty()) {
-        try {
-            process(std::move(msg), from);
-        } catch (const std::exception& e) {
-            if (logger_)
-                logger_->warn("Error while processing message: {}", e.what());
-            return;
-        }
-    } else {
-        // starting partial message session
-        auto k = msg->tid;
-        auto& pmsg = partial_messages[k];
-        if (not pmsg.msg) {
+    // starting partial message session
+    auto inserted = partial_messages.emplace(partial_key, PartialMessage {});
+    auto& pmsg = inserted.first->second;
+    if (not pmsg.msg) {
+        if (inserted.second) {
            pmsg.from = from;
-            pmsg.msg = std::move(msg);
            pmsg.start = now;
-            pmsg.last_part = now;
-            scheduler.add(now + RX_MAX_PACKET_TIME, std::bind(&NetworkEngine::maintainRxBuffer, this, k));
-            scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, k));
-        } else if (logger_)
-            logger_->error("Partial message with given TID {} already exists", k);
-    }
+            scheduler.add(now + RX_MAX_PACKET_TIME, std::bind(&NetworkEngine::maintainRxBuffer, this, partial_key));
+        }
+        pmsg.msg = std::move(msg);
+        pmsg.last_part = now;
+        for (const auto& part : pmsg.early_parts)
+            pmsg.msg->append(*part);
+        pmsg.early_parts.clear();
+        pmsg.early_bytes = 0;
+        if (tryCompleteMessage(pmsg, from)) {
+            partial_messages.erase(inserted.first);
+        } else {
+            scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, partial_key));
+        }
+    } else if (logger_)
+        logger_->error("Partial message from {} with given TID {} already exists", from.toString(), msg->tid);
 }

 void
@@ -1614,9 +1698,9 @@ NetworkEngine::sendError(const SockAddr& addr, Tid tid, uint16_t code, const std
 }

 void
-NetworkEngine::maintainRxBuffer(Tid tid)
+NetworkEngine::maintainRxBuffer(const PartialMessageKey& key)
 {
-    auto msg = partial_messages.find(tid);
+    auto msg = partial_messages.find(key);
    if (msg != partial_messages.end()) {
        const auto& now = scheduler.time();
        if (msg->second.start + RX_MAX_PACKET_TIME < now || msg->second.last_part + RX_TIMEOUT < now) {
@@ -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);
@@ -274,14 +274,21 @@ ParsedMessage::msgpack_unpack(const msgpack::object& msg)

    if (!parsed.a && !parsed.r && !parsed.e && !parsed.u)
        throw msgpack::type_error();
-    auto& req = parsed.a ? *parsed.a : (parsed.r ? *parsed.r : (parsed.u ? *parsed.u : *parsed.e));

    if (parsed.e) {
-        if (parsed.e->type != msgpack::type::ARRAY)
+        if (parsed.e->type != msgpack::type::ARRAY or parsed.e->via.array.size < 1)
            throw msgpack::type_error();
        error_code = parsed.e->via.array.ptr[0].as<uint16_t>();
    }

+    /* An error-only message carries no request map. The error array must never
+       be reached through the map view of the msgpack object union, and a
+       request field that is not a map must be rejected rather than
+       reinterpreted. */
+    const msgpack::object* req = parsed.a ? parsed.a : (parsed.r ? parsed.r : parsed.u);
+    if (req and req->type != msgpack::type::MAP)
+        throw msgpack::type_error();
+
    struct ParsedReq
    {
        msgpack::object* values;
@@ -290,8 +297,9 @@ ParsedMessage::msgpack_unpack(const msgpack::object& msg)
        msgpack::object* want;
    } parsedReq {};

-    for (unsigned i = 0; i < req.via.map.size; i++) {
-        auto& o = req.via.map.ptr[i];
+    const uint32_t req_size = req ? req->via.map.size : 0;
+    for (unsigned i = 0; i < req_size; i++) {
+        auto& o = req->via.map.ptr[i];
        if (o.key.type != msgpack::type::STR)
            continue;
        auto key = o.key.as<std::string_view>();
@@ -370,6 +378,8 @@ ParsedMessage::msgpack_unpack(const msgpack::object& msg)
    } else if (parsedReq.fields) {
        if (auto rfields = findMapValue(*parsedReq.fields, "f"sv)) {
            auto vfields = rfields->as<std::set<Value::Field>>();
+            if (vfields.empty())
+                throw msgpack::type_error();
            if (auto rvalues = findMapValue(*parsedReq.fields, "v"sv)) {
                if (rvalues->type != msgpack::type::ARRAY)
                    throw msgpack::type_error();
@@ -6,8 +6,10 @@
 #include <atomic>
 #include <thread>
 #include <iostream>
-#include <ciso646> // fix windows compiler bug
-#include <cmath>   // std::pow
+#include <cmath> // std::pow
+#if __cplusplus < 202002L
+#include <ciso646>
+#endif

 namespace dht {

@@ -238,28 +238,67 @@ 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();
+    // Saturate before the cast: the steady clock duration may hold a narrower range than the system one.
+    constexpr auto max_dt = std::chrono::duration_cast<system_clock::duration>(duration::max());
+    constexpr auto min_dt = std::chrono::duration_cast<system_clock::duration>(duration::min());
+    auto system_dt = t - system_now;
+    if (system_dt >= max_dt)
+        return time_point::max();
+    if (system_dt <= min_dt)
+        return time_point::min();
+    auto dt = std::chrono::duration_cast<duration>(system_dt);
+    if (dt > duration(0) and steady_now > time_point::max() - dt)
+        return time_point::max();
+    else if (dt < 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();
+    // Cast first: mixing clock durations of different periods would overflow the bound computations below.
+    auto dt = std::chrono::duration_cast<system_clock::duration>(t - steady_now);
+    if (dt > system_clock::duration(0) and system_now >= system_clock::time_point::max() - dt)
+        return system_clock::time_point::max();
+    else if (dt < system_clock::duration(0) and system_now <= system_clock::time_point::min() - dt)
+        return system_clock::time_point::min();
+    return system_now + 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)
 {
-    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;
+    return from_system_time(system_clock::from_time_t(t));
 }

 std::time_t
 to_time_t(time_point 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));
+    return system_clock::to_time_t(to_system_time(t));
 }

 Blob
@@ -202,6 +202,9 @@ 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
@@ -228,6 +231,8 @@ Value::toJson() const
    }
    if (priority)
        val["prio"] = priority;
+    if (not pushType.empty())
+        val[VALUE_KEY_PUSHTYPE] = pushType;
    return val;
 }

@@ -59,6 +59,24 @@ 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()
 {
@@ -95,10 +113,159 @@ 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
@@ -149,6 +316,25 @@ 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
+CryptoTester::testEcKeyCurve()
+{
+    auto key = dht::crypto::PrivateKey::generateEC(GNUTLS_ECC_CURVE_SECP256R1);
+    unsigned int bits = 0;
+    CPPUNIT_ASSERT_EQUAL(static_cast<int>(GNUTLS_PK_EC),
+                         gnutls_x509_privkey_get_pk_algorithm2(key.x509_key, &bits));
+    CPPUNIT_ASSERT_EQUAL(256u, bits);
 }

 void
@@ -12,9 +12,14 @@ 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(testEcKeyCurve);
    CPPUNIT_TEST(testOcsp);
    CPPUNIT_TEST(testAesEncryption);
    CPPUNIT_TEST(testAesEncryptionWithMultipleKeySizes);
@@ -36,10 +41,26 @@ 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
     */
@@ -48,6 +69,10 @@ public:
     * Test certificate serial number extraction
     */
    void testCertificateSerialNumber();
+    /**
+     * Test EC private key generation with an explicit curve
+     */
+    void testEcKeyCurve();
    /**
     * Test OCSP
     */
@@ -9,6 +9,8 @@
 #include <future>
 #include <mutex>
 #include <condition_variable>
+#include <fstream>
+#include <cstdio>
 using namespace std::chrono_literals;
 using namespace std::literals;

@@ -208,6 +210,42 @@ 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()
 {
@@ -265,14 +303,25 @@ DhtRunnerTester::testImportValuesPreservesStoredExpiration()
 void
 DhtRunnerTester::testImportPermanentValueExpires()
 {
-    // Simulate importing a value that was originally stored as permanent
-    // (expiration = time_point::max()). After import the permanent flag is lost,
-    // so the value must expire within the type's normal expiration window.
-    static const dht::ValueType SHORT_TYPE {201, "Short perm", 2s};
+    static const dht::ValueType SHORT_TYPE {201, "Short perm", 500ms};
+
+    dht::DhtRunner::Config config;
+    config.dht_config.node_config.max_peer_req_per_sec = -1;
+    config.dht_config.node_config.max_req_per_sec = -1;
+    config.dht_config.node_config.max_store_size = -1;
+    config.dht_config.node_config.max_store_keys = -1;
+    dht::DhtRunner restored;
+    restored.run(0, config);
+    restored.registerInsecureType(SHORT_TYPE);
+
+    // Ensure the runner is waiting on a previously computed scheduler deadline.
+    std::promise<void> loopCompleted;
+    auto loopCompletedFuture = loopCompleted.get_future();
+    restored.getNodeInfo([&loopCompleted](auto) { loopCompleted.set_value(); });
+    getFutureValue(std::move(loopCompletedFuture));

    auto key = dht::InfoHash::get("import-permanent-expiration");
    auto now = dht::clock::now();
-
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
    pk.pack_array(1);
@@ -280,63 +329,33 @@ DhtRunnerTester::testImportPermanentValueExpires()
    pk.pack(now.time_since_epoch().count());
    dht::Value {SHORT_TYPE.id, std::string("was-permanent")}.msgpack_pack(pk);
    pk.pack_bin(0);
-    // Permanent values are exported with time_point::max() expiration
    pk.pack(dht::clock::time_point::max().time_since_epoch().count());

-    dht::DhtRunner restored;
-    dht::DhtRunner::Config config;
-    config.dht_config.node_config.max_peer_req_per_sec = -1;
-    config.dht_config.node_config.max_req_per_sec = -1;
-    config.dht_config.node_config.max_store_size = -1;
-    config.dht_config.node_config.max_store_keys = -1;
-    restored.run(0, config);
-
    restored.importValues({
        dht::ValuesExport {key, {buffer.data(), buffer.data() + buffer.size()}}
    });

-    // Value should be present right after import
-    auto exportedBefore = restored.exportValues();
-    CPPUNIT_ASSERT(!exportedBefore.empty());
-
-    // Wait longer than the default USER_DATA expiration (10 min) is not
-    // practical, but the type is unregistered so the default 10 min expiration
-    // applies.  Instead, register the short type so the cap uses 2 s.
-    // Re-import into a fresh node that knows the short type.
-    dht::DhtRunner restored2;
-    restored2.run(0, config);
-    restored2.registerInsecureType(SHORT_TYPE);
-    restored2.importValues({
-        dht::ValuesExport {key, {buffer.data(), buffer.data() + buffer.size()}}
-    });
-
-    CPPUNIT_ASSERT(!restored2.exportValues().empty());
-
-    // Wait for the short expiration to pass
-    std::this_thread::sleep_for(3s);
-
-    auto restoredValues = restored2.exportValues();
-    bool found = false;
-    for (const auto& ve : restoredValues) {
-        if (ve.first == key) {
+    auto containsValue = [&] {
+        for (const auto& [exportedKey, data] : restored.exportValues()) {
+            if (exportedKey != key)
+                continue;
            msgpack::unpacked msg;
-            msgpack::unpack(msg, (const char*) ve.second.data(), ve.second.size());
+            msgpack::unpack(msg, reinterpret_cast<const char*>(data.data()), data.size());
            auto valarr = msg.get();
            CPPUNIT_ASSERT(valarr.type == msgpack::type::ARRAY);
-            // The value should have expired
-            CPPUNIT_ASSERT_EQUAL(uint32_t(0), valarr.via.array.size);
-            found = true;
+            return valarr.via.array.size != 0;
        }
-    }
-    // Either the key was cleaned up entirely or it was found with 0 values
-    CPPUNIT_ASSERT(found || restoredValues.empty()
-                   || std::none_of(restoredValues.begin(), restoredValues.end(),
-                                   [&](const auto& ve) { return ve.first == key; }));
+        return false;
+    };
+
+    CPPUNIT_ASSERT(containsValue());
+    auto timeout = dht::clock::now() + 2s;
+    while (containsValue() and dht::clock::now() < timeout)
+        std::this_thread::sleep_for(10ms);
+    CPPUNIT_ASSERT(!containsValue());

    restored.shutdown();
    restored.join();
-    restored2.shutdown();
-    restored2.join();
 }

 void
@@ -540,6 +559,34 @@ 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,12 +21,14 @@ 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 {};
@@ -66,12 +68,14 @@ 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,6 +8,7 @@

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

@@ -332,6 +333,36 @@ 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,6 +39,7 @@ 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();
@@ -82,6 +83,7 @@ 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)
     */
@@ -214,9 +214,12 @@ makeEngine(std::unique_ptr<TestDatagramSocket>&& socket,
           std::mt19937_64& rd,
           int& onNewNodeCalls)
 {
+    net::NetworkConfig config {};
+    config.max_req_per_sec = -1;
+    config.max_peer_req_per_sec = -1;
    return net::NetworkEngine(
        myid,
-        {},
+        config,
        std::move(socket),
        {},
        rd,
@@ -234,6 +237,21 @@ makeEngine(std::unique_ptr<TestDatagramSocket>&& socket,
        [](Sp<Node>, const InfoHash&, const Blob&, const Value::Id&) { return net::RequestAnswer {}; });
 }

+static Sp<Node>
+addPendingGetRequest(net::NetworkEngine& engine, const InfoHash& id, const SockAddr& addr, Tid tid)
+{
+    auto node = engine.insertNode(id, addr);
+    auto request = std::make_shared<net::Request>(
+        MessageType::GetValues,
+        tid,
+        node,
+        Blob {},
+        [](const net::Request&, ParsedMessage&&) {},
+        [](const net::Request&, bool) {});
+    node->requested(request);
+    return node;
+}
+
 void
 NetworkEngineTester::setUp()
 {}
@@ -243,24 +261,130 @@ NetworkEngineTester::tearDown()
 {}

 void
-NetworkEngineTester::testIgnoresUnknownPartialData()
+NetworkEngineTester::testCompletesPartialSessionWithDataBeforeHeader()
 {
    Scheduler scheduler;
    std::mt19937_64 rd(0);
    InfoHash myid = InfoHash::getRandom(rd);
+    InfoHash remoteId = InfoHash::getRandom(rd);
    int onNewNodeCalls = 0;
    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);

-    Blob fragment = {1, 2, 3};
-    auto packet = makeValueDataPacketBlob(99, 0, 0, fragment);
+    auto serialized = serializeValue("fragment before header");
    auto from = makeIPv4("127.0.0.2", 5000);
+    addPendingGetRequest(engine, remoteId, from, 99);
+    auto initialOnNewNodeCalls = onNewNodeCalls;
+    auto fragment = makeValueDataPacketBlob(99, 0, 0, serialized);
+    auto header = makeReplyHeaderPacketBlob(remoteId, 99, {serialized.size()});

+    engine.processMessage(fragment.data(), fragment.size(), from);
+    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
+    CPPUNIT_ASSERT_EQUAL(initialOnNewNodeCalls, onNewNodeCalls);
+
+    engine.processMessage(header.data(), header.size(), from);
+
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
+    CPPUNIT_ASSERT(onNewNodeCalls > initialOnNewNodeCalls);
+}
+
+void
+NetworkEngineTester::testBuffersLargeValueBeforeHeader()
+{
+    Scheduler scheduler;
+    std::mt19937_64 rd(8);
+    InfoHash myid = InfoHash::getRandom(rd);
+    InfoHash remoteId = InfoHash::getRandom(rd);
+    int onNewNodeCalls = 0;
+    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);
+
+    auto serialized = serializeValue(std::string(57 * 1024, 'l'));
+    auto from = makeIPv4("127.0.0.2", 5008);
+    addPendingGetRequest(engine, remoteId, from, 101);
+    auto initialOnNewNodeCalls = onNewNodeCalls;
+    for (size_t offset = 0; offset < serialized.size(); offset += TEST_MTU) {
+        auto end = std::min(offset + TEST_MTU, serialized.size());
+        Blob data(serialized.begin() + offset, serialized.begin() + end);
+        auto fragment = makeValueDataPacketBlob(101, 0, offset, data);
+        engine.processMessage(fragment.data(), fragment.size(), from);
+    }
+    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
+
+    auto header = makeReplyHeaderPacketBlob(remoteId, 101, {serialized.size()});
+    engine.processMessage(header.data(), header.size(), from);
+
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
+    CPPUNIT_ASSERT(onNewNodeCalls > initialOnNewNodeCalls);
+}
+
+void
+NetworkEngineTester::testIgnoresEmptyPartialData()
+{
+    Scheduler scheduler;
+    std::mt19937_64 rd(7);
+    InfoHash myid = InfoHash::getRandom(rd);
+    int onNewNodeCalls = 0;
+    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);
+
+    auto packet = makeValueDataPacketBlob(100, 0, 0, {});
+    auto from = makeIPv4("127.0.0.2", 5007);
    engine.processMessage(packet.data(), packet.size(), from);

    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
    CPPUNIT_ASSERT_EQUAL(0, onNewNodeCalls);
 }

+void
+NetworkEngineTester::testRejectsUnsolicitedPartialReply()
+{
+    Scheduler scheduler;
+    std::mt19937_64 rd(9);
+    InfoHash myid = InfoHash::getRandom(rd);
+    InfoHash remoteId = InfoHash::getRandom(rd);
+    int onNewNodeCalls = 0;
+    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);
+
+    auto from = makeIPv4("127.0.0.2", 5009);
+    auto header = makeReplyHeaderPacketBlob(remoteId, 102, {TEST_MTU});
+    engine.processMessage(header.data(), header.size(), from);
+
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getNodeCacheSize());
+}
+
+void
+NetworkEngineTester::testDropsMalformedCompletedPartialMessage()
+{
+    Scheduler scheduler;
+    std::mt19937_64 rd(10);
+    InfoHash myid = InfoHash::getRandom(rd);
+    InfoHash remoteId = InfoHash::getRandom(rd);
+    int onNewNodeCalls = 0;
+    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);
+
+    auto from = makeIPv4("127.0.0.2", 5010);
+    addPendingGetRequest(engine, remoteId, from, 103);
+    Blob malformed {0xc1};
+    auto header = makeReplyHeaderPacketBlob(remoteId, 103, {malformed.size()});
+    auto fragment = makeValueDataPacketBlob(103, 0, 0, malformed);
+
+    engine.processMessage(header.data(), header.size(), from);
+    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
+    engine.processMessage(fragment.data(), fragment.size(), from);
+
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
+
+    auto earlyFrom = makeIPv4("127.0.0.2", 5011);
+    addPendingGetRequest(engine, remoteId, earlyFrom, 104);
+    auto earlyHeader = makeReplyHeaderPacketBlob(remoteId, 104, {malformed.size()});
+    auto earlyFragment = makeValueDataPacketBlob(104, 0, 0, malformed);
+
+    engine.processMessage(earlyFragment.data(), earlyFragment.size(), earlyFrom);
+    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
+    engine.processMessage(earlyHeader.data(), earlyHeader.size(), earlyFrom);
+
+    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
+}
+
 void
 NetworkEngineTester::testCompletesPartialSessionFromSameSource()
 {
@@ -274,6 +398,8 @@ NetworkEngineTester::testCompletesPartialSessionFromSameSource()
    std::string data(TEST_MTU * 2 + 64, 'z');
    auto serialized = serializeValue(data);
    auto from = makeIPv4("127.0.0.2", 5001);
+    addPendingGetRequest(engine, remoteId, from, 7);
+    auto initialOnNewNodeCalls = onNewNodeCalls;
    auto header = makeReplyHeaderPacketBlob(remoteId, 7, {serialized.size()});

    engine.processMessage(header.data(), header.size(), from);
@@ -287,45 +413,40 @@ NetworkEngineTester::testCompletesPartialSessionFromSameSource()
    }

    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
-    CPPUNIT_ASSERT(onNewNodeCalls > 0);
+    CPPUNIT_ASSERT(onNewNodeCalls > initialOnNewNodeCalls);
 }

 void
-NetworkEngineTester::testKeepsSessionForWrongSourceFragment()
+NetworkEngineTester::testSeparatesPartialSessionsBySource()
 {
    Scheduler scheduler;
    std::mt19937_64 rd(2);
    InfoHash myid = InfoHash::getRandom(rd);
-    InfoHash remoteId = InfoHash::getRandom(rd);
+    InfoHash firstRemoteId = InfoHash::getRandom(rd);
+    InfoHash secondRemoteId = InfoHash::getRandom(rd);
    int onNewNodeCalls = 0;
    auto engine = makeEngine(std::make_unique<TestDatagramSocket>(), scheduler, myid, rd, onNewNodeCalls);

-    std::string data(TEST_MTU + 32, 'w');
-    auto serialized = serializeValue(data);
-    auto goodFrom = makeIPv4("127.0.0.2", 5002);
-    auto badFrom = makeIPv4("127.0.0.3", 5002);
-    auto header = makeReplyHeaderPacketBlob(remoteId, 11, {serialized.size()});
+    auto serialized = serializeValue("same transaction, different peers");
+    auto firstFrom = makeIPv4("127.0.0.2", 5002);
+    auto secondFrom = makeIPv4("127.0.0.3", 5002);
+    addPendingGetRequest(engine, firstRemoteId, firstFrom, 11);
+    addPendingGetRequest(engine, secondRemoteId, secondFrom, 11);
+    auto initialOnNewNodeCalls = onNewNodeCalls;
+    auto firstHeader = makeReplyHeaderPacketBlob(firstRemoteId, 11, {serialized.size()});
+    auto secondHeader = makeReplyHeaderPacketBlob(secondRemoteId, 11, {serialized.size()});

-    engine.processMessage(header.data(), header.size(), goodFrom);
+    engine.processMessage(firstHeader.data(), firstHeader.size(), firstFrom);
+    engine.processMessage(secondHeader.data(), secondHeader.size(), secondFrom);
+    CPPUNIT_ASSERT_EQUAL((size_t) 2, engine.getPartialCount());
+
+    auto fragment = makeValueDataPacketBlob(11, 0, 0, serialized);
+    engine.processMessage(fragment.data(), fragment.size(), firstFrom);
    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
-
-    auto firstEnd = std::min(TEST_MTU, serialized.size());
-    Blob firstFragment(serialized.begin(), serialized.begin() + firstEnd);
-    auto firstPacket = makeValueDataPacketBlob(11, 0, 0, firstFragment);
-    engine.processMessage(firstPacket.data(), firstPacket.size(), badFrom);
-
-    CPPUNIT_ASSERT_EQUAL((size_t) 1, engine.getPartialCount());
-    CPPUNIT_ASSERT_EQUAL(0, onNewNodeCalls);
-
-    engine.processMessage(firstPacket.data(), firstPacket.size(), goodFrom);
-    if (firstEnd < serialized.size()) {
-        Blob tail(serialized.begin() + firstEnd, serialized.end());
-        auto tailPacket = makeValueDataPacketBlob(11, 0, firstEnd, tail);
-        engine.processMessage(tailPacket.data(), tailPacket.size(), goodFrom);
-    }
+    engine.processMessage(fragment.data(), fragment.size(), secondFrom);

    CPPUNIT_ASSERT_EQUAL((size_t) 0, engine.getPartialCount());
-    CPPUNIT_ASSERT(onNewNodeCalls > 0);
+    CPPUNIT_ASSERT(onNewNodeCalls > initialOnNewNodeCalls);
 }

 void
@@ -13,9 +13,13 @@ class NetworkEngineTester : public CppUnit::TestFixture
 #ifdef _MSC_VER
    CPPUNIT_TEST(testDisabledOnMsvc);
 #else
-    CPPUNIT_TEST(testIgnoresUnknownPartialData);
+    CPPUNIT_TEST(testCompletesPartialSessionWithDataBeforeHeader);
+    CPPUNIT_TEST(testBuffersLargeValueBeforeHeader);
+    CPPUNIT_TEST(testIgnoresEmptyPartialData);
+    CPPUNIT_TEST(testRejectsUnsolicitedPartialReply);
+    CPPUNIT_TEST(testDropsMalformedCompletedPartialMessage);
    CPPUNIT_TEST(testCompletesPartialSessionFromSameSource);
-    CPPUNIT_TEST(testKeepsSessionForWrongSourceFragment);
+    CPPUNIT_TEST(testSeparatesPartialSessionsBySource);
    CPPUNIT_TEST(testListenConfirmationCarriesToken);
    CPPUNIT_TEST(testListenConfirmationUpdatesSearchNodeToken);
    CPPUNIT_TEST(testListenReopensSocketAfterNodeExpiration);
@@ -30,9 +34,13 @@ public:
 #ifdef _MSC_VER
    void testDisabledOnMsvc();
 #else
-    void testIgnoresUnknownPartialData();
+    void testCompletesPartialSessionWithDataBeforeHeader();
+    void testBuffersLargeValueBeforeHeader();
+    void testIgnoresEmptyPartialData();
+    void testRejectsUnsolicitedPartialReply();
+    void testDropsMalformedCompletedPartialMessage();
    void testCompletesPartialSessionFromSameSource();
-    void testKeepsSessionForWrongSourceFragment();
+    void testSeparatesPartialSessionsBySource();
    void testListenConfirmationCarriesToken();
    void testListenConfirmationUpdatesSearchNodeToken();
    void testListenReopensSocketAfterNodeExpiration();
@@ -328,6 +328,104 @@ ParsedMessageTester::testParseRejectsInvalidValuesField()
    CPPUNIT_ASSERT_THROW(parsed.msgpack_unpack(msg.get()), msgpack::type_error);
 }

+void
+ParsedMessageTester::testParseRejectsEmptyFieldSelection()
+{
+    msgpack::sbuffer buffer;
+    msgpack::packer<msgpack::sbuffer> pk(&buffer);
+
+    pk.pack_map(3);
+    pk.pack(KEY_R);
+    pk.pack_map(1);
+    pk.pack(KEY_REQ_FIELDS);
+    pk.pack_map(2);
+    pk.pack("f");
+    pk.pack_array(0);
+    pk.pack("v");
+    pk.pack_array(0);
+    pk.pack(KEY_TID);
+    pk.pack(1u);
+    pk.pack(KEY_Y);
+    pk.pack(KEY_R);
+
+    auto msg = msgpack::unpack(buffer.data(), buffer.size());
+    ParsedMessage parsed;
+    CPPUNIT_ASSERT_THROW(parsed.msgpack_unpack(msg.get()), msgpack::type_error);
+}
+
+void
+ParsedMessageTester::testParseRejectsEmptyErrorArray()
+{
+    msgpack::sbuffer buffer;
+    msgpack::packer<msgpack::sbuffer> pk(&buffer);
+
+    pk.pack_map(3);
+    pk.pack(KEY_E);
+    pk.pack_array(0);
+    pk.pack(KEY_TID);
+    pk.pack(1u);
+    pk.pack(KEY_Y);
+    pk.pack(KEY_E);
+
+    auto msg = msgpack::unpack(buffer.data(), buffer.size());
+    ParsedMessage parsed;
+    CPPUNIT_ASSERT_THROW(parsed.msgpack_unpack(msg.get()), msgpack::type_error);
+}
+
+void
+ParsedMessageTester::testParseRejectsNonMapRequest()
+{
+    msgpack::sbuffer buffer;
+    msgpack::packer<msgpack::sbuffer> pk(&buffer);
+
+    pk.pack_map(4);
+    pk.pack(KEY_A);
+    pk.pack_array(2);
+    pk.pack(1u);
+    pk.pack(2u);
+    pk.pack(KEY_Q);
+    pk.pack(QUERY_PING);
+    pk.pack(KEY_TID);
+    pk.pack(1u);
+    pk.pack(KEY_Y);
+    pk.pack("q");
+
+    auto msg = msgpack::unpack(buffer.data(), buffer.size());
+    ParsedMessage parsed;
+    CPPUNIT_ASSERT_THROW(parsed.msgpack_unpack(msg.get()), msgpack::type_error);
+}
+
+void
+ParsedMessageTester::testParseErrorOnlyMessageKeepsRequestFieldsEmpty()
+{
+    msgpack::sbuffer buffer;
+    msgpack::packer<msgpack::sbuffer> pk(&buffer);
+
+    // An error message with no request map: the error array must not be walked
+    // as if it were a sequence of key/value pairs.
+    pk.pack_map(3);
+    pk.pack(KEY_E);
+    pk.pack_array(2);
+    pk.pack(401u);
+    pk.pack("unauthorized");
+    pk.pack(KEY_TID);
+    pk.pack(9u);
+    pk.pack(KEY_Y);
+    pk.pack(KEY_E);
+
+    auto msg = msgpack::unpack(buffer.data(), buffer.size());
+    ParsedMessage parsed;
+    parsed.msgpack_unpack(msg.get());
+
+    CPPUNIT_ASSERT(parsed.type == MessageType::Error);
+    CPPUNIT_ASSERT_EQUAL((uint16_t) 401, parsed.error_code);
+    CPPUNIT_ASSERT(not parsed.id);
+    CPPUNIT_ASSERT(parsed.token.empty());
+    CPPUNIT_ASSERT(parsed.values.empty());
+    CPPUNIT_ASSERT(parsed.nodes4_raw.empty());
+    CPPUNIT_ASSERT(parsed.nodes6_raw.empty());
+}
+
 void
 ParsedMessageTester::testParseIgnoresIncompleteValueDataEntry()
 {
@@ -24,6 +24,10 @@ class ParsedMessageTester : public CppUnit::TestFixture
    CPPUNIT_TEST(testParseRejectsNonMapPacket);
    CPPUNIT_TEST(testParseRejectsInvalidValueDataPayload);
    CPPUNIT_TEST(testParseRejectsInvalidValuesField);
+    CPPUNIT_TEST(testParseRejectsEmptyFieldSelection);
+    CPPUNIT_TEST(testParseRejectsEmptyErrorArray);
+    CPPUNIT_TEST(testParseRejectsNonMapRequest);
+    CPPUNIT_TEST(testParseErrorOnlyMessageKeepsRequestFieldsEmpty);
    CPPUNIT_TEST(testParseIgnoresIncompleteValueDataEntry);
    CPPUNIT_TEST(testCompleteEmpty);
    CPPUNIT_TEST(testCompleteIncomplete);
@@ -53,6 +57,10 @@ public:
    void testParseRejectsNonMapPacket();
    void testParseRejectsInvalidValueDataPayload();
    void testParseRejectsInvalidValuesField();
+    void testParseRejectsEmptyFieldSelection();
+    void testParseRejectsEmptyErrorArray();
+    void testParseRejectsNonMapRequest();
+    void testParseErrorOnlyMessageKeepsRequestFieldsEmpty();
    void testParseIgnoresIncompleteValueDataEntry();
    void testCompleteEmpty();
    void testCompleteIncomplete();
@@ -137,4 +137,29 @@ 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,6 +16,7 @@ class ValueTester : public CppUnit::TestFixture
    CPPUNIT_TEST(testPushTypeMsgpackRoundTrip);
    CPPUNIT_TEST(testPushTypeAbsentAfterUnpack);
    CPPUNIT_TEST(testPushTypePreservedAfterEncrypt);
+    CPPUNIT_TEST(testPushTypeJsonRoundTrip);
    CPPUNIT_TEST_SUITE_END();

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

 } // namespace test
@@ -1,7 +1,7 @@
 {
  "default-registry": {
    "kind": "git",
-    "baseline": "66c0373dc7fca549e5803087b9487edfe3aca0a1",
+    "baseline": "f3e10653cc27d62a37a3763cd84b38bca07c6075",
    "repository": "https://github.com/microsoft/vcpkg"
  },
  "registries": [
@@ -1,6 +1,6 @@
 {
  "name": "opendht",
-  "version-string": "4.0.0",
+  "version-string": "4.3.0",
  "port-version": 1,
  "description": "OpenDHT: A lightweight C++17 Distributed Hash Table library.",
  "homepage": "https://opendht.net",
Author	SHA1	Message	Date
Cyrille BéraudandCopilot App	e9208cfbe4	http: bound name resolution and reuse the endpoints it found Request::send waits for Resolver before doing anything else, and the timeout a caller sets through Request::timeout is only armed later, in connect. A system resolver that never answers therefore holds the request for good: async_resolve has no deadline of its own, no timer covers the wait, and the callbacks queued in Resolver are never invoked. The proxy client reaches that path on every connectivity change, since connectivityChanged calls getProxyInfos, so a device coming back from sleep can sit there with no status, no listener and no error. getProxyInfos also builds a new Resolver each time and drops the previous one, discarding endpoints that were still perfectly usable. Resolution is then redone from scratch at the exact moment the network stack has just come up and is at its slowest. Give Resolver a deadline of its own, armed as soon as a query starts, and report timed_out to whoever is waiting. Let it also start from endpoints that were already resolved: those answer callbacks immediately so a connection begins without waiting, while the query still runs and replaces them as soon as it returns. An address that went stale in the meantime now costs one connection attempt, which Request retries against the pending query rather than reporting as a failure. A failed query no longer clears endpoints that are known to work, so a transient DNS outage leaves the client with something to connect to. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>	2026-09-03 07:50:51 -04:00
Adrien Beraud	8baf53d078	utils: fix clock conversion overflow with mismatched durations to_system_time computed its saturation bounds by subtracting a steady_clock duration from system_clock::time_point::max(). When the two clocks have different periods (microseconds for system_clock and nanoseconds for steady_clock on libc++), the common type promotes the bound to nanoseconds and overflows, so every future time point was converted to system_clock::time_point::max(). Cast the delta to the target duration before comparing against the bounds, and saturate from_system_time before the reverse cast for symmetry.	2026-09-01 22:56:16 -04:00
Adrien Beraud	82ab21dc3f	crypto: support explicit EC curve generation	2026-09-01 21:34:36 -04:00
Adrien Beraud	d676aef027	http: support legacy X509 lookup signature	2026-08-06 14:05:48 -04:00
Adrien Beraud	a2d9fdf334	Recompute runner wakeup after import schedules value expirations.	2026-08-06 13:59:48 -04:00
Adrien Beraud	0cec4135c0	update to 4.3.0	2026-08-05 16:35:01 -04:00
Adrien Beraud	6f76686a3e	ci: update to Debian 13	2026-08-05 16:19:46 -04:00
Adrien Beraud	c211b3c376	dht: persist values with system time	2026-08-05 16:14:15 -04:00
Adrien Beraud	0179b6ecc7	test: cover system time state persistence	2026-08-05 16:14:15 -04:00
Adrien Beraud	44e1ad839e	net: harden fragmented reply completion	2026-08-05 14:29:03 -04:00
Adrien Beraud	dddd97daff	tests: cover partial reply hardening	2026-08-05 14:29:03 -04:00
Adrien Beraud	632bec459e	net: avoid partial key allocation for regular messages	2026-08-05 14:29:03 -04:00
Cyrille BéraudandCopilot	910ca10a5f	net: reject malformed error and request fields An error array was read at index 0 without checking its size, so a packet carrying "e":[] dereferenced a null element pointer and crashed the process on unauthenticated UDP input. When a message had an error array but no "a", "r" or "u" map, the same object was then walked through the map view of the msgpack union. A two-element array appeared to hold two key/value pairs, reading past its allocation. A request field that was not a map was never type-checked either. Validate the error array size, restrict request parsing to "a", "r" and "u", and require those to be maps. Add parser regressions for the empty error array, the error-only message and the non-map request; the first one segfaults without this change. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-08-05 14:29:03 -04:00
Cyrille BéraudandCopilot	0826822a4d	net: harden fragmented message reassembly Key partial messages by source and transaction ID, buffer bounded fragments received before their header, and avoid charging reordered requests twice against rate limits. Cover source collisions, early fragments, empty data and large values. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-08-05 14:29:03 -04:00
Cyrille BéraudandCopilot	8aa6b009c3	net: reject empty field selections Reject field-compressed responses with no selected fields before computing the value count, avoiding a division by zero on malformed network input. Add a parser regression test. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-08-05 14:29:03 -04:00
Cyrille BéraudandCopilot	2caa21d65f	dht: let a node that lost the network try to rejoin it Dht::onDisconnected() only starts a bootstrap when bootstrapJob is unset, reading a set handle as "a bootstrap is already scheduled". That reading is wrong: Scheduler::run() erases the job from its timers and calls it, but never clears the shared handle the caller holds, and Scheduler::cancel() leaves the handle alone too when the job is no longer in the timers. The handle therefore stays set for as long as the Dht lives, once a bootstrap job has run. That is harmless while bootstrap() reschedules itself, which it does as long as the node is disconnected. It is not harmless on the early return: a job that fires while a ping is still in flight, or while a dubious contact keeps the status at Connecting, returns without rescheduling. From then on the chain is dead and onDisconnected() will not restart it, so a node that goes on to lose every contact stays disconnected for good. Only an explicit addBootstrap() or a connectivityChanged() can revive it, and a node whose network simply went away gets neither. Clearing the handle on the early return restores the meaning onDisconnected() relies on. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-08-03 11:34:25 -04:00
Adrien Beraud	cf64fa454c	crypto: encode certificate serials in network order	2026-08-02 17:24:55 -04:00
Adrien Beraud	ef9ef12195	tests: cover positive certificate serials	2026-08-02 17:24:55 -04:00
Cyrille BéraudandCopilot	74a1918a4d	crypto: strip the terminating null byte from an exported public key gnutls_pubkey_export reports the size of the exported PEM including its terminating null byte, and PublicKey::toString hands that size straight back to the caller. The returned string therefore ends with a null byte that is not part of the PEM text. Certificate::toString does not have the problem because gnutls_x509_crt_export excludes the terminator, so the two exports disagree on what a PEM string is. The stray byte travels: Value::toJson stores owner->toString() in the "owner" field, so a value published through the proxy carries a null byte inside a JSON string, which is valid JSON but a surprise for any consumer that treats the field as text. Resize to the reported size and drop the terminator when it is there. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-08-02 17:20:04 -04:00
dependabot[bot]	56a60fb557	build(deps): bump pypa/cibuildwheel from 4.1.0 to 4.1.1 Bumps [pypa/cibuildwheel](https://github.com/pypa/cibuildwheel) from 4.1.0 to 4.1.1. - [Release notes](https://github.com/pypa/cibuildwheel/releases) - [Changelog](https://github.com/pypa/cibuildwheel/blob/main/docs/changelog.md) - [Commits](https://github.com/pypa/cibuildwheel/compare/v4.1.0...v4.1.1) --- updated-dependencies: - dependency-name: pypa/cibuildwheel dependency-version: 4.1.1 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2026-07-30 10:17:04 -04:00
Adrien Beraud	f98df1d615	crypto: allow signing a revocation list with an explicit CRL number RevocationList::sign() always overwrote the CRL Number extension: random on the first signature, incremented afterwards. This leaves no way for a certificate authority replicated over several devices to keep numbers unique, since every device branching from the same list mints the same number for a different content. Add an optional `number` parameter, used verbatim when non-zero, so callers can partition the number space (RFC 5280 5.2.3 requires monotonicity for a given CRL scope and issuer, not globally). Also fix the default increment path: the extension holds a DER integer with leading zeros stripped, so reading it straight into an uint64_t only worked for numbers wide enough to occupy all 8 bytes. Signing a list numbered 5 produced 0x0500000000000001 instead of 6. Read and write the number as a big-endian byte string instead, which makes the `endian()` helper unnecessary. Add tests covering the default numbering, explicit numbers (including values with leading zero bytes and the largest positive 8-byte integer), pack/unpack round-trips, and a device-partitioned numbering scheme.	2026-07-29 13:26:23 -04:00
Adrien Beraud	8f779f2efb	http: fix build on OpenSSL 4.0	2026-07-20 11:25:02 -04:00
Adrien Beraud	699073acd8	update version to 4.2.0	2026-07-17 14:09:54 -04:00
Cyrille	02d49b9f6a	http: run completed resolver callbacks on io executor	2026-07-15 14:07:14 -04:00
Adrien Beraud	85b0bc52c8	test: reproduce completed resolver callback race	2026-07-15 14:07:14 -04:00
Adrien Beraud	af02c3a117	ci: install brew packages for macOS 15	2026-07-15 12:16:28 -04:00
François-Simon Fauteux-Chapleau	74b99453ce	op_cache: fix boundary condition In SearchCache::expire, if there is an op whose expiration is equal to `now`, then it's not processed and the function returns `now` as the next expiration timepoint. This can lead to the opExpirationJob in Search::cancelListen getting rescheduled at the same time in an infinite loop.	2026-07-13 14:38:27 -04:00
Adrien Beraud	cba3d0e18f	update version to 4.1.1	2026-07-06 15:50:00 -04:00
Adrien Beraud	f9332985f5	thread_pool: only include ciso646 on C++<20	2026-07-06 15:45:01 -04:00
Cyrille BéraudandCopilot	513d0eb803	dhtrunner: fall back to random port when saved port is taken Since `15eb221c` the node's bound port is persisted alongside the DHT state and reused on the next run for a stable identity. If that port is still held by another process - typically a fast application restart racing the previous instance's shutdown - UdpSocket constructor throws (both the IPv4 and IPv6 binds fail) and DhtRunner::run() propagates the exception: the node never starts. In Jami this left every account stuck in the connecting state after a quick restart, with 'DhtException occurred: Can't bind socket' logged per account, and no retry. The persisted port is only a best-effort hint: when binding it fails, retry with OS-assigned ports instead of throwing. The persisted file is then refreshed with the newly bound ports as before. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-07-06 15:44:47 -04:00
Cyrille BéraudandCopilot	139852a531	tests: dhtrunner: cover saved-port fallback Cover starting a node whose persisted port (persist_path + "_port.txt") is already bound by another node, as happens when an application is restarted while the previous instance still holds the socket. The node is expected to start on a fallback port instead of failing. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-07-06 15:44:47 -04:00
Cyrille BéraudandCopilot	3a73ad3aca	value: serialize pushType in JSON The pushType field (`593e59e0`) lets the DHT proxy server tag push notifications with the connection type ("pt" in the FCM payload), so mobile clients can tell incoming calls apart from background noise. It was only serialized in msgpack. Clients using DhtProxyClient send their puts as JSON (Value::toJson()), where the field was silently dropped, and the proxy server parsed the incoming JSON with Value(const Json::Value&), which never read it back. As a result any value put through a proxy (e.g. a call request from a mobile device) reached the recipient's device with an empty "pt", was classified as noise, and did not wake up the callee: calls from proxied devices never rang, while the same call from a full DHT node (desktop) did. Serialize pushType as "pt" in Value::toJson() when set, and parse it back in the JSON constructor, mirroring the msgpack behavior. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-07-04 11:57:49 -04:00
Cyrille BéraudandCopilot	9031cf06c4	tests: value: add pushType JSON round-trip test Cover Value::toJson() / Value(const Json::Value&) preservation of the pushType field, and its absence from the JSON when empty. This is the serialization path used by DhtProxyClient::put(), so mobile clients behind a DHT proxy depend on it to propagate the push notification type. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-07-04 11:57:49 -04:00
dependabot[bot]	7b1369931e	build(deps): bump actions/cache from 5 to 6 Bumps [actions/cache](https://github.com/actions/cache) from 5 to 6. - [Release notes](https://github.com/actions/cache/releases) - [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md) - [Commits](https://github.com/actions/cache/compare/v5...v6) --- updated-dependencies: - dependency-name: actions/cache dependency-version: '6' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2026-06-29 19:15:42 -04:00
dependabot[bot]	64364602d7	build(deps): bump pypa/cibuildwheel from 3.4.1 to 4.1.0 Bumps [pypa/cibuildwheel](https://github.com/pypa/cibuildwheel) from 3.4.1 to 4.1.0. - [Release notes](https://github.com/pypa/cibuildwheel/releases) - [Changelog](https://github.com/pypa/cibuildwheel/blob/main/docs/changelog.md) - [Commits](https://github.com/pypa/cibuildwheel/compare/v3.4.1...v4.1.0) --- updated-dependencies: - dependency-name: pypa/cibuildwheel dependency-version: 4.1.0 dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2026-06-22 10:56:34 -04:00
dependabot[bot]	2dbec3df97	build(deps): bump actions/checkout from 6 to 7 Bumps [actions/checkout](https://github.com/actions/checkout) from 6 to 7. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v6...v7) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: '7' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2026-06-22 10:53:41 -04:00
Adrien Beraud	507e2de3c4	update version to 4.1.0	2026-06-19 00:27:25 -04:00
dependabot[bot]	c37abed715	build(deps): bump https://github.com/microsoft/vcpkg Bumps [https://github.com/microsoft/vcpkg](https://github.com/microsoft/vcpkg) from HEAD to 2026.06.01. This release includes the previously tagged commit. - [Release notes](https://github.com/microsoft/vcpkg/releases) - [Commits](https://github.com/microsoft/vcpkg/compare/66c0373dc7fca549e5803087b9487edfe3aca0a1...f3e10653cc27d62a37a3763cd84b38bca07c6075) --- updated-dependencies: - dependency-name: https://github.com/microsoft/vcpkg dependency-version: 2026.06.01 dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2026-06-19 00:12:50 -04:00
Adrien Beraud	0eb1c33ba5	ci: update vcpkg	2026-06-19 00:10:28 -04:00
Adrien Beraud	45918186a2	ci: update vcpkg	2026-06-19 00:08:20 -04:00
Adrien Beraud	29cb909228	build/meson: base64 requires simdutf	2026-06-18 23:52:24 -04:00
Adrien Beraud	9f6a03bf3d	build/meson: require appropriate dependencies for proxy server	2026-06-18 20:34:45 -04:00
Adrien Beraud	732da0e478	default types: add ValueId to TrustRequest	2026-06-11 16:52:03 -04:00
Adrien Béraud	9a60329f66	proxy server: use token as request url	2026-06-03 20:00:34 -04:00
Adrien Béraud	0bb393ec36	http: allow to build Request by std::string url	2026-06-03 19:30:53 -04:00
vx32	947610003b	http: allow to build Url from std::string, cleanup	2026-06-03 19:14:32 -04:00
Adrien Béraud	dcbe158554	proxy server: allow url-encoded base64 for UnifiedPush	2026-06-03 19:12:40 -04:00
vx32	38e9a7fd61	base64: add support for url-encoded base64	2026-06-03 17:01:19 -04:00