proxy: include priority field in push notification JSON payload

The HTTP Urgency header set on WebPush requests is not exposed to
UnifiedPush Android clients by the connector library. Include a
"priority" field ("high" or "normal") directly in the JSON body
so that clients can determine whether a push notification requires
immediate wake-up processing or can be deferred until the next
natural activity.

This complements the daemon-side priority assignment (Gerrit #34059)
and allows UnifiedPush (F-Droid) builds to benefit from the same
battery savings as FCM builds.

Change-Id: Id316ff89e64e59d1b224f5b4e14da6b36dc62c95
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

.gitignore

@@ -69,3 +69,4 @@ build-*/
 install/
 vcpkg_installed/
 
+jamid.log

CMakeLists.txt

@@ -9,8 +9,8 @@ if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
 
-set (opendht_VERSION_MAJOR 4)
-set (opendht_VERSION_MINOR 0.0)
+set (opendht_VERSION_MAJOR 3)
+set (opendht_VERSION_MINOR 7.9)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")

c/opendht.cpp

@@ -600,7 +600,7 @@ dht_runner_put_signed(
 void
 dht_runner_put_encrypted(dht_runner* r,
                          const dht_infohash* h,
-                         const dht_pkid* to,
+                         const dht_infohash* to,
                          const dht_value* v,
                          dht_done_cb done_cb,
                          void* cb_user_data,
@@ -608,7 +608,7 @@ dht_runner_put_encrypted(dht_runner* r,
 {
     auto runner = reinterpret_cast<dht::DhtRunner*>(r);
     auto hash = reinterpret_cast<const dht::InfoHash*>(h);
-    auto toHash = reinterpret_cast<const dht::PkId*>(to);
+    auto toHash = reinterpret_cast<const dht::InfoHash*>(to);
     auto value = reinterpret_cast<const ValueSp*>(v);
     runner->putEncrypted(
         *hash,

c/opendht_c.h

@@ -195,7 +195,7 @@ OPENDHT_C_PUBLIC void dht_runner_put_signed(dht_runner* runner,
                                             bool permanent);
 OPENDHT_C_PUBLIC void dht_runner_put_encrypted(dht_runner* runner,
                                                const dht_infohash* hash,
-                                               const dht_pkid* to,
+                                               const dht_infohash* to,
                                                const dht_value* value,
                                                dht_done_cb done_cb,
                                                void* cb_user_data,

doc/dhtnode.1

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

include/opendht/callbacks.h

@@ -187,6 +187,8 @@ using ShutdownCallback = std::function<void()>;
 using IdentityAnnouncedCb = std::function<void(bool)>;
 using PublicAddressChangedCb = std::function<void(std::vector<SockAddr>)>;
 
+using CertificateStoreQueryLegacy
+    = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;
 using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const PkId& pk_id)>;
 
 using DoneCallback = std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)>;

include/opendht/dht_proxy_client.h

@@ -429,6 +429,10 @@ private:
     std::unique_ptr<asio::steady_timer> nextProxyConfirmationTimer_;
     std::unique_ptr<asio::steady_timer> listenerRestartTimer_;
 
+    // Exponential backoff for proxy reconnection (1 min → 2 → 4 → ... → 30 min)
+    std::chrono::minutes proxyRetryDelay_ {1};
+    static constexpr std::chrono::minutes MAX_PROXY_RETRY_DELAY {30};
+
     /**
      * Relaunch LISTEN requests if the client disconnect/reconnect.
      */

include/opendht/dhtrunner.h

@@ -61,7 +61,8 @@ public:
         std::unique_ptr<net::DatagramSocket> sock;
         std::shared_ptr<PeerDiscovery> peerDiscovery {};
         StatusCallback statusChangedCallback {};
-        CertificateStoreQuery certificateStore {};
+        CertificateStoreQueryLegacy certificateStore {};
+        CertificateStoreQuery certificateStorePkId {};
         IdentityAnnouncedCb identityAnnouncedCb {};
         PublicAddressChangedCb publicAddressChangedCb {};
         std::unique_ptr<std::mt19937_64> rng {};
@@ -285,6 +286,21 @@ public:
     }
     void putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb = {}, bool permanent = false);
 
+    void putEncrypted(
+        InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb = {}, bool permanent = false);
+    void putEncrypted(
+        InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallbackSimple cb, bool permanent = false)
+    {
+        putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
+    }
+
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb = {}, bool permanent = false);
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallbackSimple cb, bool permanent = false)
+    {
+        putEncrypted(hash, to, std::forward<Value>(value), bindDoneCb(cb), permanent);
+    }
+    void putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb = {}, bool permanent = false);
+
     void putEncrypted(InfoHash hash,
                       const std::shared_ptr<crypto::PublicKey>& to,
                       std::shared_ptr<Value> value,
@@ -299,11 +315,13 @@ public:
         putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
     }
 
+    [[deprecated("Use the shared_ptr version instead")]]
     void putEncrypted(InfoHash hash,
                       const std::shared_ptr<crypto::PublicKey>& to,
                       Value&& value,
                       DoneCallback cb = {},
                       bool permanent = false);
+    [[deprecated("Use the shared_ptr version instead")]]
     void putEncrypted(InfoHash hash,
                       const std::shared_ptr<crypto::PublicKey>& to,
                       Value&& value,
@@ -320,14 +338,6 @@ public:
     {
         putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
     }
-    void putEncrypted(InfoHash hash, const PkId& to, Value&& value, DoneCallback cb = {}, bool permanent = false)
-    {
-        putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
-    }
-    void putEncrypted(InfoHash hash, const PkId& to, Value&& value, DoneCallbackSimple cb, bool permanent = false)
-    {
-        putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), bindDoneCb(cb), permanent);
-    }
 
     /**
      * Insert known nodes to the routing table, without necessarly ping them.
@@ -440,9 +450,13 @@ public:
     void getPublicAddress(std::function<void(std::vector<SockAddr>&&)>, sa_family_t af = AF_UNSPEC);
 
     // securedht methods
+
+    [[deprecated("Use PkId version")]] void findCertificate(
+        InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);
     void findCertificate(PkId hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);
 
     void registerCertificate(const std::shared_ptr<crypto::Certificate>& cert);
+    void setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method);
     void setLocalCertificateStore(CertificateStoreQuery&& query_method);
 
     /**

include/opendht/securedht.h

@@ -113,6 +113,14 @@ public:
      * and put it in the DHT.
      * The operation will be immediate if the recipient' public key is known (otherwise it will be retrived first).
      */
+    void putEncrypted(
+        const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent = false);
+
+    [[deprecated("Use the shared_ptr version instead")]]
+    void putEncrypted(const InfoHash& hash, const InfoHash& to, Value&& v, DoneCallback callback, bool permanent = false)
+    {
+        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
+    }
     void putEncrypted(const InfoHash& hash,
                       const crypto::PublicKey& to,
                       Sp<Value> val,
@@ -137,11 +145,19 @@ public:
 
     Value decrypt(const Value& v);
 
+    [[deprecated("Use PkId version")]] void findCertificate(
+        const InfoHash& node, const std::function<void(const Sp<crypto::Certificate>)>& cb);
+    [[deprecated("Use PkId version")]] void findPublicKey(const InfoHash& node,
+                                                          const std::function<void(const Sp<crypto::PublicKey>)>& cb);
+
     void findCertificate(const PkId& id, const std::function<void(const Sp<crypto::Certificate>)>& cb);
     void findPublicKey(const PkId& id, const std::function<void(const Sp<crypto::PublicKey>)>& cb);
 
     void registerCertificate(const Sp<crypto::Certificate>& cert);
 
+    [[deprecated("Use PkId version")]] Sp<crypto::Certificate> getCertificate(const InfoHash& node) const;
+    [[deprecated("Use PkId version")]] Sp<crypto::PublicKey> getPublicKey(const InfoHash& node) const;
+
     Sp<crypto::Certificate> getCertificate(const PkId& node) const;
     Sp<crypto::PublicKey> getPublicKey(const PkId& node) const;
 
@@ -150,6 +166,10 @@ public:
      * The search key used is the public key ID, so there may be multiple certificates retured, signed with
      * the same private key.
      */
+    void setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method)
+    {
+        localQueryMethodLegacy_ = std::move(query_method);
+    }
     void setLocalCertificateStore(CertificateStoreQuery&& query_method) { localQueryMethod_ = std::move(query_method); }
     void setOnPublicAddressChanged(PublicAddressChangedCb cb) override { dht_->setOnPublicAddressChanged(cb); }
 
@@ -327,10 +347,13 @@ private:
 
     // method to query the local certificate store
     CertificateStoreQuery localQueryMethod_ {};
+    CertificateStoreQueryLegacy localQueryMethodLegacy_ {};
 
     // our certificate cache
-    std::map<PkId, Sp<crypto::Certificate>> nodesCertificates_ {};
-    std::map<PkId, Sp<crypto::PublicKey>> nodesPubKeys_ {};
+    std::map<InfoHash, Sp<crypto::Certificate>> nodesCertificates_ {};
+    std::map<InfoHash, Sp<crypto::PublicKey>> nodesPubKeys_ {};
+    std::map<PkId, Sp<crypto::Certificate>> nodesCertificatesLong_ {};
+    std::map<PkId, Sp<crypto::PublicKey>> nodesPubKeysLong_ {};
 
     std::atomic_bool forward_all_ {false};
     bool enableCache_ {false};

include/opendht/thread_pool.h

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

meson.build

@@ -5,7 +5,7 @@ project(
     'cython',
     license: 'MIT',
     license_files: 'LICENSE',
-    version: '4.0.0',
+    version: '3.7.9',
     meson_version: '>=1.1.0',
     default_options: ['cpp_std=c++20', 'warning_level=3'],
 )

python/CMakeLists.txt

@@ -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

python/opendht.pyx

@@ -820,8 +820,13 @@ cdef class DhtRunner(_WithID):
                         key._infohash, (<PkId>to)._pkid, val._value,
                         cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent
                     )
+                elif isinstance(to, InfoHash):
+                    self.thisptr.get().putEncrypted(
+                        key._infohash, (<InfoHash>to)._infohash, val._value,
+                        cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent
+                    )
                 else:
-                    raise TypeError("'to' must be PublicKey or PkId")
+                    raise TypeError("'to' must be PublicKey, PkId, or InfoHash")
             except:
                 ref.Py_DECREF(cb_obj)
                 raise

python/opendht_cpp.pxd

@@ -282,6 +282,7 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
         void get(InfoHash key, GetCallback get_cb, DoneCallback done_cb, nullptr_t f, Where w)
         void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, time_point created, bool permanent)
         void putSigned(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, bool permanent) 
+        void putEncrypted(InfoHash key, InfoHash to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
         void putEncrypted(InfoHash key, PkId to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
         void putEncrypted(InfoHash key, shared_ptr[PublicKey] to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
         void cancelPut(InfoHash key, shared_ptr[Value] val)

rust/src/dhtrunner.rs

@@ -226,7 +226,7 @@ impl DhtRunner {
     pub fn put_encrypted<'a>(
         &mut self,
         h: &InfoHash,
-        to: &PkId,
+        to: &InfoHash,
         v: Box<Value>,
         done_cb: &'a mut (dyn FnMut(bool)),
         permanent: bool,

rust/src/ffi.rs

@@ -190,7 +190,7 @@ extern {
                                  cb_user_data: *mut c_void,
                                  permanent: bool);
     pub fn dht_runner_put_encrypted(dht: *mut DhtRunner, h: *const InfoHash,
-                                    to: *const PkId, v: *const Value,
+                                    to: *const InfoHash, v: *const Value,
                                     done_cb: extern fn(bool, *mut c_void),
                                     cb_user_data: *mut c_void,
                                     permanent: bool);

src/crypto.cpp

@@ -11,7 +11,6 @@ extern "C" {
 #include <nettle/gcm.h>
 #include <nettle/aes.h>
 #include <nettle/hmac.h>
-#include <nettle/version.h>
 #include <gnutls/crypto.h>
 
 #include <argon2.h>
@@ -99,46 +98,6 @@ private:
 #define GCM_DIGEST_SIZE GCM_BLOCK_SIZE
 #endif
 
-static void
-gcmAes128Digest(gcm_aes128_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes128_digest(ctx, digest);
-#else
-    gcm_aes128_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-gcmAes192Digest(gcm_aes192_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes192_digest(ctx, digest);
-#else
-    gcm_aes192_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-gcmAes256Digest(gcm_aes256_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    gcm_aes256_digest(ctx, digest);
-#else
-    gcm_aes256_digest(ctx, GCM_DIGEST_SIZE, digest);
-#endif
-}
-
-static void
-hmacSha256Digest(hmac_sha256_ctx* ctx, uint8_t* digest)
-{
-#if NETTLE_VERSION_MAJOR >= 4
-    hmac_sha256_digest(ctx, digest);
-#else
-    hmac_sha256_digest(ctx, SHA256_DIGEST_SIZE, digest);
-#endif
-}
-
 Blob
 aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
 {
@@ -156,19 +115,19 @@ aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
         gcm_aes128_set_key(&aes, key.data());
         gcm_aes128_set_iv(&aes, GCM_IV_SIZE, ret.data());
         gcm_aes128_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes128Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
     } else if (key.size() == AES_LENGTHS[1]) {
         struct gcm_aes192_ctx aes;
         gcm_aes192_set_key(&aes, key.data());
         gcm_aes192_set_iv(&aes, GCM_IV_SIZE, ret.data());
         gcm_aes192_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes192Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
     } else if (key.size() == AES_LENGTHS[2]) {
         struct gcm_aes256_ctx aes;
         gcm_aes256_set_key(&aes, key.data());
         gcm_aes256_set_iv(&aes, GCM_IV_SIZE, ret.data());
         gcm_aes256_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcmAes256Digest(&aes, ret.data() + GCM_IV_SIZE + data_length);
+        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
     }
 
     return ret;
@@ -201,19 +160,19 @@ aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key)
         gcm_aes128_set_key(&aes, key.data());
         gcm_aes128_set_iv(&aes, GCM_IV_SIZE, data);
         gcm_aes128_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes128Digest(&aes, digest.data());
+        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, digest.data());
     } else if (key.size() == AES_LENGTHS[1]) {
         struct gcm_aes192_ctx aes;
         gcm_aes192_set_key(&aes, key.data());
         gcm_aes192_set_iv(&aes, GCM_IV_SIZE, data);
         gcm_aes192_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes192Digest(&aes, digest.data());
+        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, digest.data());
     } else if (key.size() == AES_LENGTHS[2]) {
         struct gcm_aes256_ctx aes;
         gcm_aes256_set_key(&aes, key.data());
         gcm_aes256_set_iv(&aes, GCM_IV_SIZE, data);
         gcm_aes256_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcmAes256Digest(&aes, digest.data());
+        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, digest.data());
     }
 
     if (not std::equal(digest.begin(), digest.end(), data + data_length - GCM_DIGEST_SIZE)) {
@@ -2086,7 +2045,7 @@ hkdf_extract(const Blob& salt, const Blob& ikm)
     hmac_sha256_set_key(&ctx, salt.size(), salt.data());
     hmac_sha256_update(&ctx, ikm.size(), ikm.data());
     Blob prk(SHA256_DIGEST_SIZE);
-    hmacSha256Digest(&ctx, prk.data());
+    hmac_sha256_digest(&ctx, SHA256_DIGEST_SIZE, prk.data());
     return prk;
 }
 
@@ -2104,7 +2063,7 @@ hkdf_expand(const Blob& prk, const uint8_t* info, size_t info_len, size_t len)
         hmac_sha256_update(&ctx, info_len, info);
         hmac_sha256_update(&ctx, 1, &i);
         T.resize(SHA256_DIGEST_SIZE);
-        hmacSha256Digest(&ctx, T.data());
+        hmac_sha256_digest(&ctx, SHA256_DIGEST_SIZE, T.data());
         okm.insert(okm.end(), T.begin(), T.end());
         i++;
     }
@@ -2264,7 +2223,7 @@ webPushEncrypt(const Blob& p256dh,
 
     Blob ciphertext(plaintext.size() + GCM_DIGEST_SIZE);
     gcm_aes128_encrypt(&aes, plaintext.size(), ciphertext.data(), plaintext.data());
-    gcmAes128Digest(&aes, ciphertext.data() + plaintext.size());
+    gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, ciphertext.data() + plaintext.size());
 
     // 6. Construct Output
     Blob output;

src/dht_proxy_client.cpp

@@ -782,7 +782,10 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
     if (newStatus == NodeStatus::Connected) {
         if (oldStatus == NodeStatus::Disconnected || oldStatus == NodeStatus::Connecting || launchConnectedCbs_) {
             launchConnectedCbs_ = false;
-            listenerRestartTimer_->expires_at(std::chrono::steady_clock::now());
+            // Small random delay (0-2s) to avoid resubscription burst
+            auto jitter = std::chrono::milliseconds(
+                std::rand() % 2000);
+            listenerRestartTimer_->expires_at(std::chrono::steady_clock::now() + jitter);
             listenerRestartTimer_->async_wait(std::bind(&DhtProxyClient::restartListeners, this, std::placeholders::_1));
             if (not onConnectCallbacks_.empty()) {
                 std::lock_guard lock(lockCallbacks_);
@@ -794,11 +797,18 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
                 });
             }
         }
+        // Reset backoff on successful connection
+        proxyRetryDelay_ = std::chrono::minutes(1);
         nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + std::chrono::minutes(15));
         nextProxyConfirmationTimer_->async_wait(
             std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
     } else if (newStatus == NodeStatus::Disconnected) {
-        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + std::chrono::minutes(1));
+        // Exponential backoff: 1 → 2 → 4 → 8 → 16 → 30 min (capped)
+        auto delay = proxyRetryDelay_;
+        proxyRetryDelay_ = std::min(proxyRetryDelay_ * 2, MAX_PROXY_RETRY_DELAY);
+        if (logger_)
+            logger_->warn("[proxy:client] disconnected, retrying in {} min", delay.count());
+        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + delay);
         nextProxyConfirmationTimer_->async_wait(
             std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
     }
@@ -1166,6 +1176,8 @@ DhtProxyClient::getConnectivityStatus()
 {
     if (logger_)
         logger_->d("[proxy:client] [connectivity] get status");
+    // Reset backoff on explicit connectivity change (e.g., WiFi/cellular switch)
+    proxyRetryDelay_ = std::chrono::minutes(1);
     if (!isDestroying_)
         getProxyInfos();
 }

src/dht_proxy_server.cpp

@@ -594,8 +594,10 @@ DhtProxyServer::addServerSettings(ServerSettings& settings, const unsigned int m
     settings.logger(logger_);
     settings.protocol(restinio::asio_ns::ip::tcp::v6());
     settings.request_handler(createRestRouter());
-    // time limits                                              // ~ 0.8 month
-    std::chrono::milliseconds timeout_request(std::numeric_limits<int>::max());
+    // time limits
+    // Use 1-hour timeout for idle connections so that dead mobile clients
+    // are cleaned up promptly instead of lingering for ~24 days.
+    constexpr auto timeout_request = std::chrono::hours(1);
     settings.read_next_http_message_timelimit(timeout_request);
     settings.write_http_response_timelimit(60s);
     settings.handle_request_timeout(timeout_request);
@@ -1189,7 +1191,13 @@ DhtProxyServer::handlePushListen(const InfoHash& infoHash,
                        minPriority,
                        values.size());
 
-    sendPushNotification(pushToken, std::move(json), type, !expired and minPriority == 0, topic);
+    // Include priority in the JSON payload so that UnifiedPush clients
+    // (which don't have access to the HTTP Urgency header) can determine
+    // whether a push requires immediate processing or can be deferred.
+    bool highPriority = !expired and minPriority == 0;
+    json["priority"] = highPriority ? "high" : "normal";
+
+    sendPushNotification(pushToken, std::move(json), type, highPriority, topic);
 
     return true;
 }

src/dhtrunner.cpp

@@ -186,6 +186,9 @@ DhtRunner::run(const Config& config, Context&& context)
     if (context.certificateStore) {
         dht_->setLocalCertificateStore(std::move(context.certificateStore));
     }
+    if (context.certificateStorePkId) {
+        dht_->setLocalCertificateStore(std::move(context.certificateStorePkId));
+    }
     if (context.publicAddressChangedCb) {
         dht_->setOnPublicAddressChanged(std::move(context.publicAddressChangedCb));
     }
@@ -664,6 +667,14 @@ DhtRunner::registerCertificate(const std::shared_ptr<crypto::Certificate>& cert)
     dht_->registerCertificate(cert);
 }
 
+void
+DhtRunner::setLocalCertificateStore(CertificateStoreQueryLegacy&& query_method)
+{
+    std::lock_guard lck(dht_mtx);
+    if (dht_)
+        dht_->setLocalCertificateStore(std::forward<CertificateStoreQueryLegacy>(query_method));
+}
+
 void
 DhtRunner::setLocalCertificateStore(CertificateStoreQuery&& query_method)
 {
@@ -944,6 +955,35 @@ DhtRunner::putEncrypted(InfoHash hash, const PkId& to, std::shared_ptr<Value> va
     cv.notify_all();
 }
 
+void
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
+{
+    std::unique_lock lck(storage_mtx);
+    if (running != State::Running) {
+        lck.unlock();
+        if (cb)
+            cb(false, {});
+        return;
+    }
+    ongoing_ops++;
+    pending_ops.emplace([=, cb = std::move(cb), value = std::move(value)](SecureDht& dht) mutable {
+        dht.putEncrypted(hash, to, value, bindOpDoneCallback(std::move(cb)), permanent);
+    });
+    cv.notify_all();
+}
+
+void
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb, bool permanent)
+{
+    putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
+}
+
+void
+DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb, bool permanent)
+{
+    putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), std::move(cb), permanent);
+}
+
 void
 DhtRunner::putEncrypted(InfoHash hash,
                         const std::shared_ptr<crypto::PublicKey>& to,
@@ -1079,6 +1119,25 @@ DhtRunner::connectivityChanged()
     cv.notify_all();
 }
 
+void
+DhtRunner::findCertificate(InfoHash hash, std::function<void(const Sp<crypto::Certificate>&)> cb)
+{
+    std::unique_lock lck(storage_mtx);
+    if (running != State::Running) {
+        lck.unlock();
+        cb({});
+        return;
+    }
+    ongoing_ops++;
+    pending_ops.emplace([this, hash, cb = std::move(cb)](SecureDht& dht) {
+        dht.findCertificate(hash, [this, cb = std::move(cb)](const Sp<crypto::Certificate>& crt) {
+            cb(crt);
+            opEnded();
+        });
+    });
+    cv.notify_all();
+}
+
 void
 DhtRunner::findCertificate(PkId hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)> cb)
 {

src/securedht.cpp

@@ -96,13 +96,37 @@ SecureDht::secureType(ValueType&& type)
     return type;
 }
 
+Sp<crypto::Certificate>
+SecureDht::getCertificate(const InfoHash& node) const
+{
+    if (node == getId())
+        return certificate_;
+    auto it = nodesCertificates_.find(node);
+    if (it == nodesCertificates_.end())
+        return nullptr;
+    else
+        return it->second;
+}
+
+Sp<crypto::PublicKey>
+SecureDht::getPublicKey(const InfoHash& node) const
+{
+    if (node == getId())
+        return certificate_->getSharedPublicKey();
+    auto it = nodesPubKeys_.find(node);
+    if (it == nodesPubKeys_.end())
+        return nullptr;
+    else
+        return it->second;
+}
+
 Sp<crypto::Certificate>
 SecureDht::getCertificate(const PkId& node) const
 {
     if (node == getLongId())
         return certificate_;
-    auto it = nodesCertificates_.find(node);
-    if (it == nodesCertificates_.end())
+    auto it = nodesCertificatesLong_.find(node);
+    if (it == nodesCertificatesLong_.end())
         return nullptr;
     else
         return it->second;
@@ -113,8 +137,8 @@ SecureDht::getPublicKey(const PkId& node) const
 {
     if (node == getLongId())
         return certificate_->getSharedPublicKey();
-    auto it = nodesPubKeys_.find(node);
-    if (it == nodesPubKeys_.end())
+    auto it = nodesPubKeysLong_.find(node);
+    if (it == nodesPubKeysLong_.end())
         return nullptr;
     else
         return it->second;
@@ -167,10 +191,85 @@ void
 SecureDht::registerCertificate(const Sp<crypto::Certificate>& cert)
 {
     if (cert) {
-        nodesCertificates_[cert->getLongId()] = cert;
+        nodesCertificates_[cert->getId()] = cert;
+        nodesCertificatesLong_[cert->getLongId()] = cert;
     }
 }
 
+void
+SecureDht::findCertificate(const InfoHash& node, const std::function<void(const Sp<crypto::Certificate>)>& cb)
+{
+    Sp<crypto::Certificate> b = getCertificate(node);
+    if (b && *b) {
+        if (logger_)
+            logger_->debug("Using certificate from cache for {}", node.toString());
+        if (cb)
+            cb(b);
+        return;
+    }
+    if (localQueryMethodLegacy_) {
+        auto res = localQueryMethodLegacy_(node);
+        if (not res.empty()) {
+            if (logger_)
+                logger_->debug("Registering certificate from local store for {}", node.toString());
+            nodesCertificates_.emplace(node, res.front());
+            nodesCertificatesLong_.emplace(res.front()->getLongId(), res.front());
+            if (cb)
+                cb(res.front());
+            return;
+        }
+    }
+
+    auto found = std::make_shared<bool>(false);
+    dht_->get(
+        node,
+        [cb, node, found, this](const std::vector<Sp<Value>>& vals) {
+            for (const auto& v : vals) {
+                if (auto cert = registerCertificate(node, v->data)) {
+                    *found = true;
+                    if (logger_)
+                        logger_->debug("Found certificate for {}", node.toString());
+                    if (cb)
+                        cb(cert);
+                    return false;
+                }
+            }
+            return !*found;
+        },
+        [cb, found](bool) {
+            if (!*found and cb)
+                cb(nullptr);
+        },
+        Value::TypeFilter(CERTIFICATE_TYPE));
+}
+
+void
+SecureDht::findPublicKey(const InfoHash& node, const std::function<void(const Sp<crypto::PublicKey>)>& cb)
+{
+    auto pk = getPublicKey(node);
+    if (pk && *pk) {
+        if (logger_)
+            logger_->debug("Found public key from cache for {}", node.toString());
+        if (cb)
+            cb(pk);
+        return;
+    }
+    findCertificate(node, [=](const Sp<crypto::Certificate>& crt) {
+        if (crt && *crt) {
+            auto pk = crt->getSharedPublicKey();
+            if (*pk) {
+                nodesPubKeys_[pk->getId()] = pk;
+                nodesPubKeysLong_[pk->getLongId()] = pk;
+                if (cb)
+                    cb(pk);
+                return;
+            }
+        }
+        if (cb)
+            cb(nullptr);
+    });
+}
+
 void
 SecureDht::findCertificate(const PkId& node, const std::function<void(const Sp<crypto::Certificate>)>& cb)
 {
@@ -188,7 +287,8 @@ SecureDht::findCertificate(const PkId& node, const std::function<void(const Sp<c
         if (not res.empty()) {
             if (logger_)
                 logger_->debug("Registering certificate from local store for {}", node.to_c_str());
-            nodesCertificates_.emplace(node, res.front());
+            nodesCertificates_.emplace(res.front()->getId(), res.front());
+            nodesCertificatesLong_.emplace(node, res.front());
             if (cb)
                 cb(res.front());
             return;
@@ -233,7 +333,8 @@ SecureDht::findPublicKey(const PkId& node, const std::function<void(const Sp<cry
         if (crt && *crt) {
             auto pk = crt->getSharedPublicKey();
             if (*pk) {
-                nodesPubKeys_[pk->getLongId()] = pk;
+                nodesPubKeys_[pk->getId()] = pk;
+                nodesPubKeysLong_[pk->getLongId()] = pk;
                 if (cb)
                     cb(pk);
                 return;
@@ -261,7 +362,8 @@ SecureDht::checkValue(const Sp<Value>& v)
             if (auto decrypted_val = v->decrypt(*key_)) {
                 auto cacheValue = not isDecrypted and decrypted_val->owner;
                 if (cacheValue) {
-                    nodesPubKeys_[decrypted_val->owner->getLongId()] = decrypted_val->owner;
+                    nodesPubKeys_[decrypted_val->owner->getId()] = decrypted_val->owner;
+                    nodesPubKeysLong_[decrypted_val->owner->getLongId()] = decrypted_val->owner;
                 }
                 return decrypted_val;
             }
@@ -275,7 +377,8 @@ SecureDht::checkValue(const Sp<Value>& v)
         auto cacheValue = not v->isSignatureChecked() and enableCache_ and v->owner;
         if (v->checkSignature()) {
             if (cacheValue) {
-                nodesPubKeys_[v->owner->getLongId()] = v->owner;
+                nodesPubKeys_[v->owner->getId()] = v->owner;
+                nodesPubKeysLong_[v->owner->getLongId()] = v->owner;
             }
             return v;
         } else if (logger_)
@@ -389,6 +492,35 @@ SecureDht::putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback,
         Where().id(val->id));
 }
 
+void
+SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent)
+{
+    if (not key_) {
+        if (callback)
+            callback(false, {});
+        return;
+    }
+    findPublicKey(to,
+                  [this, hash, val = std::move(val), callback = std::move(callback), permanent](
+                      const Sp<crypto::PublicKey>& pk) {
+                      if (!pk || !*pk) {
+                          if (callback)
+                              callback(false, {});
+                          return;
+                      }
+                      if (logger_)
+                          logger_->warn("Encrypting data for PK: {}", pk->getId().toString());
+                      try {
+                          dht_->put(hash, encrypt(*val, *pk), callback, time_point::max(), permanent);
+                      } catch (const std::exception& e) {
+                          if (logger_)
+                              logger_->error("Error putting encrypted data: {}", e.what());
+                          if (callback)
+                              callback(false, {});
+                      }
+                  });
+}
+
 void
 SecureDht::putEncrypted(const InfoHash& hash, const PkId& to, Sp<Value> val, DoneCallback callback, bool permanent)
 {

src/thread_pool.cpp

@@ -78,8 +78,6 @@ ThreadPool::run(std::function<void()>&& cb)
                             break;
                         task = std::move(tasks_.front());
                         tasks_.pop();
-                        if (tasks_.empty() && stopping_)
-                            stopCv_.notify_one();
                     }
 
                     // run task
@@ -137,9 +135,7 @@ ThreadPool::stop(bool wait)
 {
     std::unique_lock l(lock_);
     if (wait) {
-        stopping_ = true;
-        stopCv_.wait(l, [&]() { return tasks_.empty(); });
-        stopping_ = false;
+        cv_.wait(l, [&]() { return tasks_.empty(); });
     }
     running_ = false;
     tasks_ = {};

tests/test_threadpool.cpp

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

tests/test_threadpool.h

@@ -14,7 +14,6 @@ class ThreadPoolTester : public CppUnit::TestFixture
     CPPUNIT_TEST(testThreadPool);
     CPPUNIT_TEST(testExecutor);
     CPPUNIT_TEST(testContext);
-    CPPUNIT_TEST(testJoinNonEmptyTaskQueue);
     CPPUNIT_TEST_SUITE_END();
 
 public:
@@ -30,7 +29,6 @@ public:
     void testThreadPool();
     void testExecutor();
     void testContext();
-    void testJoinNonEmptyTaskQueue();
 };
 
 } // namespace test

tools/dhtchat.cpp

@@ -123,7 +123,7 @@ main(int argc, char** argv)
                     iss >> idstr;
                     std::getline(iss, line);
                     dht.putEncrypted(room,
-                                     PkId(idstr),
+                                     InfoHash(idstr),
                                      dht::ImMessage(IdDist()(tools::rd), std::move(line), now),
                                      [](bool ok) {
                                          // dht.cancelPut(room, id);

tools/dhtnode.cpp

@@ -481,7 +481,7 @@ cmd_loop(std::shared_ptr<DhtRunner>& node,
             auto value = std::make_shared<dht::Value>(dht::ValueType::USER_DATA.id,
                                                       std::vector<uint8_t> {v.begin(), v.end()});
             value->user_type = "text/plain";
-            node->putEncrypted(id, PkId(tostr), std::move(value), [start](bool ok) {
+            node->putEncrypted(id, InfoHash(tostr), std::move(value), [start](bool ok) {
                 auto end = std::chrono::high_resolution_clock::now();
                 std::cout << "Put encrypted: " << (ok ? "success" : "failure") << " (took "
                           << print_duration(end - start) << ')' << std::endl;

vcpkg.json

@@ -1,6 +1,6 @@
 {
   "name": "opendht",
-  "version-string": "4.0.0",
+  "version-string": "3.7.9",
   "port-version": 1,
   "description": "OpenDHT: A lightweight C++17 Distributed Hash Table library.",
   "homepage": "https://opendht.net",