fix

Signed-off-by: zhengfish <zhengfish@gmail.com>

.github/workflows/ccpp.yml

@@ -0,0 +1,27 @@
+name: C/C++ CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name: deps
+      run: |
+        sudo apt install libncurses5-dev libreadline-dev nettle-dev \
+        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
+        autotools-dev autoconf libasio-dev libfmt-dev libhttp-parser-dev libmsgpack-dev
+    - name: autogen
+      run: ./autogen.sh
+    - name: argon2
+      run: |
+        cd argon2 && make && sudo make install && cd ..
+    - name: configure
+      run: ./configure
+    - name: make
+      run: make
+    - name: make check
+      run: make check

CMakeLists.txt

@@ -95,6 +95,7 @@ if (OPENDHT_SANITIZE)
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fstack-protector-strong")
 endif ()
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")
+
 if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
 endif ()
@@ -362,39 +363,39 @@ install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendhtConfigVersion.cmake DESTINATIO
 
 # Unit tests
 if (OPENDHT_TESTS)
-  FIND_PACKAGE(Cppunit REQUIRED)
-  # unit testing
+    FIND_PACKAGE(Cppunit REQUIRED)
+    # unit testing
     list (APPEND test_FILES
-      tests/infohashtester.h
-      tests/infohashtester.cpp
-      tests/valuetester.h
-      tests/valuetester.cpp
-      tests/cryptotester.h
-      tests/cryptotester.cpp
-      tests/dhtrunnertester.h
-      tests/dhtrunnertester.cpp
-      tests/peerdiscoverytester.h
-      tests/peerdiscoverytester.cpp
-      tests/threadpooltester.h
-      tests/threadpooltester.cpp
+        tests/infohashtester.h
+        tests/infohashtester.cpp
+        tests/valuetester.h
+        tests/valuetester.cpp
+        tests/cryptotester.h
+        tests/cryptotester.cpp
+        tests/dhtrunnertester.h
+        tests/dhtrunnertester.cpp
+        tests/peerdiscoverytester.h
+        tests/peerdiscoverytester.cpp
+        tests/threadpooltester.h
+        tests/threadpooltester.cpp
     )
     if (OPENDHT_PROXY_SERVER AND OPENDHT_PROXY_CLIENT)
-      list (APPEND test_FILES
-        tests/httptester.h
-        tests/httptester.cpp
-        tests/dhtproxytester.h
-        tests/dhtproxytester.cpp
-      )
+        list (APPEND test_FILES
+            tests/httptester.h
+            tests/httptester.cpp
+            tests/dhtproxytester.h
+            tests/dhtproxytester.cpp
+        )
     endif()
     add_executable(opendht_unit_tests
-      tests/tests_runner.cpp
-      ${test_FILES}
+        tests/tests_runner.cpp
+        ${test_FILES}
     )
     target_include_directories(opendht_unit_tests SYSTEM PRIVATE ${CPPUNIT_INCLUDE_DIRS})
     if (OPENDHT_SHARED)
-      target_link_libraries(opendht_unit_tests opendht)
+        target_link_libraries(opendht_unit_tests opendht)
     else ()
-      target_link_libraries(opendht_unit_tests opendht-static)
+        target_link_libraries(opendht_unit_tests opendht-static)
     endif ()
     target_link_libraries(opendht_unit_tests
        ${CMAKE_THREAD_LIBS_INIT}

Makefile.am

@@ -16,9 +16,7 @@ if ENABLE_TESTS
 SUBDIRS += tests
 endif
 
-if HAVE_DOXYGEN
 SUBDIRS += doc
-endif
 
 ACLOCAL_AMFLAGS = -I m4
 

c/opendht.cpp

@@ -3,6 +3,7 @@
 
 using ValueSp = std::shared_ptr<dht::Value>;
 using PrivkeySp = std::shared_ptr<dht::crypto::PrivateKey>;
+using PubkeySp = std::shared_ptr<const dht::crypto::PublicKey>;
 using CertSp = std::shared_ptr<dht::crypto::Certificate>;
 
 #ifdef __cplusplus
@@ -10,6 +11,19 @@ extern "C" {
 #endif
 
 // dht::InfoHash
+
+inline dht_infohash dht_infohash_to_c(const dht::InfoHash& h) {
+    dht_infohash ret;
+    *reinterpret_cast<dht::InfoHash*>(&ret) = h;
+    return ret;
+}
+
+inline dht_pkid dht_pkid_to_c(const dht::PkId& h) {
+    dht_pkid ret;
+    *reinterpret_cast<dht::PkId*>(&ret) = h;
+    return ret;
+}
+
 const char* dht_infohash_print(const dht_infohash* h) {
     return reinterpret_cast<const dht::InfoHash*>(h)->to_c_str();
 }
@@ -26,10 +40,18 @@ void dht_infohash_get(dht_infohash* h, const uint8_t* dat, size_t dat_size) {
     *reinterpret_cast<dht::InfoHash*>(h) = dht::InfoHash::get(dat, dat_size);
 }
 
+void dht_infohash_get_from_string(dht_infohash* h, const char* dat) {
+    *reinterpret_cast<dht::InfoHash*>(h) = dht::InfoHash::get((const uint8_t*)dat, (size_t)strlen(dat));
+}
+
 bool dht_infohash_is_zero(const dht_infohash* h) {
     return !static_cast<bool>(*reinterpret_cast<const dht::InfoHash*>(h));
 }
 
+void dht_infohash_from_hex(dht_infohash* h, const char* dat) {
+    *h = dht_infohash_to_c(dht::InfoHash(std::string(dat, HASH_LEN*2)));
+}
+
 const char* dht_pkid_print(const dht_pkid* h) {
     return reinterpret_cast<const dht::PkId*>(h)->to_c_str();
 }
@@ -60,6 +82,21 @@ dht_value_id dht_value_get_id(const dht_value* data) {
     return vsp->id;
 }
 
+dht_publickey* dht_value_get_owner(const dht_value* data) {
+    const ValueSp& vsp(*reinterpret_cast<const ValueSp*>(data));
+    return vsp->owner ? reinterpret_cast<dht_publickey*>(new PubkeySp(vsp->owner)) : nullptr;
+}
+
+dht_infohash dht_value_get_recipient(const dht_value* data) {
+    const ValueSp& vsp(*reinterpret_cast<const ValueSp*>(data));
+    return dht_infohash_to_c(vsp->recipient);
+}
+
+const char* dht_value_get_user_type(const dht_value* data) {
+    const ValueSp& vsp(*reinterpret_cast<const ValueSp*>(data));
+    return vsp->user_type.c_str();
+}
+
 dht_value* dht_value_new(const uint8_t* data, size_t size) {
     return reinterpret_cast<dht_value*>(new ValueSp(std::make_shared<dht::Value>(data, size)));
 }
@@ -73,51 +110,46 @@ void dht_value_unref(dht_value* v) {
 }
 
 // dht::crypto::PublicKey
-dht_publickey* dht_publickey_new() {
-    return reinterpret_cast<dht_publickey*>(new dht::crypto::PublicKey);
+dht_publickey* dht_publickey_import(const uint8_t* dat, size_t dat_size) {
+    try {
+        return reinterpret_cast<dht_publickey*>(new PubkeySp(std::make_shared<const dht::crypto::PublicKey>(dat, dat_size)));
+    } catch (const dht::crypto::CryptoException& e) {
+        return nullptr;
+    }
 }
 
 void dht_publickey_delete(dht_publickey* pk) {
-    delete reinterpret_cast<dht::crypto::PublicKey*>(pk);
-}
-
-int dht_publickey_unpack(dht_publickey* pk, const uint8_t* dat, size_t dat_size) {
-    try {
-        reinterpret_cast<dht::crypto::PublicKey*>(pk)->unpack(dat, dat_size);
-    } catch (const dht::crypto::CryptoException& e) {
-        return -1;
-    }
-    return 0;
+    delete reinterpret_cast<PubkeySp*>(pk);
 }
 
 int dht_publickey_pack(dht_publickey* pk, char* out, size_t* outlen) {
-    return gnutls_pubkey_export(reinterpret_cast<dht::crypto::PublicKey*>(pk)->pk, GNUTLS_X509_FMT_DER, out, outlen);
+    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
+    return gnutls_pubkey_export(pkey->pk, GNUTLS_X509_FMT_DER, out, outlen);
 }
 
 dht_infohash dht_publickey_get_id(const dht_publickey* pk) {
-    auto pkey = reinterpret_cast<const dht::crypto::PublicKey*>(pk);
-    dht_infohash h;
-    *reinterpret_cast<dht::InfoHash*>(&h) = pkey->getId();
-    return h;
+    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
+    return dht_infohash_to_c(pkey->getId());
 }
 
 dht_pkid dht_publickey_get_long_id(const dht_publickey* pk) {
-    auto pkey = reinterpret_cast<const dht::crypto::PublicKey*>(pk);
-    dht_pkid h;
-    *reinterpret_cast<dht::PkId*>(&h) = pkey->getLongId();
-    return h;
+    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
+    return dht_pkid_to_c(pkey->getLongId());
 }
 
 bool dht_publickey_check_signature(const dht_publickey* pk, const char* data, size_t data_size, const char* signature, size_t signature_size) {
-    return reinterpret_cast<const dht::crypto::PublicKey*>(pk)->checkSignature((const uint8_t*)data, data_size, (const uint8_t*)signature, signature_size);
+    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
+    return pkey->checkSignature((const uint8_t*)data, data_size, (const uint8_t*)signature, signature_size);
 }
 
 dht_blob* dht_publickey_encrypt(const dht_publickey* pk, const char* data, size_t data_size) {
+    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
     auto rdata = new dht::Blob;
-    *rdata = reinterpret_cast<const dht::crypto::PublicKey*>(pk)->encrypt((const uint8_t*)data, data_size);
+    *rdata = pkey->encrypt((const uint8_t*)data, data_size);
     return (dht_blob*)rdata;
 }
 
+// dht::crypto::PrivateKey
 dht_privatekey* dht_privatekey_generate(unsigned key_length_bits) {
     if (key_length_bits == 0)
         key_length_bits = 4096;
@@ -134,13 +166,73 @@ dht_privatekey* dht_privatekey_import(const uint8_t* dat, size_t dat_size, const
 
 dht_publickey* dht_privatekey_get_publickey(const dht_privatekey* k) {
     const auto& key = *reinterpret_cast<const PrivkeySp*>(k);
-    return reinterpret_cast<dht_publickey*>(new dht::crypto::PublicKey(key->getPublicKey()));
+    return reinterpret_cast<dht_publickey*>(new PubkeySp(std::make_shared<dht::crypto::PublicKey>(key->getPublicKey())));
 }
 
 void dht_privatekey_delete(dht_privatekey* pk) {
     delete reinterpret_cast<PrivkeySp*>(pk);
 }
 
+// dht::crypto::Certificate
+dht_certificate* dht_certificate_import(const uint8_t* dat, size_t dat_size) {
+    try {
+        return reinterpret_cast<dht_certificate*>(new CertSp(std::make_shared<dht::crypto::Certificate>(dat, dat_size)));
+    } catch (const dht::crypto::CryptoException& e) {
+        return nullptr;
+    }
+}
+
+void dht_certificate_delete(dht_certificate* c) {
+    delete reinterpret_cast<CertSp*>(c);
+}
+
+dht_infohash dht_certificate_get_id(const dht_certificate* c) {
+    const auto& cert = *reinterpret_cast<const CertSp*>(c);
+    return dht_infohash_to_c(cert->getId());
+}
+
+dht_pkid dht_certificate_get_long_id(const dht_certificate* c) {
+    const auto& cert = *reinterpret_cast<const CertSp*>(c);
+    return dht_pkid_to_c(cert->getLongId());
+}
+
+dht_publickey* dht_certificate_get_publickey(const dht_certificate* c) {
+    const auto& cert = *reinterpret_cast<const CertSp*>(c);
+    return reinterpret_cast<dht_publickey*>(new PubkeySp(std::make_shared<dht::crypto::PublicKey>(cert->getPublicKey())));
+}
+
+// dht::crypto::Identity
+inline dht::crypto::Identity dht_identity_from_c(const dht_identity* cid) {
+    dht::crypto::Identity id {};
+    if (cid and cid->privatekey)
+        id.first = *reinterpret_cast<const PrivkeySp*>(cid->privatekey);
+    if (cid and cid->certificate)
+        id.second = *reinterpret_cast<const CertSp*>(cid->certificate);
+    return id;
+}
+
+inline dht_identity dht_identity_to_c(const dht::crypto::Identity& id) {
+    dht_identity cid {};
+    cid.privatekey = id.first ? reinterpret_cast<dht_privatekey*>(new PrivkeySp(id.first)) : NULL;
+    cid.certificate = id.second ? reinterpret_cast<dht_certificate*>(new CertSp(id.second)) : NULL;
+    return cid;
+}
+
+OPENDHT_C_PUBLIC dht_identity dht_identity_generate(const char* common_name, const dht_identity* ca) {
+    return dht_identity_to_c(dht::crypto::generateIdentity(common_name, dht_identity_from_c(ca)));
+}
+
+OPENDHT_C_PUBLIC void dht_identity_delete(dht_identity* id) {
+    if (id->certificate) {
+        dht_certificate_delete(id->certificate);
+        id->certificate = NULL;
+    }
+    if (id->privatekey) {
+        dht_privatekey_delete(id->privatekey);
+        id->privatekey = NULL;
+    }
+}
+
 // config
 void dht_runner_config_default(dht_runner_config* config) {
     bzero(config, sizeof(dht_runner_config));
@@ -171,8 +263,8 @@ void dht_runner_run_config(dht_runner* r, in_port_t port, const dht_runner_confi
     config.dht_config.node_config.persist_path = conf->dht_config.node_config.persist_path
         ? std::string(conf->dht_config.node_config.persist_path) : std::string{};
 
-    if (conf->dht_config.id.privkey)
-        config.dht_config.id.first = *reinterpret_cast<const PrivkeySp*>(conf->dht_config.id.privkey);
+    if (conf->dht_config.id.privatekey)
+        config.dht_config.id.first = *reinterpret_cast<const PrivkeySp*>(conf->dht_config.id.privatekey);
 
     if (conf->dht_config.id.certificate)
         config.dht_config.id.second = *reinterpret_cast<const CertSp*>(conf->dht_config.id.certificate);
@@ -249,24 +341,35 @@ void dht_op_token_delete(dht_op_token* token) {
     delete reinterpret_cast<std::future<size_t>*>(token);
 }
 
-void dht_runner_put(dht_runner* r, const dht_infohash* h, const dht_value* v, dht_done_cb done_cb, void* cb_user_data) {
+void dht_runner_put(dht_runner* r, const dht_infohash* h, const dht_value* v, dht_done_cb done_cb, void* cb_user_data, bool permanent) {
     auto runner = reinterpret_cast<dht::DhtRunner*>(r);
     auto hash = reinterpret_cast<const dht::InfoHash*>(h);
     auto value = reinterpret_cast<const ValueSp*>(v);
     runner->put(*hash, *value, [done_cb, cb_user_data](bool ok){
         if (done_cb)
             done_cb(ok, cb_user_data);
-    });
+    }, dht::time_point::max(), permanent);
 }
 
-void dht_runner_put_permanent(dht_runner* r, const dht_infohash* h, const dht_value* v, dht_done_cb done_cb, void* cb_user_data) {
+void dht_runner_put_signed(dht_runner* r, const dht_infohash* h, const dht_value* v, dht_done_cb done_cb, void* cb_user_data, bool permanent) {
     auto runner = reinterpret_cast<dht::DhtRunner*>(r);
     auto hash = reinterpret_cast<const dht::InfoHash*>(h);
     auto value = reinterpret_cast<const ValueSp*>(v);
-    runner->put(*hash, *value, [done_cb, cb_user_data](bool ok){
+    runner->putSigned(*hash, *value, [done_cb, cb_user_data](bool ok){
         if (done_cb)
             done_cb(ok, cb_user_data);
-    }, dht::time_point::max(), true);
+    }, permanent);
+}
+
+void dht_runner_put_encrypted(dht_runner* r, const dht_infohash* h, const dht_infohash* to, const dht_value* v, dht_done_cb done_cb, void* cb_user_data, bool permanent) {
+    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
+    auto hash = reinterpret_cast<const dht::InfoHash*>(h);
+    auto toHash = reinterpret_cast<const dht::InfoHash*>(to);
+    auto value = reinterpret_cast<const ValueSp*>(v);
+    runner->putEncrypted(*hash, *toHash, *value, [done_cb, cb_user_data](bool ok){
+        if (done_cb)
+            done_cb(ok, cb_user_data);
+    }, permanent);
 }
 
 void dht_runner_cancel_put(dht_runner* r, const dht_infohash* h, dht_value_id value_id) {

c/opendht_c.h

@@ -18,16 +18,6 @@ struct OPENDHT_C_PUBLIC dht_data_view {
 };
 typedef struct dht_data_view dht_data_view;
 
-// dht::Value
-struct OPENDHT_C_PUBLIC dht_value;
-typedef struct dht_value dht_value;
-typedef uint64_t dht_value_id;
-OPENDHT_C_PUBLIC dht_data_view dht_value_get_data(const dht_value* data);
-OPENDHT_C_PUBLIC dht_value_id dht_value_get_id(const dht_value* data);
-OPENDHT_C_PUBLIC dht_value* dht_value_new(const uint8_t* data, size_t size);
-OPENDHT_C_PUBLIC dht_value* dht_value_ref(const dht_value*);
-OPENDHT_C_PUBLIC void dht_value_unref(dht_value*);
-
 // dht::Blob
 struct OPENDHT_C_PUBLIC dht_blob;
 typedef struct dht_blob dht_blob;
@@ -39,7 +29,9 @@ struct OPENDHT_C_PUBLIC dht_infohash { uint8_t d[HASH_LEN]; };
 typedef struct dht_infohash dht_infohash;
 OPENDHT_C_PUBLIC void dht_infohash_zero(dht_infohash* h);
 OPENDHT_C_PUBLIC void dht_infohash_random(dht_infohash* h);
+OPENDHT_C_PUBLIC void dht_infohash_from_hex(dht_infohash* h, const char* dat);
 OPENDHT_C_PUBLIC void dht_infohash_get(dht_infohash* h, const uint8_t* dat, size_t dat_size);
+OPENDHT_C_PUBLIC void dht_infohash_get_from_string(dht_infohash* h, const char* str);
 OPENDHT_C_PUBLIC const char* dht_infohash_print(const dht_infohash* h);
 OPENDHT_C_PUBLIC bool dht_infohash_is_zero(const dht_infohash* h);
 
@@ -51,9 +43,8 @@ OPENDHT_C_PUBLIC const char* dht_pkid_print(const dht_pkid* h);
 // dht::crypto::PublicKey
 struct OPENDHT_C_PUBLIC dht_publickey;
 typedef struct dht_publickey dht_publickey;
-OPENDHT_C_PUBLIC dht_publickey* dht_publickey_new();
+OPENDHT_C_PUBLIC dht_publickey* dht_publickey_import(const uint8_t* dat, size_t dat_size);
 OPENDHT_C_PUBLIC void dht_publickey_delete(dht_publickey* pk);
-OPENDHT_C_PUBLIC int dht_publickey_unpack(dht_publickey* pk, const uint8_t* dat, size_t dat_size);
 OPENDHT_C_PUBLIC int dht_publickey_pack(dht_publickey* pk, char* out, size_t* out_size);
 OPENDHT_C_PUBLIC dht_infohash dht_publickey_get_id(const dht_publickey* pk);
 OPENDHT_C_PUBLIC dht_pkid dht_publickey_get_long_id(const dht_publickey* pk);
@@ -71,18 +62,38 @@ OPENDHT_C_PUBLIC void dht_privatekey_delete(dht_privatekey*);
 // dht::crypto::Certificate
 struct OPENDHT_C_PUBLIC dht_certificate;
 typedef struct dht_certificate dht_certificate;
+OPENDHT_C_PUBLIC dht_certificate* dht_certificate_import(const uint8_t* dat, size_t dat_size);
+OPENDHT_C_PUBLIC dht_infohash dht_certificate_get_id(const dht_certificate*);
+OPENDHT_C_PUBLIC dht_pkid dht_certificate_get_long_id(const dht_certificate*);
+OPENDHT_C_PUBLIC dht_publickey* dht_certificate_get_publickey(const dht_certificate*);
+OPENDHT_C_PUBLIC void dht_certificate_delete(dht_certificate*);
 
 struct OPENDHT_PUBLIC dht_identity {
-    dht_privatekey* privkey;
+    dht_privatekey* privatekey;
     dht_certificate* certificate;
 };
 typedef struct dht_identity dht_identity;
+OPENDHT_C_PUBLIC dht_identity dht_identity_generate(const char* common_name, const dht_identity* ca);
+OPENDHT_C_PUBLIC void dht_identity_delete(dht_identity*);
+
+// dht::Value
+struct OPENDHT_C_PUBLIC dht_value;
+typedef struct dht_value dht_value;
+typedef uint64_t dht_value_id;
+OPENDHT_C_PUBLIC dht_value* dht_value_new(const uint8_t* data, size_t size);
+OPENDHT_C_PUBLIC dht_value* dht_value_ref(const dht_value*);
+OPENDHT_C_PUBLIC void dht_value_unref(dht_value*);
+OPENDHT_C_PUBLIC dht_data_view dht_value_get_data(const dht_value* data);
+OPENDHT_C_PUBLIC dht_value_id dht_value_get_id(const dht_value* data);
+OPENDHT_C_PUBLIC dht_publickey* dht_value_get_owner(const dht_value* data);
+OPENDHT_C_PUBLIC dht_infohash dht_value_get_recipient(const dht_value* data);
+OPENDHT_C_PUBLIC const char* dht_value_get_user_type(const dht_value* data);
 
 // callbacks
 typedef bool (*dht_get_cb)(const dht_value* value, void* user_data);
 typedef bool (*dht_value_cb)(const dht_value* value, bool expired, void* user_data);
-typedef bool (*dht_done_cb)(bool ok, void* user_data);
-typedef bool (*dht_shutdown_cb)(void* user_data);
+typedef void (*dht_done_cb)(bool ok, void* user_data);
+typedef void (*dht_shutdown_cb)(void* user_data);
 
 struct OPENDHT_C_PUBLIC dht_op_token;
 typedef struct dht_op_token dht_op_token;
@@ -98,8 +109,7 @@ struct OPENDHT_PUBLIC dht_node_config {
 };
 typedef struct dht_node_config dht_node_config;
 
-struct OPENDHT_PUBLIC dht_secure_config
-{
+struct OPENDHT_PUBLIC dht_secure_config {
     dht_node_config node_config;
     dht_identity id;
 };
@@ -131,8 +141,9 @@ OPENDHT_C_PUBLIC void dht_runner_bootstrap(dht_runner* runner, const char* host,
 OPENDHT_C_PUBLIC void dht_runner_get(dht_runner* runner, const dht_infohash* hash, dht_get_cb cb, dht_done_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC dht_op_token* dht_runner_listen(dht_runner* runner, const dht_infohash* hash, dht_value_cb cb, dht_shutdown_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC void dht_runner_cancel_listen(dht_runner* runner, const dht_infohash* hash, dht_op_token* token);
-OPENDHT_C_PUBLIC void dht_runner_put(dht_runner* runner, const dht_infohash* hash, const dht_value* value, dht_done_cb done_cb, void* cb_user_data);
-OPENDHT_C_PUBLIC void dht_runner_put_permanent(dht_runner* runner, const dht_infohash* hash, const dht_value* value, dht_done_cb done_cb, void* cb_user_data);
+OPENDHT_C_PUBLIC void dht_runner_put(dht_runner* runner, const dht_infohash* hash, const dht_value* value, dht_done_cb done_cb, void* cb_user_data, bool permanent);
+OPENDHT_C_PUBLIC void dht_runner_put_signed(dht_runner* runner, const dht_infohash* hash, const dht_value* value, dht_done_cb done_cb, void* cb_user_data, bool permanent);
+OPENDHT_C_PUBLIC void dht_runner_put_encrypted(dht_runner* runner, const dht_infohash* hash, const dht_infohash* to, const dht_value* value, dht_done_cb done_cb, void* cb_user_data, bool permanent);
 OPENDHT_C_PUBLIC void dht_runner_cancel_put(dht_runner* runner, const dht_infohash* hash, dht_value_id value_id);
 OPENDHT_C_PUBLIC void dht_runner_shutdown(dht_runner* runner, dht_shutdown_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC dht_infohash dht_runner_get_node_id(const dht_runner* runner);

configure.ac

@@ -98,7 +98,7 @@ AS_IF([test "x$SYS" = "xandroid"],
 LT_INIT()
 LT_LANG(C++)
 
-AX_CXX_COMPILE_STDCXX(11,[noext],[mandatory])
+AX_CXX_COMPILE_STDCXX(14,[noext],[mandatory])
 
 PKG_PROG_PKG_CONFIG()
 
@@ -210,22 +210,19 @@ AM_COND_IF(ENABLE_PROXY_CLIENT, [CPPFLAGS+=" -DOPENDHT_PROXY_CLIENT"], [])
 AM_COND_IF(ENABLE_PUSH_NOTIFICATIONS, [CPPFLAGS+=" -DOPENDHT_PUSH_NOTIFICATIONS"], [])
 AM_COND_IF(ENABLE_PROXY_SERVER_IDENTITY, [CPPFLAGS+=" -DOPENDHT_PROXY_SERVER_IDENTITY"], [])
 
-AM_COND_IF([HAVE_DOXYGEN], [
-  AC_CONFIG_FILES([doc/Doxyfile doc/Makefile])
-])
-
 dnl Configure setup.py if we build the python module
-AM_COND_IF([USE_CYTHON], [
-    AC_SUBST(CURRENT_SOURCE_DIR, ".")
-    AC_SUBST(CURRENT_BINARY_DIR, ".")
-    AC_SUBST(PROJECT_SOURCE_DIR, "..")
-    AC_SUBST(PROJECT_BINARY_DIR, "../src/.libs")
-    AC_CONFIG_FILES([python/Makefile python/setup.py])
-])
+AC_SUBST(CURRENT_SOURCE_DIR, ".")
+AC_SUBST(CURRENT_BINARY_DIR, ".")
+AC_SUBST(PROJECT_SOURCE_DIR, "..")
+AC_SUBST(PROJECT_BINARY_DIR, "../src/.libs")
 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
                  tools/Makefile
+                 python/Makefile
+                 python/setup.py
                  tests/Makefile
+                 doc/Makefile
+                 doc/Doxyfile
                  opendht.pc])
 AC_OUTPUT

doc/Makefile.am

@@ -1,7 +1,10 @@
 dist_man1_MANS = dhtnode.1
 
+noinst_HEADERS = \
+	Doxyfile
+
 if HAVE_DOXYGEN
-doxyfile.stamp:
+doxyfile.stamp: Doxyfile
 	$(DOXYGEN) Doxyfile
 	echo stamp > doxyfile.stamp
 

docker/DockerfileBionic

@@ -0,0 +1,13 @@
+FROM docker.pkg.github.com/savoirfairelinux/opendht/opendht-deps-bionic:2.0.0
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+		-DOPENDHT_PROXY_CLIENT=On \
+		-DOPENDHT_PROXY_SERVER=On \
+		-DOPENDHT_C=On \
+		-DOPENDHT_PYTHON=On \
+		-DOPENDHT_LTO=On \
+		&& make -j8 && make install \
+	&& cd ../.. && rm -rf opendht

docker/DockerfileDeps

@@ -2,7 +2,7 @@ FROM ubuntu:16.04
 MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 RUN apt-get update && apt-get install -y \
         build-essential cmake git wget libncurses5-dev libreadline-dev nettle-dev \
-        libgnutls28-dev libuv1-dev cython3 python3-dev libcppunit-dev libjsoncpp-dev \
+        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
         autotools-dev autoconf libasio-dev \
     && apt-get clean
 
@@ -28,14 +28,11 @@ RUN echo "** Building a recent version of asio ***" \
     && make install \
     && cd ../../ && rm -rf asio*
 
-#patch for https://github.com/Stiffstream/restinio-conan-example/issues/2
-RUN apt-get update && apt-get install -y python3-pip && pip3 install --upgrade cmake
-
 RUN echo "*** Downloading RESTinio ***" \
     && mkdir restinio && cd restinio \
-    && wget https://github.com/Stiffstream/restinio/archive/v.0.5.1.2.tar.gz \
-    && ls -l && tar -xzf v.0.5.1.2.tar.gz \
-    && cd restinio-v.0.5.1.2/dev \
+    && wget https://github.com/aberaud/restinio/archive/8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59.tar.gz \
+    && ls -l && tar -xzf 8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59.tar.gz \
+    && cd restinio-8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59/dev \
     && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
              -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
              -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none . \

docker/DockerfileDepsBionic

@@ -0,0 +1,28 @@
+FROM ubuntu:18.04
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+
+RUN echo "APT::Acquire::Retries \"3\";" > /etc/apt/apt.conf.d/80-retries
+RUN apt-get update && apt-get install -y \
+        apt-transport-https build-essential cmake git wget libncurses5-dev libreadline-dev nettle-dev \
+        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
+        autotools-dev autoconf libasio-dev libfmt-dev libhttp-parser-dev libmsgpack-dev \
+    && apt-get clean
+
+# libasio-dev (1.10) is too old
+RUN echo "** Building a recent version of asio ***" \
+    && wget https://github.com/chriskohlhoff/asio/archive/asio-1-12-2.tar.gz \
+    && tar -xvf asio-1-12-2.tar.gz && cd asio-asio-1-12-2/asio \
+    && ./autogen.sh && ./configure --prefix=/usr --without-boost \
+    && make install \
+    && cd ../../ && rm -rf asio*
+
+RUN echo "*** Downloading RESTinio ***" \
+    && mkdir restinio && cd restinio \
+    && wget https://github.com/aberaud/restinio/archive/8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59.tar.gz \
+    && ls -l && tar -xzf 8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59.tar.gz \
+    && cd restinio-8d5d3e8237e0947adb9ba1ffc8281f4ad7cb2a59/dev \
+    && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
+             -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
+             -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none . \
+    && make -j8 && make install \
+    && cd ../../ && rm -rf restinio*

include/opendht/callbacks.h

@@ -44,6 +44,13 @@ enum class NodeStatus {
     Connected     // 1+ good nodes
 };
 
+inline constexpr const char*
+statusToStr(NodeStatus status) {
+    return status == NodeStatus::Connected  ? "connected"  : (
+           status == NodeStatus::Connecting ? "connecting" :
+                                              "disconnected");
+}
+
 struct OPENDHT_PUBLIC NodeStats {
     unsigned good_nodes {0},
              dubious_nodes {0},
@@ -71,6 +78,7 @@ struct OPENDHT_PUBLIC NodeInfo {
     InfoHash node_id;
     NodeStats ipv4;
     NodeStats ipv6;
+    size_t ongoing_ops;
 
 #ifdef OPENDHT_JSONCPP
     /**
@@ -106,6 +114,12 @@ struct OPENDHT_PUBLIC Config {
 
     /** If set, the dht will load its state from this file on start and save its state in this file on shutdown */
     std::string persist_path {};
+
+    /** If non-0, overrides the default global rate-limit.-1 means no limit. */
+    ssize_t max_req_per_sec {0};
+
+    /** If non-0, overrides the default per-IP address rate-limit. -1 means no limit. */
+    ssize_t max_peer_req_per_sec {0};
 };
 
 /**

include/opendht/crypto.h

@@ -43,16 +43,22 @@ namespace dht {
 namespace crypto {
 
 class OPENDHT_PUBLIC CryptoException : public std::runtime_error {
-    public:
-        CryptoException(const std::string& str) : std::runtime_error(str) {};
+public:
+    explicit CryptoException(const std::string& str) : std::runtime_error(str) {};
+    explicit CryptoException(const char* str) : std::runtime_error(str) {};
+    CryptoException(const CryptoException& e) noexcept = default;
+    CryptoException& operator=(const CryptoException&) noexcept = default;
 };
 
 /**
  * Exception thrown when a decryption error happened.
  */
 class OPENDHT_PUBLIC DecryptError : public CryptoException {
-    public:
-        DecryptError(const std::string& str = "") : CryptoException(str) {};
+public:
+    explicit DecryptError(const std::string& str) : CryptoException(str) {};
+    explicit DecryptError(const char* str) : CryptoException(str) {};
+    DecryptError(const DecryptError& e) noexcept = default;
+    DecryptError& operator=(const DecryptError&) noexcept = default;
 };
 
 struct PrivateKey;
@@ -72,7 +78,8 @@ struct OPENDHT_PUBLIC PublicKey
      * Takes ownership of an existing gnutls_pubkey.
      */
     PublicKey(gnutls_pubkey_t k) : pk(k) {}
-    PublicKey(const Blob& pk);
+    PublicKey(const uint8_t* dat, size_t dat_size);
+    PublicKey(const Blob& pk) : PublicKey(pk.data(), pk.size()) {}
     PublicKey(PublicKey&& o) noexcept : pk(o.pk) { o.pk = nullptr; };
 
     ~PublicKey();

include/opendht/dht_proxy_client.h

@@ -285,9 +285,7 @@ private:
      */
     struct InfoState;
     void getProxyInfos();
-    void handleProxyStatus(const asio::error_code &ec, std::shared_ptr<InfoState> infoState);
-    void queryProxyInfo(std::shared_ptr<InfoState> infoState, const sa_family_t family,
-                        std::vector<asio::ip::tcp::endpoint>&& endpoints);
+    void queryProxyInfo(std::shared_ptr<InfoState> infoState, sa_family_t family, std::shared_ptr<http::Resolver> resolver);
     void onProxyInfos(const Json::Value& val, const sa_family_t family);
     SockAddr parsePublicAddress(const Json::Value& val);
 
@@ -310,9 +308,8 @@ private:
     void handleResubscribe(const asio::error_code& ec, const InfoHash& key,
                            const size_t token, std::shared_ptr<OperationState> opstate);
 
-    void doPut(const InfoHash&, Sp<Value>, DoneCallback, time_point created, bool permanent);
-    void handleRefreshPut(const asio::error_code& ec, const InfoHash& key, const Value::Id id,
-                          std::shared_ptr<std::atomic_bool> ok);
+    void doPut(const InfoHash&, Sp<Value>, DoneCallbackSimple, time_point created, bool permanent);
+    void handleRefreshPut(const asio::error_code& ec, InfoHash key, Value::Id id);
 
     /**
      * Initialize statusIpvX_
@@ -322,28 +319,15 @@ private:
      * cancel all Listeners
      */
     void cancelAllListeners();
-    /**
-     * cancel all Operations
-     */
-    void cancelAllOperations();
 
+    std::atomic_bool isDestroying_ {false};
+
+    std::string proxyUrl_;
     dht::crypto::Identity clientIdentity_;
     std::shared_ptr<dht::crypto::Certificate> serverCertificate_;
-    std::pair<std::string, std::string> serverHostService_;
+    //std::pair<std::string, std::string> serverHostService_;
     std::string pushClientId_;
 
-    /*
-     * ASIO I/O Context for sockets in httpClient_
-     * Note: Each context is used in one thread only
-     */
-    asio::io_context httpContext_;
-    std::shared_ptr<http::Resolver> resolver_;
-    std::map<unsigned int /*id*/, std::shared_ptr<http::Request>> requests_;
-    /*
-     * Thread for executing the http io_context.run() blocking call
-     */
-    std::thread httpClientThread_;
-
     mutable std::mutex lockCurrentProxyInfos_;
     NodeStatus statusIpv4_ {NodeStatus::Disconnected};
     NodeStatus statusIpv6_ {NodeStatus::Disconnected};
@@ -357,24 +341,36 @@ private:
     // registred types
     TypeStore types;
 
+    /*
+     * ASIO I/O Context for sockets in httpClient_
+     * Note: Each context is used in one thread only
+     */
+    asio::io_context httpContext_;
+    std::shared_ptr<http::Resolver> resolver_;
+
+    mutable std::mutex requestLock_;
+    std::map<unsigned, std::shared_ptr<http::Request>> requests_;
+    /*
+     * Thread for executing the http io_context.run() blocking call
+     */
+    std::thread httpClientThread_;
+
     /**
      * Store listen requests.
      */
     struct ProxySearch;
 
+    mutable std::mutex searchLock_;
     size_t listenerToken_ {0};
     std::map<InfoHash, ProxySearch> searches_;
-    mutable std::mutex searchLock_;
 
     /**
      * Callbacks should be executed in the main thread.
      */
-    std::vector<std::function<void()>> callbacks_;
     std::mutex lockCallbacks_;
+    std::vector<std::function<void()>> callbacks_;
 
     Sp<InfoState> infoState_;
-    Sp<asio::steady_timer> statusTimer_;
-    mutable std::mutex statusLock_;
 
     /**
      * Retrieve if we can connect to the proxy (update statusIpvX_)
@@ -407,9 +403,11 @@ private:
     void getPushRequest(Json::Value&) const;
 #endif // OPENDHT_PUSH_NOTIFICATIONS
 
-    std::atomic_bool isDestroying_ {false};
-
+    Json::StreamWriterBuilder jsonBuilder_;
+    Json::CharReaderBuilder jsonReaderBuilder_;
     std::shared_ptr<dht::Logger> logger_;
+
+    std::shared_ptr<http::Request> buildRequest(const std::string& target = {});
 };
 
 }

include/opendht/dht_proxy_server.h

@@ -149,6 +149,8 @@ private:
 
     std::unique_ptr<RestRouter> createRestRouter();
 
+    void onConnectionClosed(restinio::connection_id_t);
+
     /**
      * Return the PublicKey id, the node id and node stats
      * Method: GET "/"
@@ -317,6 +319,7 @@ private:
 
     std::shared_ptr<DhtRunner> dht_;
     Json::StreamWriterBuilder jsonBuilder_;
+    Json::CharReaderBuilder jsonReaderBuilder_;
 
     // http server
     std::thread serverThread_;
@@ -325,6 +328,8 @@ private:
 
     // http client
     std::pair<std::string, std::string> pushHostPort_;
+    
+    mutable std::mutex requestLock_;
     std::map<unsigned int /*id*/, std::shared_ptr<http::Request>> requests_;
 
     std::shared_ptr<dht::Logger> logger_;
@@ -335,10 +340,9 @@ private:
     std::unique_ptr<asio::steady_timer> printStatsTimer_;
 
     // Thread-safe access to listeners map.
-    std::shared_ptr<std::mutex> lockListener_;
+    std::mutex lockListener_;
     // Shared with connection listener.
-    std::shared_ptr<std::map<restinio::connection_id_t,
-                             http::ListenerSession>> listeners_;
+    std::map<restinio::connection_id_t, http::ListenerSession> listeners_;
     // Connection Listener observing conn state changes.
     std::shared_ptr<ConnectionListener> connListener_;
 

include/opendht/dhtrunner.h

@@ -230,29 +230,30 @@ public:
     }
     void put(const std::string& key, Value&& value, DoneCallbackSimple cb={}, time_point created=time_point::max(), bool permanent = false);
 
-    void cancelPut(const InfoHash& h, const Value::Id& id);
+    void cancelPut(const InfoHash& h, Value::Id id);
+    void cancelPut(const InfoHash& h, const std::shared_ptr<Value>& value);
 
-    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb={});
-    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallbackSimple cb) {
-        putSigned(hash, value, bindDoneCb(cb));
+    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb={}, bool permanent = false);
+    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallbackSimple cb, bool permanent = false) {
+        putSigned(hash, value, bindDoneCb(cb), permanent);
     }
 
-    void putSigned(InfoHash hash, Value&& value, DoneCallback cb={});
-    void putSigned(InfoHash hash, Value&& value, DoneCallbackSimple cb) {
-        putSigned(hash, std::forward<Value>(value), bindDoneCb(cb));
+    void putSigned(InfoHash hash, Value&& value, DoneCallback cb={}, bool permanent = false);
+    void putSigned(InfoHash hash, Value&& value, DoneCallbackSimple cb, bool permanent = false) {
+        putSigned(hash, std::forward<Value>(value), bindDoneCb(cb), permanent);
     }
-    void putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb={});
+    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={});
-    void putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallbackSimple cb) {
-        putEncrypted(hash, to, value, bindDoneCb(cb));
+    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={});
-    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallbackSimple cb) {
-        putEncrypted(hash, to, std::forward<Value>(value), bindDoneCb(cb));
+    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={});
+    void putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb={}, bool permanent = false);
 
     /**
      * Insert known nodes to the routing table, without necessarly ping them.
@@ -316,9 +317,7 @@ public:
      * Returns the currently bound port, in host byte order.
      * @param f: address family of the bound port to retreive.
      */
-    in_port_t getBoundPort(sa_family_t f = AF_INET) const {
-        return getBound(f).getPort();
-    }
+    in_port_t getBoundPort(sa_family_t f = AF_INET) const;
 
     std::pair<size_t, size_t> getStoreSize() const;
 
@@ -341,7 +340,7 @@ public:
     void importValues(const std::vector<ValuesExport>& values);
 
     bool isRunning() const {
-        return running;
+        return running != State::Idle;
     }
 
     NodeStats getNodesStats(sa_family_t af) const;
@@ -359,7 +358,7 @@ public:
 
     // securedht methods
 
-    void findCertificate(InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>)>);
+    void findCertificate(InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);
     void registerCertificate(std::shared_ptr<crypto::Certificate> cert);
     void setLocalCertificateStore(CertificateStoreQuery&& query_method);
 
@@ -412,7 +411,7 @@ public:
     /**
      * Gracefuly disconnect from network.
      */
-    void shutdown(ShutdownCallback cb);
+    void shutdown(ShutdownCallback cb = {});
 
     /**
      * Quit and wait for all threads to terminate.
@@ -450,6 +449,12 @@ public:
 private:
     static constexpr std::chrono::seconds BOOTSTRAP_PERIOD {10};
 
+    enum class State {
+        Idle,
+        Running,
+        Stopping
+    };
+
     /**
      * Will try to resolve the list of hostnames `bootstrap_nodes` on seperate
      * thread and then queue ping requests. This list should contain reliable
@@ -464,6 +469,11 @@ private:
         return std::max(status4, status6);
     }
 
+    bool checkShutdown();
+    void opEnded();
+    DoneCallback bindOpDoneCallback(DoneCallback&& cb);
+    DoneCallbackSimple bindOpDoneCallback(DoneCallbackSimple&& cb);
+
     /** Local DHT instance */
     std::unique_ptr<SecureDht> dht_;
 
@@ -511,7 +521,9 @@ private:
     std::queue<std::function<void(SecureDht&)>> pending_ops {};
     std::mutex storage_mtx {};
 
-    std::atomic_bool running {false};
+    std::atomic<State> running {State::Idle};
+    std::atomic_size_t ongoing_ops {0};
+    std::vector<ShutdownCallback> shutdownCallbacks_;
 
     NodeStatus status4 {NodeStatus::Disconnected},
                status6 {NodeStatus::Disconnected};

include/opendht/http.h

@@ -61,7 +61,7 @@ struct Certificate;
 namespace http {
 
 using HandlerCb = std::function<void(const asio::error_code& ec)>;
-using BytesHandlerCb = std::function<void(const asio::error_code& ec, const size_t bytes)>;
+using BytesHandlerCb = std::function<void(const asio::error_code& ec, size_t bytes)>;
 using ConnectHandlerCb = std::function<void(const asio::error_code& ec,
                                             const asio::ip::tcp::endpoint& endpoint)>;
 
@@ -82,7 +82,7 @@ public:
     std::string fragment;
 };
 
-class OPENDHT_PUBLIC Connection
+class OPENDHT_PUBLIC Connection : public std::enable_shared_from_this<Connection>
 {
 public:
     Connection(asio::io_context& ctx, const bool ssl = true, std::shared_ptr<dht::Logger> l = {});
@@ -90,30 +90,31 @@ public:
                const dht::crypto::Identity& identity, std::shared_ptr<dht::Logger> l = {});
     ~Connection();
 
-    unsigned int id();
-    bool is_open();
-    bool is_ssl();
+    inline unsigned int id() const { return  id_; };
+    bool is_open() const;
+    bool is_ssl() const;
 
     void set_ssl_verification(const asio::ip::tcp::endpoint& endpoint, const asio::ssl::verify_mode verify_mode);
 
     asio::streambuf& input();
-    asio::streambuf& data();
+    std::istream& data() { return istream_; }
 
-    std::string read_bytes(const size_t bytes);
+    std::string read_bytes(size_t bytes);
     std::string read_until(const char delim);
 
     void async_connect(std::vector<asio::ip::tcp::endpoint>&& endpoints, ConnectHandlerCb);
     void async_handshake(HandlerCb cb);
     void async_write(BytesHandlerCb cb);
     void async_read_until(const char* delim, BytesHandlerCb cb);
-    void async_read(const size_t bytes, BytesHandlerCb cb);
+    void async_read_until(char delim, BytesHandlerCb cb);
+    void async_read(size_t bytes, BytesHandlerCb cb);
 
     void timeout(const std::chrono::seconds timeout, HandlerCb cb = {});
     void close();
 
 private:
     unsigned int id_;
-    static unsigned int ids_;
+    static std::atomic_uint ids_;
 
     asio::io_context& ctx_;
     std::unique_ptr<socket_t> socket_;
@@ -124,6 +125,7 @@ private:
 
     asio::streambuf write_buf_;
     asio::streambuf read_buf_;
+    std::istream istream_;
 
     std::unique_ptr<asio::steady_timer> timeout_timer_;
     std::shared_ptr<dht::Logger> logger_;
@@ -147,7 +149,7 @@ class OPENDHT_PUBLIC Resolver
 {
 public:
     using ResolverCb = std::function<void(const asio::error_code& ec,
-                                          std::vector<asio::ip::tcp::endpoint> endpoints)>;
+                                          const std::vector<asio::ip::tcp::endpoint>& endpoints)>;
 
     Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
     Resolver(asio::io_context& ctx, const std::string& host, const std::string& service,
@@ -156,14 +158,20 @@ public:
     // use already resolved endpoints with classes using this resolver
     Resolver(asio::io_context& ctx, std::vector<asio::ip::tcp::endpoint> endpoints,
              const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
+    Resolver(asio::io_context& ctx, const std::string& url, std::vector<asio::ip::tcp::endpoint> endpoints,
+            std::shared_ptr<dht::Logger> logger = {});
 
     ~Resolver();
 
     inline const Url& get_url() const {
         return url_;
-    };
+    }
 
-    void add_callback(ResolverCb cb);
+    void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC);
+
+    std::shared_ptr<Logger> getLogger() const {
+        return logger_;
+    }
 
 private:
     void resolve(const std::string& host, const std::string& service);
@@ -184,12 +192,13 @@ private:
 
 struct Response
 {
-    unsigned int status_code;
+    unsigned int status_code {0};
     std::map<std::string, std::string> headers;
     std::string body;
+    bool aborted {false};
 };
 
-class OPENDHT_PUBLIC Request
+class OPENDHT_PUBLIC Request : public std::enable_shared_from_this<Request>
 {
 public:
     enum class State {
@@ -203,6 +212,7 @@ public:
     using OnDataCb = std::function<void(const char* at, size_t length)>;
     using OnStateChangeCb = std::function<void(State state, const Response& response)>;
     using OnJsonCb = std::function<void(Json::Value value, unsigned int status_code)>;
+    using OnDoneCb = std::function<void(const Response& response)>;
 
     // resolves implicitly
     Request(asio::io_context& ctx, const std::string& url, const Json::Value& json, OnJsonCb jsoncb,
@@ -210,9 +220,11 @@ public:
     Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
     Request(asio::io_context& ctx, const std::string& host, const std::string& service,
             const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger = {});
 
     // user defined resolver
-    Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, std::shared_ptr<dht::Logger> logger = {});
+    Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, sa_family_t family = AF_UNSPEC);
+    Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, const std::string& target, sa_family_t family = AF_UNSPEC);
 
     // user defined resolved endpoints
     Request(asio::io_context& ctx, std::vector<asio::ip::tcp::endpoint>&& endpoints,
@@ -290,9 +302,11 @@ private:
 
     void handle_request(const asio::error_code& ec);
 
-    void handle_response_header(const asio::error_code& ec);
+    void handle_response_header(const asio::error_code& ec, size_t bytes);
 
-    void handle_response_body(const asio::error_code& ec, const size_t bytes);
+    void handle_response_body(const asio::error_code& ec, size_t bytes);
+
+    void onHeadersComplete();
 
     /**
      * Parse the request with http_parser.
@@ -301,13 +315,15 @@ private:
      */
     size_t parse_request(const std::string& request);
 
+    std::shared_ptr<dht::Logger> logger_;
+
     restinio::http_request_header_t header_;
     std::map<restinio::http_field_t, std::string> headers_;
-    restinio::http_connection_header_t connection_type_;
+    restinio::http_connection_header_t connection_type_ {restinio::http_connection_header_t::close};
     std::string body_;
 
     std::mutex cbs_mutex_;
-    std::unique_ptr<Callbacks> cbs_;
+    Callbacks cbs_;
     State state_;
 
     dht::crypto::Identity client_identity_;
@@ -316,8 +332,9 @@ private:
     std::string host_;
 
     unsigned int id_;
-    static unsigned int ids_;
+    static std::atomic_uint ids_;
     asio::io_context& ctx_;
+    sa_family_t family_ = AF_UNSPEC;
     std::shared_ptr<Connection> conn_;
     std::shared_ptr<Resolver> resolver_;
 
@@ -327,8 +344,6 @@ private:
     std::atomic<bool> finishing_ {false};
     std::unique_ptr<http_parser> parser_;
     std::unique_ptr<http_parser_settings> parser_s_;
-
-    std::shared_ptr<dht::Logger> logger_;
 };
 
 } // namespace http

include/opendht/network_engine.h

@@ -48,6 +48,12 @@ struct TransId;
 #define MSG_CONFIRM 0
 #endif
 
+struct NetworkConfig {
+    NetId network {0};
+    ssize_t max_req_per_sec {0};
+    ssize_t max_peer_req_per_sec {0};
+};
+
 class DhtProtocolException : public DhtException {
 public:
     // sent to another peer (http-like).
@@ -207,7 +213,12 @@ public:
     using RequestExpiredCb = std::function<void(const Request&, bool)>;
 
     NetworkEngine(Logger& log, Scheduler& scheduler, std::unique_ptr<DatagramSocket>&& sock);
-    NetworkEngine(InfoHash& myid, NetId net, std::unique_ptr<DatagramSocket>&& sock, Logger& log, Scheduler& scheduler,
+    NetworkEngine(
+            InfoHash& myid,
+            NetworkConfig config,
+            std::unique_ptr<DatagramSocket>&& sock,
+            Logger& log,
+            Scheduler& scheduler,
             decltype(NetworkEngine::onError)&& onError,
             decltype(NetworkEngine::onNewNode)&& onNewNode,
             decltype(NetworkEngine::onReportedAddr)&& onReportedAddr,
@@ -425,7 +436,6 @@ private:
     /***************
      *  Constants  *
      ***************/
-    static constexpr size_t MAX_REQUESTS_PER_SEC {1600};
     /* the length of a node info buffer in ipv4 format */
     static const constexpr size_t NODE4_INFO_BUF_LEN {HASH_LEN + sizeof(in_addr) + sizeof(in_port_t)};
     /* the length of a node info buffer in ipv6 format */
@@ -513,18 +523,18 @@ private:
 
     /* DHT info */
     const InfoHash& myid;
-    const NetId network {0};
+    const NetworkConfig config {};
     const std::unique_ptr<DatagramSocket> dht_socket;
     const Logger& DHT_LOG;
 
     NodeCache cache {};
 
     // global limiting should be triggered by at least 8 different IPs
-    using IpLimiter = RateLimiter<MAX_REQUESTS_PER_SEC/8>;
+    using IpLimiter = RateLimiter;
     using IpLimiterMap = std::map<SockAddr, IpLimiter, SockAddr::ipCmp>;
-    IpLimiterMap address_rate_limiter {};
-    RateLimiter<MAX_REQUESTS_PER_SEC> rate_limiter {};
-    size_t limiter_maintenance {0};
+    IpLimiterMap address_rate_limiter;
+    RateLimiter rate_limiter;
+    ssize_t limiter_maintenance {0};
 
     // requests handling
     std::map<Tid, Sp<Request>> requests {};

include/opendht/network_utils.h

@@ -35,7 +35,7 @@
 #include <functional>
 #include <thread>
 #include <atomic>
-#include <iostream>
+#include <mutex>
 
 namespace dht {
 namespace net {
@@ -63,24 +63,34 @@ public:
     virtual int sendTo(const SockAddr& dest, const uint8_t* data, size_t size, bool replied) = 0;
 
     inline void setOnReceive(OnReceive&& cb) {
+        std::lock_guard<std::mutex> lk(lock);
         rx_callback = std::move(cb);
     }
 
-    virtual const SockAddr& getBound(sa_family_t family = AF_UNSPEC) const = 0;
     virtual bool hasIPv4() const = 0;
     virtual bool hasIPv6() const = 0;
 
-    in_port_t getPort(sa_family_t family = AF_UNSPEC) const {
-        return getBound(family).getPort();
+    SockAddr getBound(sa_family_t family = AF_UNSPEC) const {
+        std::lock_guard<std::mutex> lk(lock);
+        return getBoundRef(family);
     }
+    in_port_t getPort(sa_family_t family = AF_UNSPEC) const {
+        std::lock_guard<std::mutex> lk(lock);
+        return getBoundRef(family).getPort();
+    }
+
+    virtual const SockAddr& getBoundRef(sa_family_t family = AF_UNSPEC) const = 0;
 
     virtual void stop() = 0;
 protected:
 
     inline void onReceived(std::unique_ptr<ReceivedPacket>&& packet) {
+        std::lock_guard<std::mutex> lk(lock);
         if (rx_callback)
             rx_callback(std::move(packet));
     }
+protected:
+    mutable std::mutex lock;
 private:
     OnReceive rx_callback;
 };
@@ -93,12 +103,18 @@ public:
 
     int sendTo(const SockAddr& dest, const uint8_t* data, size_t size, bool replied) override;
 
-    const SockAddr& getBound(sa_family_t family = AF_UNSPEC) const override {
+    const SockAddr& getBoundRef(sa_family_t family = AF_UNSPEC) const override {
         return (family == AF_INET6) ? bound6 : bound4;
     }
 
-    bool hasIPv4() const override { return s4 != -1; }
-    bool hasIPv6() const override { return s6 != -1; }
+    bool hasIPv4() const override {
+        std::lock_guard<std::mutex> lk(lock);
+        return s4 != -1;
+    }
+    bool hasIPv6() const override {
+        std::lock_guard<std::mutex> lk(lock);
+        return s6 != -1;
+    }
 
     void stop() override;
 private:

include/opendht/rate_limiter.h

@@ -23,19 +23,23 @@
 
 namespace dht {
 
-template<size_t Quota, unsigned long Period=1>
 class RateLimiter {
 public:
+    RateLimiter(size_t quota, const duration& period = std::chrono::seconds(1))
+     : quota_(quota), period_(period) {}
+
     /** Clear outdated records and return current quota usage */
     size_t maintain(const time_point& now) {
-        auto limit = now - std::chrono::seconds(Period);
+        auto limit = now - period_;
         while (not records.empty() and records.front() < limit)
             records.pop();
         return records.size();
     }
     /** Return false if quota is reached, insert record and return true otherwise. */
     bool limit(const time_point& now) {
-        if (maintain(now) >= Quota)
+        if (quota_ == std::numeric_limits<size_t>::max())
+            return true;
+        if (maintain(now) >= quota_)
             return false;
         records.emplace(now);
         return true;
@@ -44,6 +48,8 @@ public:
         return records.empty();
     }
 private:
+    const size_t quota_;
+    const duration period_;
     std::queue<time_point> records {};
 };
 

include/opendht/thread_pool.h

@@ -43,9 +43,15 @@ public:
     template<class T>
     std::future<T> get(std::function<T()>&& cb) {
         auto ret = std::make_shared<std::promise<T>>();
-        run(std::bind([=](std::function<T()>& mcb) mutable {
-                ret->set_value(mcb());
-            }, std::move(cb)));
+        run([cb = std::move(cb), ret]() mutable {
+            try {
+                ret->set_value(cb());
+            } catch (...) {
+                try {
+                    ret->set_exception(std::current_exception());
+                } catch(...) {}
+            }
+        });
         return ret->get_future();
     }
     template<class T>

include/opendht/value.h

@@ -167,7 +167,7 @@ struct OPENDHT_PUBLIC Value
         static Filter chain(Filter&& f1, Filter&& f2) {
             if (not f1) return std::move(f2);
             if (not f2) return std::move(f1);
-            return [f1,f2](const Value& v) {
+            return [f1 = std::move(f1), f2 = std::move(f2)](const Value& v) {
                 return f1(v) and f2(v);
             };
         }
@@ -180,12 +180,12 @@ struct OPENDHT_PUBLIC Value
         }
         static Filter chainAll(std::vector<Filter>&& set) {
             if (set.empty()) return {};
-            return std::bind([](const Value& v, std::vector<Filter>& s) {
-                for (const auto& f : s)
+            return [set = std::move(set)](const Value& v) {
+                for (const auto& f : set)
                     if (f and not f(v))
                         return false;
                 return true;
-            }, std::placeholders::_1, std::move(set));
+            };
         }
         static Filter chain(std::initializer_list<Filter> l) {
             return chainAll(std::vector<Filter>(l.begin(), l.end()));

m4/ax_cxx_compile_stdcxx.m4

@@ -1,5 +1,5 @@
 # ===========================================================================
-#   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
 # ===========================================================================
 #
 # SYNOPSIS
@@ -33,21 +33,23 @@
 #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
 #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
+#   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
 #
 #   Copying and distribution of this file, with or without modification, are
 #   permitted in any medium without royalty provided the copyright notice
 #   and this notice are preserved.  This file is offered as-is, without any
 #   warranty.
 
-#serial 4
+#serial 11
 
 dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
 dnl  (serial version number 13).
 
 AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
-  m4_if([$1], [11], [],
-        [$1], [14], [],
-        [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])],
+  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
+        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
+        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
         [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
   m4_if([$2], [], [],
         [$2], [ext], [],
@@ -59,18 +61,11 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
         [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
   AC_LANG_PUSH([C++])dnl
   ac_success=no
-  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
-  ax_cv_cxx_compile_cxx$1,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-    [ax_cv_cxx_compile_cxx$1=yes],
-    [ax_cv_cxx_compile_cxx$1=no])])
-  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
-    ac_success=yes
-  fi
 
   m4_if([$2], [noext], [], [dnl
   if test x$ac_success = xno; then
-    for switch in -std=gnu++$1 -std=gnu++0x; do
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
                      $cachevar,
@@ -96,22 +91,27 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
     dnl HP's aCC needs +std=c++11 according to:
     dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
     dnl Cray's crayCC needs "-h std=c++11"
-    for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
-                     $cachevar,
-        [ac_save_CXX="$CXX"
-         CXX="$CXX $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXX="$ac_save_CXX"])
-      if eval test x\$$cachevar = xyes; then
-        CXX="$CXX $switch"
-        if test -n "$CXXCPP" ; then
-          CXXCPP="$CXXCPP $switch"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          [ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+            [eval $cachevar=yes],
+            [eval $cachevar=no])
+           CXX="$ac_save_CXX"])
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
         fi
-        ac_success=yes
+      done
+      if test x$ac_success = xyes; then
         break
       fi
     done
@@ -148,6 +148,11 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 )
 
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
 
 dnl  Tests for new features in C++11
 
@@ -185,11 +190,13 @@ namespace cxx11
 
     struct Base
     {
+      virtual ~Base() {}
       virtual void f() {}
     };
 
     struct Derived : public Base
     {
+      virtual ~Derived() override {}
       virtual void f() override {}
     };
 
@@ -518,7 +525,7 @@ namespace cxx14
 
   }
 
-  namespace test_digit_seperators
+  namespace test_digit_separators
   {
 
     constexpr auto ten_million = 100'000'000;
@@ -560,3 +567,385 @@ namespace cxx14
 #endif  // __cplusplus >= 201402L
 
 ]])
+
+
+dnl  Tests for new features in C++17
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
+
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201703L
+
+#error "This is not a C++17 compiler"
+
+#else
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+
+namespace cxx17
+{
+
+  namespace test_constexpr_lambdas
+  {
+
+    constexpr int foo = [](){return 42;}();
+
+  }
+
+  namespace test::nested_namespace::definitions
+  {
+
+  }
+
+  namespace test_fold_expression
+  {
+
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+
+  }
+
+  namespace test_extended_static_assert
+  {
+
+    static_assert (true);
+
+  }
+
+  namespace test_auto_brace_init_list
+  {
+
+    auto foo = {5};
+    auto bar {5};
+
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+
+  namespace test_typename_in_template_template_parameter
+  {
+
+    template<template<typename> typename X> struct D;
+
+  }
+
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+
+    int f1()
+    {
+      return 42;
+    }
+
+    [[nodiscard]] int f2()
+    {
+      [[maybe_unused]] auto unused = f1();
+
+      switch (f1())
+      {
+      case 17:
+        f1();
+        [[fallthrough]];
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+
+  }
+
+  namespace test_extended_aggregate_initialization
+  {
+
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+
+    struct derived : base1, base2
+    {
+        int d;
+    };
+
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+
+  }
+
+  namespace test_general_range_based_for_loop
+  {
+
+    struct iter
+    {
+      int i;
+
+      int& operator* ()
+      {
+        return i;
+      }
+
+      const int& operator* () const
+      {
+        return i;
+      }
+
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+
+    struct sentinel
+    {
+      int i;
+    };
+
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+
+    void f()
+    {
+      range r {};
+
+      for (auto i : r)
+      {
+        [[maybe_unused]] auto v = i;
+      }
+    }
+
+  }
+
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return [*this]()
+        {
+          return i;
+        }();
+      }
+    };
+
+  }
+
+  namespace test_enum_class_construction
+  {
+
+    enum class byte : unsigned char
+    {};
+
+    byte foo {42};
+
+  }
+
+  namespace test_constexpr_if
+  {
+
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+
+  }
+
+  namespace test_selection_statement_with_initializer
+  {
+
+    int f()
+    {
+      return 13;
+    }
+
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+
+      default:
+        return 1;
+      }
+    }
+
+  }
+
+  namespace test_template_argument_deduction_for_class_templates
+  {
+
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+
+      T1 m1;
+      T2 m2;
+    };
+
+    void f()
+    {
+      [[maybe_unused]] auto p = pair{13, 42u};
+    }
+
+  }
+
+  namespace test_non_type_auto_template_parameters
+  {
+
+    template <auto n>
+    struct B
+    {};
+
+    B<5> b1;
+    B<'a'> b2;
+
+  }
+
+  namespace test_structured_bindings
+  {
+
+    int arr[2] = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+
+    auto f1() -> int(&)[2]
+    {
+      return arr;
+    }
+
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+
+    S f3()
+    {
+      return {};
+    }
+
+    auto [ x1, y1 ] = f1();
+    auto& [ xr1, yr1 ] = f1();
+    auto [ x2, y2 ] = f2();
+    auto& [ xr2, yr2 ] = f2();
+    const auto [ x3, y3 ] = f3();
+
+  }
+
+  namespace test_exception_spec_type_system
+  {
+
+    struct Good {};
+    struct Bad {};
+
+    void g1() noexcept;
+    void g2();
+
+    template<typename T>
+    Bad
+    f(T*, T*);
+
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+
+  }
+
+  namespace test_inline_variables
+  {
+
+    template<class T> void f(T)
+    {}
+
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+
+    template<> inline void f<>(int)
+    {}
+
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+
+  }
+
+}  // namespace cxx17
+
+#endif  // __cplusplus < 201703L
+
+]])

python/opendht.pyx

@@ -458,6 +458,9 @@ cdef class DhtConfig(object):
         self._config.dht_config.node_config.network = netid
     def setMaintainStorage(self, bool maintain_storage):
         self._config.dht_config.node_config.maintain_storage = maintain_storage
+    def setRateLimit(self, ssize_t max_req_per_sec, ssize_t max_peer_req_per_sec):
+        self._config.dht_config.node_config.max_req_per_sec = max_req_per_sec
+        self._config.dht_config.node_config.max_peer_req_per_sec = max_peer_req_per_sec
 
 cdef class DhtRunner(_WithID):
     cdef cpp.shared_ptr[cpp.DhtRunner] thisptr

python/opendht_cpp.pxd

@@ -211,6 +211,9 @@ cdef extern from "opendht/callbacks.h" namespace "dht":
         uint32_t network
         bool is_bootstrap
         bool maintain_storage
+        string persist_path
+        size_t max_req_per_sec
+        size_t max_peer_req_per_sec
     cppclass SecureDhtConfig:
         Config node_config
         Identity id

python/tools/pingpong.py

@@ -19,13 +19,16 @@ import opendht as dht
 import time
 import asyncio
 
+config = dht.DhtConfig()
+config.setRateLimit(-1, -1)
+
 ping_node = dht.DhtRunner()
-ping_node.run()
+ping_node.run(config=config)
 #ping_node.enableLogging()
 #ping_node.bootstrap("bootstrap.ring.cx", "4222")
 
 pong_node = dht.DhtRunner()
-pong_node.run()
+pong_node.run(config=config)
 #pong_node.enableLogging()
 pong_node.ping(ping_node.getBound())
 
@@ -42,7 +45,6 @@ def done(h, ok):
 
 def ping(node, h):
 	global i
-	time.sleep(0.0075)
 	i += 1
 	if i < MAX:
 		node.put(h, dht.Value(b"hey"), lambda ok, nodes: done(node.getNodeId().decode(), ok))

rust/examples/dhtnode.rs

@@ -20,6 +20,7 @@ extern crate opendht;
 use std::{ thread, time };
 
 use opendht::{ InfoHash, DhtRunner, DhtRunnerConfig, Value };
+// use opendht::crypto::*;
 
 fn main() {
     println!("{}", InfoHash::random());
@@ -28,15 +29,24 @@ fn main() {
     println!("{}", InfoHash::get("alice"));
     println!("{}", InfoHash::get("alice").is_zero());
 
+
     let mut dht = DhtRunner::new();
-    let config = DhtRunnerConfig::new();
+    let /*mut*/ config = DhtRunnerConfig::new();
+    //// If you want to inject a certificate, uncomment the following lines and previous mut.
+    //// Note: you can generate a certificate with
+    //// openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes -keyout example.key -out example.crt -subj /CN=example.com
+    //let cert = DhtCertificate::import("example.crt").ok().expect("Invalid cert file");
+    //let pk = PrivateKey::import("example.key", "");
+    //config.set_identity(cert, pk);
     dht.run_config(1412, config);
     dht.bootstrap("bootstrap.jami.net", 4222);
+    println!("Current node id: {}", dht.node_id());
 
     let /* mut */ data = 42;
     let mut get_cb = |v: Box<Value>| {
         //data += 1;
         println!("GET: VALUE CB - data: {} - v: {}", data, v);
+        true
     };
     let mut done_cb = |ok: bool| {
         println!("GET: DONE CB - data: {} - ok: {}", data, ok);
@@ -47,12 +57,13 @@ fn main() {
     let mut put_done_cb = |ok: bool| {
         println!("PUT: DONE CB - data: {} - ok: {}", data, ok);
     };
-    dht.put(&InfoHash::get("bob"), Value::new("hi!"), &mut put_done_cb);
+    dht.put(&InfoHash::get("bob"), Value::new("hi!"), &mut put_done_cb, false);
 
 
     println!("Start listening /foo");
     let mut value_cb = |v, expired| {
         println!("LISTEN: DONE CB - data: {} - v: {} - expired: {}", data, v, expired);
+        true
     };
     let token = dht.listen(&InfoHash::get("foo"), &mut value_cb);
     let one_min = time::Duration::from_secs(10);

rust/src/crypto.rs

@@ -18,13 +18,17 @@
 
 #![allow(dead_code)]
 
-use crate::ffi::*;
+pub use crate::ffi::*;
 use std::ffi::CString;
+use std::io;
+use std::io::prelude::*;
+use std::fs::File;
+use std::ptr;
 
 impl PublicKey {
-    pub fn new() -> Box<PublicKey> {
+    pub fn new(data: &str) -> Box<PublicKey> {
         unsafe {
-            Box::from_raw(dht_publickey_new())
+            Box::from_raw(dht_publickey_import(data.as_ptr(), data.len()))
         }
     }
 
@@ -89,11 +93,17 @@ impl PrivateKey {
         }
     }
 
-    pub fn import(data: &str, password: &str) -> Box<PrivateKey> {
-        let password = CString::new(password).unwrap();
+    pub fn import(file: &str, password: &str) -> io::Result<Box<PrivateKey>> {
+        let mut f = File::open(file)?;
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer)?;
+        Ok(PrivateKey::from_bytes(&buffer, password))
+    }
+
+    pub fn from_bytes(buffer: &Vec<u8>, password: &str) -> Box<PrivateKey> {
         unsafe {
-            Box::from_raw(dht_privatekey_import(data.as_ptr(),
-                data.as_bytes().len(), password.as_ptr()))
+            Box::from_raw(dht_privatekey_import((&*buffer).as_ptr(), buffer.len(),
+                password.as_ptr() as *const i8))
         }
     }
 
@@ -111,4 +121,74 @@ impl Drop for PrivateKey {
             dht_privatekey_delete(&mut *self)
         }
     }
+}
+
+impl DhtCertificate {
+    pub fn import(file: &str) -> io::Result<Box<DhtCertificate>> {
+        let mut f = File::open(file)?;
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer)?;
+        Ok(DhtCertificate::from_bytes(&buffer))
+    }
+
+    pub fn from_bytes(buffer: &Vec<u8>) -> Box<DhtCertificate> {
+        unsafe {
+            Box::from_raw(dht_certificate_import((&*buffer).as_ptr(), buffer.len()))
+        }
+    }
+
+    pub fn from_slice(buffer: &str) -> Box<DhtCertificate> {
+        unsafe {
+            Box::from_raw(dht_certificate_import((&*buffer).as_ptr(), buffer.len()))
+        }
+    }
+
+    pub fn id(&self) -> InfoHash {
+        unsafe {
+            dht_certificate_get_id(&*self)
+        }
+    }
+
+    pub fn long_id(&self) -> PkId {
+        unsafe {
+            dht_certificate_get_long_id(&*self)
+        }
+    }
+
+    pub fn publickey(&self) -> Box<PublicKey> {
+        unsafe {
+            Box::from_raw(dht_certificate_get_publickey(&*self))
+        }
+    }
+}
+
+impl Drop for DhtCertificate {
+    fn drop(&mut self) {
+        unsafe {
+            dht_certificate_delete(&mut *self)
+        }
+    }
+}
+
+impl DhtIdentity {
+    pub fn new(common_name: &str) -> DhtIdentity {
+        unsafe {
+            DhtIdentity::generate(common_name, Box::from_raw(ptr::null_mut()))
+        }
+    }
+
+    pub fn generate(common_name: &str, ca: Box<DhtIdentity>) -> DhtIdentity {
+        let common_name = CString::new(common_name).unwrap();
+        unsafe {
+            dht_identity_generate(common_name.as_ptr(), &*ca)
+        }
+    }
+}
+
+impl Drop for DhtIdentity {
+    fn drop(&mut self) {
+        unsafe {
+            dht_identity_delete(&mut *self)
+        }
+    }
 }

rust/src/dhtrunner.rs

@@ -39,7 +39,7 @@ impl DhtRunnerConfig {
                     persist_path: ptr::null(),
                 },
                 id: DhtIdentity {
-                    privkey: ptr::null_mut(),
+                    privatekey: ptr::null_mut(),
                     certificate: ptr::null_mut(),
                 },
             },
@@ -51,7 +51,7 @@ impl DhtRunnerConfig {
             peer_publish: false,
             server_ca: ptr::null_mut(),
             client_identity: DhtIdentity {
-                privkey: ptr::null_mut(),
+                privatekey: ptr::null_mut(),
                 certificate: ptr::null_mut(),
             },
         });
@@ -73,6 +73,11 @@ impl DhtRunnerConfig {
         self.push_token = CString::new(push_token).unwrap().as_ptr();
     }
 
+    pub fn set_identity(&mut self, certificate: Box<DhtCertificate>, privatekey: Box<PrivateKey>) {
+        self.dht_config.id.privatekey = Box::into_raw(privatekey);
+        self.dht_config.id.certificate = Box::into_raw(certificate);
+    }
+
 }
 
 impl DhtNodeConfig
@@ -84,13 +89,13 @@ impl DhtNodeConfig
 
 struct GetHandler<'a>
 {
-    get_cb: &'a mut(dyn FnMut(Box<Value>)),
+    get_cb: &'a mut(dyn FnMut(Box<Value>) -> bool),
     done_cb: &'a mut(dyn FnMut(bool))
 }
 
 impl<'a> GetHandler<'a>
 {
-    fn get_cb(&mut self, v: Box<Value>) {
+    fn get_cb(&mut self, v: Box<Value>) -> bool{
         (self.get_cb)(v)
     }
 
@@ -99,9 +104,9 @@ impl<'a> GetHandler<'a>
     }
 }
 
-extern fn get_handler_cb(v: *mut Value, ptr: *mut c_void) {
+extern fn get_handler_cb(v: *mut Value, ptr: *mut c_void) -> bool {
     if ptr.is_null() {
-        return;
+        return true;
     }
     unsafe {
         let handler = ptr as *mut GetHandler;
@@ -137,17 +142,17 @@ extern fn put_handler_done(ok: bool, ptr: *mut c_void) {
 
 struct ListenHandler<'a>
 {
-    cb: &'a mut(dyn FnMut(Box<Value>, bool))
+    cb: &'a mut(dyn FnMut(Box<Value>, bool) -> bool)
 }
 
 impl<'a> ListenHandler<'a>
 {
-    fn cb(&mut self, v: Box<Value>, expired: bool) {
+    fn cb(&mut self, v: Box<Value>, expired: bool) -> bool {
         (self.cb)(v, expired)
     }
 }
 
-extern fn listen_handler(v: *mut Value, expired: bool, ptr: *mut c_void) {
+extern fn listen_handler(v: *mut Value, expired: bool, ptr: *mut c_void) -> bool {
     unsafe {
         let handler = ptr as *mut ListenHandler;
         (*handler).cb((*v).boxed(), expired)
@@ -200,7 +205,7 @@ impl DhtRunner {
     }
 
     pub fn get<'a>(&mut self, h: &InfoHash,
-                get_cb: &'a mut(dyn FnMut(Box<Value>)),
+                get_cb: &'a mut(dyn FnMut(Box<Value>) -> bool),
                 done_cb: &'a mut(dyn FnMut(bool))) {
         let handler = Box::new(GetHandler {
             get_cb,
@@ -213,24 +218,35 @@ impl DhtRunner {
     }
 
     pub fn put<'a>(&mut self, h: &InfoHash, v: Box<Value>,
-                done_cb: &'a mut(dyn FnMut(bool))) {
+                   done_cb: &'a mut(dyn FnMut(bool)), permanent: bool) {
         let handler = Box::new(PutHandler {
             done_cb,
         });
         let handler = Box::into_raw(handler) as *mut c_void;
         unsafe {
-            dht_runner_put(&mut *self, h, &*v, put_handler_done, handler)
+            dht_runner_put(&mut *self, h, &*v, put_handler_done, handler, permanent)
         }
     }
 
-    pub fn permanent_put<'a>(&mut self, h: &InfoHash, v: Box<Value>,
-                done_cb: &'a mut(dyn FnMut(bool))) {
+    pub fn put_signed<'a>(&mut self, h: &InfoHash, v: Box<Value>,
+                                                 done_cb: &'a mut(dyn FnMut(bool)), permanent: bool) {
         let handler = Box::new(PutHandler {
             done_cb,
         });
         let handler = Box::into_raw(handler) as *mut c_void;
         unsafe {
-            dht_runner_put_permanent(&mut *self, h, &*v, put_handler_done, handler)
+            dht_runner_put_signed(&mut *self, h, &*v, put_handler_done, handler, permanent)
+        }
+    }
+
+    pub fn put_encrypted<'a>(&mut self, h: &InfoHash, to: &InfoHash, v: Box<Value>,
+                             done_cb: &'a mut(dyn FnMut(bool)), permanent: bool) {
+        let handler = Box::new(PutHandler {
+            done_cb,
+        });
+        let handler = Box::into_raw(handler) as *mut c_void;
+        unsafe {
+            dht_runner_put_encrypted(&mut *self, h, to, &*v, put_handler_done, handler, permanent)
         }
     }
 
@@ -241,7 +257,7 @@ impl DhtRunner {
     }
 
     pub fn listen<'a>(&mut self, h: &InfoHash,
-                cb: &'a mut(dyn FnMut(Box<Value>, bool))) -> Box<OpToken> {
+                cb: &'a mut(dyn FnMut(Box<Value>, bool) -> bool)) -> Box<OpToken> {
         let handler = Box::new(ListenHandler {
             cb,
         });

rust/src/ffi.rs

@@ -44,6 +44,7 @@ pub struct Blob
 }
 
 #[repr(C)]
+#[derive(PartialEq)]
 pub struct InfoHash
 {
     pub d: [u8; HASH_LEN],
@@ -98,7 +99,7 @@ pub struct DhtCertificate
 #[repr(C)]
 pub struct DhtIdentity
 {
-    pub privkey: *mut PrivateKey,
+    pub privatekey: *mut PrivateKey,
     pub certificate: *mut DhtCertificate,
 }
 
@@ -127,11 +128,14 @@ pub struct DhtRunnerConfig
 #[link(name = "opendht-c")]
 extern {
     // dht::Value
-    pub fn dht_value_get_id(data: *const Value) -> u64;
-    pub fn dht_value_get_data(data: *const Value) -> DataView;
     pub fn dht_value_new(data: *const u8, size: size_t) -> *mut Value;
     pub fn dht_value_ref(data: *const Value) -> *mut Value;
     pub fn dht_value_unref(data: *mut Value);
+    pub fn dht_value_get_data(data: *const Value) -> DataView;
+    pub fn dht_value_get_id(data: *const Value) -> u64;
+    pub fn dht_value_get_owner(data: *const Value) -> *mut PublicKey;
+    pub fn dht_value_get_recipient(data: *const Value) -> InfoHash;
+    pub fn dht_value_get_user_type(data: *const Value) -> *const c_char;
 
     // dht::Blob
     pub fn dht_blob_get_data(data: *const Blob) -> DataView;
@@ -141,13 +145,14 @@ extern {
     pub fn dht_infohash_print(h: *const InfoHash) -> *const c_char;
     pub fn dht_infohash_random(h: *mut InfoHash);
     pub fn dht_infohash_get(h: *mut InfoHash, dat: *mut u8, dat_size: size_t);
+    pub fn dht_infohash_from_hex(h: *mut InfoHash, dat: *const c_char);
     pub fn dht_infohash_is_zero(j: *const InfoHash) -> bool;
 
     // dht::PkId
     pub fn dht_pkid_print(h: *const PkId) -> *const c_char;
 
     // dht::crypto::PublicKey
-    pub fn dht_publickey_new() -> *mut PublicKey;
+    pub fn dht_publickey_import(dat: *const u8, dat_size: size_t) -> *mut PublicKey;
     pub fn dht_publickey_delete(pk: *mut PublicKey);
     pub fn dht_publickey_unpack(pk: *mut PublicKey, dat: *const u8, dat_size: size_t) -> c_int;
     pub fn dht_publickey_pack(pk: *mut PublicKey, out: *const c_char, out_size: size_t) -> c_int;
@@ -162,6 +167,16 @@ extern {
     pub fn dht_privatekey_get_publickey(pk: *const PrivateKey) -> *mut PublicKey;
     pub fn dht_privatekey_delete(pk: *mut PrivateKey);
 
+    // dht::crypto::Certificate
+    pub fn dht_certificate_import(dat: *const u8, dat_size: size_t) -> *mut DhtCertificate;
+    pub fn dht_certificate_get_id(cert: *const DhtCertificate) -> InfoHash;
+    pub fn dht_certificate_get_long_id(cert: *const DhtCertificate) -> PkId;
+    pub fn dht_certificate_get_publickey(cert: *const DhtCertificate) -> *mut PublicKey;
+    pub fn dht_certificate_delete(cert: *mut DhtCertificate);
+
+    pub fn dht_identity_generate(common_name: *const c_char, ca: *const DhtIdentity) -> DhtIdentity;
+    pub fn dht_identity_delete(ca: *mut DhtIdentity);
+
     // dht::OpToken
     pub fn dht_op_token_delete(token: *mut OpToken);
 
@@ -175,18 +190,28 @@ extern {
     pub fn dht_runner_run_config(dht: *mut DhtRunner, port: in_port_t, config: *const DhtRunnerConfig);
     pub fn dht_runner_bootstrap(dht: *mut DhtRunner, host: *const c_char, service: *const c_char);
     pub fn dht_runner_get(dht: *mut DhtRunner, h: *const InfoHash,
-                      get_cb: extern fn(*mut Value, *mut c_void),
-                      done_cb: extern fn(bool, *mut c_void),
-                      cb_user_data: *mut c_void);
+                          get_cb: extern fn(*mut Value, *mut c_void) -> bool,
+                          done_cb: extern fn(bool, *mut c_void),
+                          cb_user_data: *mut c_void);
     pub fn dht_runner_put(dht: *mut DhtRunner, h: *const InfoHash, v: *const Value,
-                      done_cb: extern fn(bool, *mut c_void),
-                      cb_user_data: *mut c_void);
+                          done_cb: extern fn(bool, *mut c_void),
+                          cb_user_data: *mut c_void,
+                          permanent: bool);
+    pub fn dht_runner_put_signed(dht: *mut DhtRunner, h: *const InfoHash, v: *const Value,
+                                 done_cb: extern fn(bool, *mut c_void),
+                                 cb_user_data: *mut c_void,
+                                 permanent: bool);
+    pub fn dht_runner_put_encrypted(dht: *mut DhtRunner, h: *const InfoHash,
+                                    to: *const InfoHash, v: *const Value,
+                                    done_cb: extern fn(bool, *mut c_void),
+                                    cb_user_data: *mut c_void,
+                                    permanent: bool);
     pub fn dht_runner_put_permanent(dht: *mut DhtRunner, h: *const InfoHash, v: *const Value,
                       done_cb: extern fn(bool, *mut c_void),
                       cb_user_data: *mut c_void);
     pub fn dht_runner_cancel_put(dht: *mut DhtRunner, h: *const InfoHash, vid: u64);
     pub fn dht_runner_listen(dht: *mut DhtRunner, h: *const InfoHash,
-                      cb: extern fn(*mut Value, bool, *mut c_void),
+                      cb: extern fn(*mut Value, bool, *mut c_void) -> bool,
                       done_cb: extern fn(*mut c_void),
                       cb_user_data: *mut c_void) -> *mut OpToken;
     pub fn dht_runner_cancel_listen(dht: *mut DhtRunner, h: *const InfoHash,

rust/src/infohash.rs

@@ -47,6 +47,23 @@ impl InfoHash {
         h
     }
 
+    pub fn from_bytes(data: &Vec<u8>) -> InfoHash {
+        let mut h = InfoHash::new();
+        unsafe {
+            dht_infohash_get(&mut h, data.as_ptr() as *mut u8, data.len());
+        }
+        h
+    }
+
+    pub fn from_hex(data: &str) -> InfoHash {
+        let mut h = InfoHash::new();
+        unsafe {
+            let c_str = CString::new(data).unwrap();
+            dht_infohash_from_hex(&mut h, c_str.as_ptr());
+        }
+        h
+    }
+
     pub fn is_zero(&self) -> bool {
         unsafe {
             dht_infohash_is_zero(self)

rust/src/value.rs

@@ -15,9 +15,11 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
+#![allow(dead_code)]
 
 use crate::ffi::*;
 use std::fmt;
+use std::ffi::{ CString, IntoStringError };
 use std::str;
 use std::slice;
 
@@ -62,6 +64,28 @@ impl Value {
             Box::from_raw(dht_value_ref(self))
         }
     }
+
+    pub fn recipient(&self) -> InfoHash {
+        unsafe {
+            dht_value_get_recipient(self)
+        }
+    }
+
+    pub fn owner(&self) -> Option<Box<PublicKey>> {
+        unsafe {
+            let ptr = dht_value_get_owner(self);
+            if ptr.is_null() {
+                return None;
+            }
+            Some(Box::from_raw(ptr))
+        }
+    }
+
+    pub fn user_type(&self) -> Result<String, IntoStringError> {
+        unsafe {
+            CString::from_raw(dht_value_get_user_type(self) as *mut _).into_string()
+        }
+    }
 }
 
 impl Drop for Value {

src/Makefile.am

@@ -2,7 +2,7 @@ lib_LTLIBRARIES = libopendht.la
 
 libopendht_la_CPPFLAGS = @CPPFLAGS@ -I$(top_srcdir)/include/opendht @Argon2_CFLAGS@ @JsonCpp_CFLAGS@ @MsgPack_CFLAGS@ @OpenSSL_CFLAGS@ @Fmt_CFLAGS@
 libopendht_la_LIBADD   = @Argon2_LIBS@ @JsonCpp_LIBS@ @GnuTLS_LIBS@ @Nettle_LIBS@ @OpenSSL_LIBS@ @Fmt_LIBS@
-libopendht_la_LDFLAGS  = @LDFLAGS@ @Argon2_LDFLAGS@ @OpenSSL_LDFLAGS@ @Fmt_LDFLAGS@ -version-number @OPENDHT_MAJOR_VERSION@:@OPENDHT_MINOR_VERSION@:@OPENDHT_PATCH_VERSION@
+libopendht_la_LDFLAGS  = @LDFLAGS@ @Argon2_LDFLAGS@ -version-number @OPENDHT_MAJOR_VERSION@:@OPENDHT_MINOR_VERSION@:@OPENDHT_PATCH_VERSION@
 libopendht_la_SOURCES  = \
         dht.cpp \
         storage.h \

src/callbacks.cpp

@@ -121,6 +121,7 @@ NodeInfo::toJson() const
     val["node_id"] = node_id.toString();
     val["ipv4"] = ipv4.toJson();
     val["ipv6"] = ipv6.toJson();
+    val["ops"] = Json::Value::LargestUInt(ongoing_ops);
     return val;
 }
 
@@ -131,6 +132,7 @@ NodeInfo::NodeInfo(const Json::Value& v)
     node_id = InfoHash(v["node_id"].asString());
     ipv4 = NodeStats(v["ipv4"]);
     ipv6 = NodeStats(v["ipv6"]);
+    ongoing_ops = v["ops"].asLargestUInt();
 }
 
 #endif

src/crypto.cpp

@@ -52,6 +52,9 @@ static std::uniform_int_distribution<uint8_t> rand_byte;
 #define GNUTLS_PKCS_PBES2_AES_256 GNUTLS_PKCS_USE_PBES2_AES_256
 #endif
 
+#define DHT_AES_LEGACY_ENCRYPT 1
+#define DHT_AES_LEGACY_DECRYPT 1
+
 namespace dht {
 namespace crypto {
 
@@ -105,7 +108,9 @@ Blob aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
     struct gcm_aes_ctx aes;
     gcm_aes_set_key(&aes, key.size(), key.data());
     gcm_aes_set_iv(&aes, GCM_IV_SIZE, ret.data());
+#if DHT_AES_LEGACY_ENCRYPT
     gcm_aes_update(&aes, data_length, data);
+#endif
 
     gcm_aes_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
     gcm_aes_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
@@ -137,21 +142,26 @@ Blob aesDecrypt(const Blob& data, const Blob& key)
 
     size_t data_sz = data.size() - GCM_IV_SIZE - GCM_DIGEST_SIZE;
     Blob ret(data_sz);
-    //gcm_aes_update(&aes, data_sz, data.data() + GCM_IV_SIZE);
     gcm_aes_decrypt(&aes, data_sz, ret.data(), data.data() + GCM_IV_SIZE);
-    //gcm_aes_digest(aes, GCM_DIGEST_SIZE, digest.data());
+    gcm_aes_digest(&aes, GCM_DIGEST_SIZE, digest.data());
 
-    // TODO compute the proper digest directly from the decryption pass
-    Blob ret_tmp(data_sz);
-    struct gcm_aes_ctx aes_d;
-    gcm_aes_set_key(&aes_d, key.size(), key.data());
-    gcm_aes_set_iv(&aes_d, GCM_IV_SIZE, data.data());
-    gcm_aes_update(&aes_d, ret.size(), ret.data());
-    gcm_aes_encrypt(&aes_d, ret.size(), ret_tmp.data(), ret.data());
-    gcm_aes_digest(&aes_d, GCM_DIGEST_SIZE, digest.data());
+    if (not std::equal(digest.begin(), digest.end(), data.end() - GCM_DIGEST_SIZE)) {
+#if DHT_AES_LEGACY_DECRYPT
+        //gcm_aes_decrypt(&aes, data_sz, ret.data(), data.data() + GCM_IV_SIZE);
+        Blob ret_tmp(data_sz);
+        struct gcm_aes_ctx aes_d;
+        gcm_aes_set_key(&aes_d, key.size(), key.data());
+        gcm_aes_set_iv(&aes_d, GCM_IV_SIZE, data.data());
+        gcm_aes_update(&aes_d, ret.size(), ret.data());
+        gcm_aes_encrypt(&aes_d, ret.size(), ret_tmp.data(), ret.data());
+        gcm_aes_digest(&aes_d, GCM_DIGEST_SIZE, digest.data());
 
-    if (not std::equal(digest.begin(), digest.end(), data.end() - GCM_DIGEST_SIZE))
+        if (not std::equal(digest.begin(), digest.end(), data.end() - GCM_DIGEST_SIZE))
+            throw DecryptError("Can't decrypt data");
+#else
         throw DecryptError("Can't decrypt data");
+#endif
+    }
 
     return ret;
 }
@@ -364,9 +374,9 @@ PublicKey::PublicKey()
         throw CryptoException(std::string("Can't initialize public key: ") + gnutls_strerror(err));
 }
 
-PublicKey::PublicKey(const Blob& dat) : PublicKey()
+PublicKey::PublicKey(const uint8_t* dat, size_t dat_size) : PublicKey()
 {
-    unpack(dat.data(), dat.size());
+    unpack(dat, dat_size);
 }
 
 PublicKey::~PublicKey()

src/dht.cpp

@@ -39,6 +39,7 @@ constexpr std::chrono::minutes Dht::MAX_STORAGE_MAINTENANCE_EXPIRE_TIME;
 constexpr std::chrono::minutes Dht::SEARCH_EXPIRE_TIME;
 constexpr std::chrono::seconds Dht::LISTEN_EXPIRE_TIME;
 constexpr std::chrono::seconds Dht::REANNOUNCE_MARGIN;
+static constexpr size_t MAX_REQUESTS_PER_SEC {1600};
 
 NodeStatus
 Dht::getStatus(sa_family_t af) const
@@ -77,8 +78,7 @@ Dht::shutdown(ShutdownCallback cb)
 
     if (!*remaining) {
         DHT_LOG.w("shuting down node: %u ops remaining", *remaining);
-        if (cb)
-            cb();
+        if (cb) cb();
     }
 }
 
@@ -921,8 +921,7 @@ Dht::put(const InfoHash& id, Sp<Value> val, DoneCallback callback, time_point cr
     }
     if (val->id == Value::INVALID_ID) {
         crypto::random_device rdev;
-        std::uniform_int_distribution<Value::Id> rand_id {};
-        val->id = rand_id(rdev);
+        val->id = std::uniform_int_distribution<Value::Id>{1}(rdev);
     }
     scheduler.syncTime();
     const auto& now = scheduler.time();
@@ -1689,11 +1688,23 @@ Dht::~Dht()
         s.second->clear();
 }
 
+net::NetworkConfig
+fromDhtConfig(const Config& config)
+{
+    net::NetworkConfig netConf;
+    netConf.network = config.network;
+    netConf.max_req_per_sec = config.max_req_per_sec ? config.max_req_per_sec : MAX_REQUESTS_PER_SEC;
+    netConf.max_peer_req_per_sec = config.max_peer_req_per_sec
+        ? config.max_peer_req_per_sec
+        : netConf.max_req_per_sec/8;
+    return netConf;
+}
+
 Dht::Dht() : store(), network_engine(DHT_LOG, scheduler, {}) {}
 
 Dht::Dht(std::unique_ptr<net::DatagramSocket>&& sock, const Config& config, const Logger& l)
     : DhtInterface(l), myid(config.node_id ? config.node_id : InfoHash::getRandom()), store(), store_quota(),
-    network_engine(myid, config.network, std::move(sock), DHT_LOG, scheduler,
+    network_engine(myid, fromDhtConfig(config), std::move(sock), DHT_LOG, scheduler,
             std::bind(&Dht::onError, this, _1, _2),
             std::bind(&Dht::onNewNode, this, _1, _2),
             std::bind(&Dht::onReportedAddr, this, _1, _2),
@@ -1908,7 +1919,7 @@ Dht::periodic(const uint8_t *buf, size_t buflen, SockAddr from)
         try {
             network_engine.processMessage(buf, buflen, std::move(from));
         } catch (const std::exception& e) {
-            DHT_LOG.e("Can't process message: %s", e.what());
+            DHT_LOG.w("Can't process message: %s", e.what());
         }
     }
     return scheduler.run();

src/dht_proxy_client.cpp

@@ -80,9 +80,10 @@ DhtProxyClient::DhtProxyClient(
         pushClientId_(pushClientId), loopSignal_(signal), logger_(logger)
 {
     // build http client
-    serverHostService_ = splitPort(serverHost);
-    serverHostService_.second = serverHostService_.second.empty() ? "80" :
-                                serverHostService_.second;
+    proxyUrl_ = serverHost;
+
+    jsonBuilder_["commentStyle"] = "None";
+    jsonBuilder_["indentation"] = "";
     if (logger_){
         if (serverCertificate_)
             logger_->d("[proxy:client] using ca certificate for ssl:\n%s",
@@ -91,8 +92,6 @@ DhtProxyClient::DhtProxyClient(
             logger_->d("[proxy:client] using client certificate for ssl:\n%s",
                        clientIdentity_.second->toString(false/*chain*/).c_str());
     }
-    // resolve once
-    resolver_ = std::make_shared<http::Resolver>(httpContext_, serverHost, logger_);
     // run http client
     httpClientThread_ = std::thread([this](){
         try {
@@ -109,18 +108,18 @@ DhtProxyClient::DhtProxyClient(
                 logger_->e("[proxy:client] run error: %s", ex.what());
         }
     });
-    if (!serverHostService_.first.empty())
+    if (!proxyUrl_.empty())
         startProxy();
 }
 
 void
 DhtProxyClient::startProxy()
 {
-    if (serverHostService_.first.empty())
+    if (proxyUrl_.empty())
         return;
 
     if (logger_)
-        logger_->d("[proxy:client] start proxy with %s", serverHostService_.first.c_str());
+        logger_->d("[proxy:client] start proxy with %s", proxyUrl_.c_str());
 
     nextProxyConfirmationTimer_ = std::make_shared<asio::steady_timer>(httpContext_, std::chrono::steady_clock::now());
     nextProxyConfirmationTimer_->async_wait(std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
@@ -140,7 +139,7 @@ DhtProxyClient::handleProxyConfirm(const asio::error_code &ec)
             logger_->e("[proxy:client] confirm error: %s", ec.message().c_str());
         return;
     }
-    if (serverHostService_.first.empty())
+    if (proxyUrl_.empty())
         return;
     getConnectivityStatus();
 }
@@ -153,15 +152,22 @@ DhtProxyClient::~DhtProxyClient()
 void
 DhtProxyClient::stop()
 {
-    isDestroying_ = true;
-    cancelAllOperations();
-    cancelAllListeners();
-    if (infoState_)
-        infoState_->cancel = true;
-    if (statusTimer_)
-        statusTimer_->cancel();
-    if (httpClientThread_.joinable())
-        httpClientThread_.join();
+    if (not isDestroying_.exchange(true)) {
+        resolver_.reset();
+        cancelAllListeners();
+        if (infoState_)
+            infoState_->cancel = true;
+        {
+            std::lock_guard<std::mutex> lock(requestLock_);
+            for (auto& request : requests_)
+                request.second->cancel();
+        }
+        if (not httpContext_.stopped())
+            httpContext_.stop();
+        if (httpClientThread_.joinable())
+            httpClientThread_.join();
+        requests_.clear();
+    }
 }
 
 std::vector<Sp<Value>>
@@ -182,13 +188,6 @@ DhtProxyClient::getLocalById(const InfoHash& k, Value::Id id) const {
     return s->second.ops.get(id);
 }
 
-void
-DhtProxyClient::cancelAllOperations()
-{
-    if (!httpContext_.stopped())
-        httpContext_.stop();
-}
-
 void
 DhtProxyClient::cancelAllListeners()
 {
@@ -263,9 +262,6 @@ DhtProxyClient::periodic(const uint8_t*, size_t, SockAddr)
 
 void
 DhtProxyClient::setHeaderFields(http::Request& request){
-    request.set_header_field(restinio::http_field_t::host,
-                             serverHostService_.first + ":" + serverHostService_.second);
-    request.set_header_field(restinio::http_field_t::user_agent, "RESTinio client");
     request.set_header_field(restinio::http_field_t::accept, "*/*");
     request.set_header_field(restinio::http_field_t::content_type, "application/json");
 }
@@ -276,27 +272,22 @@ DhtProxyClient::get(const InfoHash& key, GetCallback cb, DoneCallback donecb, Va
     if (logger_)
         logger_->d("[proxy:client] [get] [search %s]", key.to_c_str());
 
-    auto request = std::make_shared<http::Request>(httpContext_, resolver_, logger_);
-    auto reqid = request->id();
+    if (isDestroying_) {
+        if (donecb) donecb(false, {});
+        return;
+    }
     try {
-        request->set_connection_type(restinio::http_connection_header_t::keep_alive);
-        request->set_target("/" + key.toString());
+        auto request = buildRequest("/" + key.toString());
+        auto reqid = request->id();
+        //request->set_connection_type(restinio::http_connection_header_t::keep_alive);
         request->set_method(restinio::http_method_get());
         setHeaderFields(*request);
 
         auto opstate = std::make_shared<OperationState>();
         Value::Filter filter = w.empty() ? f : f.chain(w.getFilter());
 
-        request->add_on_status_callback([this, key, opstate](unsigned int status_code){
-            if (status_code != 200){
-                if (logger_)
-                    logger_->e("[proxy:client] [get %s] status error: %i", key.to_c_str(), status_code);
-                opstate->ok.store(false);
-            }
-        });
         request->add_on_body_callback([this, key, opstate, filter, cb](const char* at, size_t length){
             try {
-                Json::CharReaderBuilder rbuilder;
                 auto body = std::string(at, length);
                 // one value per body line
                 std::string data_line;
@@ -305,7 +296,7 @@ DhtProxyClient::get(const InfoHash& key, GetCallback cb, DoneCallback donecb, Va
                     std::string err;
                     Json::Value json;
                     auto* char_data = static_cast<const char*>(&data_line[0]);
-                    auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+                    auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
                     if (!reader->parse(char_data, char_data + data_line.size(), &json, &err)){
                         opstate->ok.store(false);
                         return;
@@ -332,12 +323,14 @@ DhtProxyClient::get(const InfoHash& key, GetCallback cb, DoneCallback donecb, Va
         request->add_on_state_change_callback([this, reqid, opstate, donecb, key]
                                               (http::Request::State state, const http::Response& response){
             if (state == http::Request::State::DONE){
-                if (response.status_code != 200){
+                if (response.status_code != 200) {
                     if (logger_)
                         logger_->e("[proxy:client] [get %s] failed with code=%i", key.to_c_str(), response.status_code);
                     opstate->ok.store(false);
+                    if (not response.aborted and response.status_code == 0)
+                        opFailed();
                 }
-                if (donecb){
+                if (donecb) {
                     {
                         std::lock_guard<std::mutex> lock(lockCallbacks_);
                         callbacks_.emplace_back([donecb, opstate](){
@@ -347,29 +340,29 @@ DhtProxyClient::get(const InfoHash& key, GetCallback cb, DoneCallback donecb, Va
                     }
                     loopSignal_();
                 }
-                requests_.erase(reqid);
+                if (not isDestroying_) {
+                    std::lock_guard<std::mutex> l(requestLock_);
+                    requests_.erase(reqid);
+                }
             }
         });
-        if (serverCertificate_)
-            request->set_certificate_authority(serverCertificate_);
-        if (clientIdentity_.first and clientIdentity_.second)
-            request->set_identity(clientIdentity_);
+        {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_[reqid] = request;
+        }
         request->send();
-        requests_[reqid] = request;
     }
     catch (const std::exception &e){
         if (logger_)
             logger_->e("[proxy:client] [get %s] error: %s", key.to_c_str(), e.what());
-        requests_.erase(reqid);
     }
 }
 
 void
 DhtProxyClient::put(const InfoHash& key, Sp<Value> val, DoneCallback cb, time_point created, bool permanent)
 {
-    if (not val){
-        if (cb)
-            cb(false, {});
+    if (not val or isDestroying_) {
+        if (cb) cb(false, {});
         return;
     }
     if (logger_)
@@ -377,35 +370,43 @@ DhtProxyClient::put(const InfoHash& key, Sp<Value> val, DoneCallback cb, time_po
 
     if (val->id == Value::INVALID_ID) {
         crypto::random_device rdev;
-        std::uniform_int_distribution<Value::Id> rand_id {};
-        val->id = rand_id(rdev);
+        val->id = std::uniform_int_distribution<Value::Id>{1}(rdev);
     }
+    std::shared_ptr<std::atomic_bool> ok;
     if (permanent) {
         std::lock_guard<std::mutex> lock(searchLock_);
         auto id = val->id;
         auto& search = searches_[key];
         auto refreshPutTimer = std::make_unique<asio::steady_timer>(httpContext_, std::chrono::steady_clock::now() +
                                                                     proxy::OP_TIMEOUT - proxy::OP_MARGIN);
-        auto ok = std::make_shared<std::atomic_bool>();
-        ok->store(true);
-        refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this,
-                                              std::placeholders::_1, key, id, ok));
+        refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this, std::placeholders::_1, key, id));
         search.puts.erase(id);
+        ok = std::make_shared<std::atomic_bool>(true);
         search.puts.emplace(std::piecewise_construct,
             std::forward_as_tuple(id),
             std::forward_as_tuple(val, std::move(refreshPutTimer), ok));
     }
-    doPut(key, val, std::move(cb), created, permanent);
+    doPut(key, val, [this, cb, ok](bool result){
+        if (ok)
+            *ok = result;
+        if (cb) {
+            std::lock_guard<std::mutex> lock(lockCallbacks_);
+            callbacks_.emplace_back([cb, result](){
+                cb(result, {});
+            });
+        }
+        loopSignal_();
+    }, created, permanent);
 }
+
 void
-DhtProxyClient::handleRefreshPut(const asio::error_code &ec, const InfoHash& key, const Value::Id id,
-                                 std::shared_ptr<std::atomic_bool> ok)
+DhtProxyClient::handleRefreshPut(const asio::error_code &ec, InfoHash key, Value::Id id)
 {
     if (ec == asio::error::operation_aborted)
         return;
     else if (ec){
         if (logger_)
-            logger_->e("[proxy:client] [listener] [refresh %s] %s", key.toString().c_str(), ec.message().c_str());
+            logger_->e("[proxy:client] [put] [refresh %s] %s", key.toString().c_str(), ec.message().c_str());
         return;
     }
     if (logger_)
@@ -415,26 +416,41 @@ DhtProxyClient::handleRefreshPut(const asio::error_code &ec, const InfoHash& key
     if (search != searches_.end()) {
         auto p = search->second.puts.find(id);
         if (p != search->second.puts.end()){
-            doPut(key, p->second.value, [ok](bool result, const std::vector<std::shared_ptr<dht::Node>>&){
+            doPut(key, p->second.value, [ok = p->second.ok](bool result){
                 *ok = result;
             }, time_point::max(), true);
-            p->second.refreshPutTimer->expires_at(std::chrono::steady_clock::now() +
-                                               proxy::OP_TIMEOUT - proxy::OP_MARGIN);
-            p->second.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this, std::placeholders::_1, key, id, ok));
+            p->second.refreshPutTimer->expires_at(std::chrono::steady_clock::now() + proxy::OP_TIMEOUT - proxy::OP_MARGIN);
+            p->second.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this, std::placeholders::_1, key, id));
         }
     }
 }
 
+std::shared_ptr<http::Request>
+DhtProxyClient::buildRequest(const std::string& target)
+{
+    auto resolver = resolver_;
+    if (not resolver)
+        resolver = std::make_shared<http::Resolver>(httpContext_, proxyUrl_, logger_);
+    auto request = target.empty() 
+        ? std::make_shared<http::Request>(httpContext_, resolver)
+        : std::make_shared<http::Request>(httpContext_, resolver, target);
+    if (serverCertificate_)
+        request->set_certificate_authority(serverCertificate_);
+    if (clientIdentity_.first and clientIdentity_.second)
+        request->set_identity(clientIdentity_);
+    request->set_header_field(restinio::http_field_t::user_agent, "RESTinio client");
+    return request;
+}
+
 void
-DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallback cb, time_point /*created*/, bool permanent)
+DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallbackSimple cb, time_point /*created*/, bool permanent)
 {
     if (logger_)
         logger_->d("[proxy:client] [put] [search %s] executing for %s", key.to_c_str(), val->toString().c_str());
 
-    auto request = std::make_shared<http::Request>(httpContext_, resolver_, logger_);
-    auto reqid = request->id();
     try {
-        request->set_target("/" + key.toString());
+        auto request = buildRequest("/" + key.toString());
+        auto reqid = request->id();
         request->set_method(restinio::http_method_post());
         setHeaderFields(*request);
 
@@ -452,52 +468,34 @@ DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallback cb, time_
 #endif
             }
         }
-        Json::StreamWriterBuilder wbuilder;
-        wbuilder["commentStyle"] = "None";
-        wbuilder["indentation"] = "";
-        auto body = Json::writeString(wbuilder, json);
-        request->set_body(body);
-
-        auto ok = std::make_shared<std::atomic_bool>();
-        ok->store(true);
-
-        request->add_on_status_callback([this, key, ok](unsigned int status_code){
-            if (status_code != 200){
-                if (logger_)
-                    logger_->e("[proxy:client] [put %s] status error: %i", key.to_c_str(), status_code);
-                ok->store(false);
-            }
-            return 0;
-        });
-        request->add_on_state_change_callback([this, reqid, ok, cb, key]
+        request->set_body(Json::writeString(jsonBuilder_, json));
+        request->add_on_state_change_callback([this, reqid, cb]
                                               (http::Request::State state, const http::Response& response){
             if (state == http::Request::State::DONE){
-                if (response.status_code != 200)
+                bool ok = response.status_code == 200;
+                if (not ok) {
                     if (logger_)
                         logger_->e("[proxy:client] [status] failed with code=%i", response.status_code);
-                if (cb){
-                    {
-                        std::lock_guard<std::mutex> lock(lockCallbacks_);
-                        callbacks_.emplace_back([cb, ok](){
-                            cb(ok->load(), {});
-                        });
-                    }
-                    loopSignal_();
+                    if (not response.aborted and response.status_code == 0)
+                        opFailed();
+                }
+                if (cb)
+                    cb(ok);
+                if (not isDestroying_) {
+                    std::lock_guard<std::mutex> l(requestLock_);
+                    requests_.erase(reqid);
                 }
-                requests_.erase(reqid);
             }
         });
-        if (serverCertificate_)
-            request->set_certificate_authority(serverCertificate_);
-        if (clientIdentity_.first and clientIdentity_.second)
-            request->set_identity(clientIdentity_);
+        {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_[reqid] = request;
+        }
         request->send();
-        requests_[reqid] = request;
     }
     catch (const std::exception &e){
         if (logger_)
             logger_->e("[proxy:client] [put %s] error: %s", key.to_c_str(), e.what());
-        requests_.erase(reqid);
     }
 }
 
@@ -556,146 +554,77 @@ DhtProxyClient::getProxyInfos()
 {
     if (logger_)
         logger_->d("[proxy:client] [info] requesting proxy server node information");
-    std::lock_guard<std::mutex> l(statusLock_);
-
     auto infoState = std::make_shared<InfoState>();
-    if (infoState_)
-        infoState_->cancel = true;
-    infoState_ = infoState;
     {
         std::lock_guard<std::mutex> l(lockCurrentProxyInfos_);
+        if (infoState_)
+            infoState_->cancel = true;
+        infoState_ = infoState;
         if (statusIpv4_ == NodeStatus::Disconnected)
             statusIpv4_ = NodeStatus::Connecting;
         if (statusIpv6_ == NodeStatus::Disconnected)
             statusIpv6_ = NodeStatus::Connecting;
     }
-    // Try to contact the proxy and set the status to connected when done.
-    // will change the connectivity status
-    if (!statusTimer_)
-        statusTimer_ = std::make_shared<asio::steady_timer>(httpContext_);
-    statusTimer_->expires_at(std::chrono::steady_clock::now());
-    statusTimer_->async_wait(std::bind(&DhtProxyClient::handleProxyStatus, this,
-                             std::placeholders::_1, infoState));
-}
-
-void
-DhtProxyClient::handleProxyStatus(const asio::error_code& ec, std::shared_ptr<InfoState> infoState)
-{
-    if (ec == asio::error::operation_aborted)
-        return;
-    else if (ec){
-        if (logger_)
-            logger_->e("[proxy:client] [status] handling error: %s", ec.message().c_str());
-        return;
-    }
     if (logger_)
         logger_->d("[proxy:client] [status] sending request");
 
-    resolver_->add_callback([this, infoState](const asio::error_code& ec,
-                                              std::vector<asio::ip::tcp::endpoint> endpoints)
-    {
-        if (ec){
-            if (logger_)
-                logger_->e("[proxy:client] [status] resolve error: %s", ec.message().c_str());
-            return;
-        }
-        std::vector<asio::ip::tcp::endpoint> endpointsIpv4;
-        std::vector<asio::ip::tcp::endpoint> endpointsIpv6;
-
-        for (auto& endpoint: endpoints){
-            try {
-                if (endpoint.address().is_v6())
-                    endpointsIpv6.push_back(endpoint);
-                if (endpoint.address().is_v4())
-                    endpointsIpv4.push_back(endpoint);
-            } catch (const std::exception&){};
-        }
-        // avoiding nested add_callback call
-        if (!endpointsIpv4.empty())
-            queryProxyInfo(infoState, AF_INET, std::move(endpointsIpv4));
-        if (!endpointsIpv6.empty())
-            queryProxyInfo(infoState, AF_INET6, std::move(endpointsIpv6));
-    });
+    auto resolver = std::make_shared<http::Resolver>(httpContext_, proxyUrl_, logger_);
+    queryProxyInfo(infoState, AF_INET, resolver);
+    queryProxyInfo(infoState, AF_INET6, resolver);
+    resolver_ = resolver;
 }
 
 void
-DhtProxyClient::queryProxyInfo(std::shared_ptr<InfoState> infoState, const sa_family_t family,
-                               std::vector<asio::ip::tcp::endpoint>&& endpoints)
+DhtProxyClient::queryProxyInfo(std::shared_ptr<InfoState> infoState, sa_family_t family, std::shared_ptr<http::Resolver> resolver)
 {
     if (logger_)
         logger_->d("[proxy:client] [status] query ipv%i info", family == AF_INET ? 4 : 6);
-    auto request = std::make_shared<http::Request>(httpContext_, std::move(endpoints),
-        resolver_->get_url().protocol == "https" ? /*ssl*/ true : false, logger_);
-    auto reqid = request->id();
     try {
-        request->set_connection_type(restinio::http_connection_header_t::keep_alive);
-        request->set_target("/");
-        request->set_method(restinio::http_method_get());
+        auto request = std::make_shared<http::Request>(httpContext_, resolver, family);
+        auto reqid = request->id();
+        request->set_method(restinio::http_method_get()); 
         setHeaderFields(*request);
-
-        auto ok = std::make_shared<std::atomic_bool>();
-        ok->store(true);
-
-        request->add_on_status_callback([this, ok, family](unsigned int status_code){
-            if (status_code != 200){
-                if (logger_)
-                    logger_->e("[proxy:client] [status] ipv%i status code error: %i", family, status_code);
-                ok->store(false);
-            }
-        });
-        request->add_on_body_callback([this, ok, infoState, family](const char* at, size_t length){
-            try{
-                std::string err;
-                Json::Value proxyInfos;
-                Json::CharReaderBuilder rbuilder;
-                auto body = std::string(at, length);
-                auto* char_data = static_cast<const char*>(&body[0]);
-                auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
-                if (!reader->parse(char_data, char_data + body.size(), &proxyInfos, &err)){
-                    ok->store(false);
-                    return;
-                }
-                if (not infoState->cancel)
-                    onProxyInfos(proxyInfos, family);
-            }
-            catch (const std::exception& e) {
-                if (logger_)
-                    logger_->e("[proxy:client] [status] body error: %s", e.what());
-                ok->store(false);
-            }
-        });
         request->add_on_state_change_callback([this, reqid, family, infoState]
                                               (http::Request::State state, const http::Response& response){
-            if (state == http::Request::State::DONE){
-                if (response.status_code != 200)
+            if (state == http::Request::State::DONE) {
+                if (infoState->cancel.load())
+                    return;
+                if (response.status_code != 200) {
                     if (logger_)
                         logger_->e("[proxy:client] [status] ipv%i failed with code=%i",
                                     family == AF_INET ? 4 : 6, response.status_code);
-                if (infoState->cancel.load()){
                     // pass along the failures
-                    if (family == AF_INET and infoState->ipv4 == 0)
-                        onProxyInfos(Json::Value{}, AF_INET);
-                    if (family == AF_INET6 and infoState->ipv6 == 0)
-                    onProxyInfos(Json::Value{}, AF_INET6);
+                    if ((family == AF_INET and infoState->ipv4 == 0) or (family == AF_INET6 and infoState->ipv6 == 0))
+                        onProxyInfos(Json::Value{}, family);
+                } else {
+                    std::string err;
+                    Json::Value proxyInfos;
+                    auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
+                    if (!reader->parse(response.body.data(), response.body.data() + response.body.size(), &proxyInfos, &err)){
+                        onProxyInfos(Json::Value{}, family);
+                        return;
+                    }
+                    if (not infoState->cancel)
+                        onProxyInfos(proxyInfos, family);
+                }
+                if (not isDestroying_) {
+                    std::lock_guard<std::mutex> l(requestLock_);
+                    requests_.erase(reqid);
                 }
-                requests_.erase(reqid);
             }
         });
 
         if (infoState->cancel.load())
             return;
-
-        if (serverCertificate_)
-            request->set_certificate_authority(serverCertificate_);
-        if (clientIdentity_.first and clientIdentity_.second)
-            request->set_identity(clientIdentity_);
+        {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_[reqid] = request;
+        }
         request->send();
-        requests_[reqid] = request;
     }
     catch (const std::exception &e){
         if (logger_)
             logger_->e("[proxy:client] [status] error sending request: %s", e.what());
-        requests_.erase(reqid);
     }
 }
 
@@ -778,11 +707,13 @@ DhtProxyClient::listen(const InfoHash& key, ValueCallback cb, Value::Filter filt
 {
     if (logger_)
         logger_->d("[proxy:client] [listen] [search %s]", key.to_c_str());
+    if (isDestroying_)
+        return 0;
 
+    std::lock_guard<std::mutex> lock(searchLock_);
     auto& search = searches_[key];
     auto query = std::make_shared<Query>(Select{}, std::move(where));
     return search.ops.listen(cb, query, filter, [this, key](Sp<Query>, ValueCallback cb, SyncCallback) -> size_t {
-        std::lock_guard<std::mutex> lock(searchLock_);
         // Find search
         auto search = searches_.find(key);
         if (search == searches_.end()) {
@@ -933,50 +864,41 @@ DhtProxyClient::handleExpireListener(const asio::error_code &ec, const InfoHash&
 
         if (not deviceKey_.empty()) {
             // UNSUBSCRIBE
-            auto request = std::make_shared<http::Request>(httpContext_, resolver_, logger_);
+            auto request = buildRequest("/" + key.toString());
             auto reqid = request->id();
             try {
-                request->set_target("/" + key.toString());
                 request->set_method(restinio::http_method_unsubscribe());
                 setHeaderFields(*request);
 
                 Json::Value body;
                 body["key"] = deviceKey_;
                 body["client_id"] = pushClientId_;
-                Json::StreamWriterBuilder wbuilder;
-                wbuilder["commentStyle"] = "None";
-                wbuilder["indentation"] = "";
-                auto content = Json::writeString(wbuilder, body) + "\n";
-                std::replace(content.begin(), content.end(), '\n', ' ');
-                request->set_body(content);
-
-                request->add_on_status_callback([this, key](unsigned int status_code){
-                    if (status_code != 200)
-                        if (logger_)
-                            logger_->e("[proxy:client] [unsubscribe %s] failed with code=%i",
-                                       key.to_c_str(), status_code);
-                });
+                request->set_body(Json::writeString(jsonBuilder_, body));
                 request->add_on_state_change_callback([this, reqid, key]
                                                       (http::Request::State state, const http::Response& response){
                     if (state == http::Request::State::DONE){
-                        if (response.status_code != 200)
+                        if (response.status_code != 200) {
                             if (logger_)
                                 logger_->e("[proxy:client] [unsubscribe %s] failed with code=%i",
                                            key.to_c_str(), response.status_code);
-                        requests_.erase(reqid);
+                            if (not response.aborted and response.status_code == 0)
+                                opFailed();
+                        }
+                        if (not isDestroying_) {
+                            std::lock_guard<std::mutex> l(requestLock_);
+                            requests_.erase(reqid);
+                        }
                     }
                 });
-                if (serverCertificate_)
-                    request->set_certificate_authority(serverCertificate_);
-                if (clientIdentity_.first and clientIdentity_.second)
-                    request->set_identity(clientIdentity_);
+                {
+                    std::lock_guard<std::mutex> l(requestLock_);
+                    requests_[reqid] = request;
+                }
                 request->send();
-                requests_[reqid] = request;
             }
             catch (const std::exception &e){
                 if (logger_)
                      logger_->e("[proxy:client] [unsubscribe %s] failed: %s", key.to_c_str(), e.what());
-                requests_.erase(reqid);
             }
         } else {
             // stop the request
@@ -1003,33 +925,26 @@ DhtProxyClient::sendListen(const restinio::http_request_header_t header,
                            const Sp<OperationState>& opstate,
                            Listener& listener, ListenMethod method)
 {
-    auto request = std::make_shared<http::Request>(httpContext_, resolver_, logger_);
-    listener.request = request;
-    auto reqid = request->id();
+    if (logger_)
+        logger_->e("[proxy:client] [listen] sendListen: %d", (int)method);
     try {
+        auto request = buildRequest();
+        listener.request = request;
+        auto reqid = request->id();
         request->set_header(header);
         setHeaderFields(*request);
         if (method == ListenMethod::LISTEN)
             request->set_connection_type(restinio::http_connection_header_t::keep_alive);
-        std::string body;
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
+        std::string body;
         if (method != ListenMethod::LISTEN)
             body = fillBody(method == ListenMethod::RESUBSCRIBE);
-#endif
         request->set_body(body);
+#endif
 
-        request->add_on_status_callback([this, reqid, opstate](unsigned int status_code){
-            if (status_code != 200){
-                if (logger_)
-                    logger_->e("[proxy:client] [listen] send request #%i status error: %i", reqid, status_code);
-                opstate->ok.store(false);
-            }
-        });
         request->add_on_body_callback([this, reqid, opstate, cb](const char* at, size_t length){
             try {
-                Json::CharReaderBuilder rbuilder;
                 auto body = std::string(at, length);
-                std::vector<dht::Sp<dht::Value>> values;
                 // one value per body line
                 std::string data_line;
                 std::stringstream body_stream(body);
@@ -1037,7 +952,7 @@ DhtProxyClient::sendListen(const restinio::http_request_header_t header,
                     std::string err;
                     Json::Value json;
                     auto* char_data = static_cast<const char*>(&data_line[0]);
-                    auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+                    auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
                     if (!reader->parse(char_data, char_data + data_line.size(), &json, &err)){
                         opstate->ok.store(false);
                         return;
@@ -1065,33 +980,40 @@ DhtProxyClient::sendListen(const restinio::http_request_header_t header,
                 opstate->ok.store(false);
             }
         });
-        request->add_on_state_change_callback([this, reqid]
+        request->add_on_state_change_callback([this, opstate, reqid]
                                               (http::Request::State state, const http::Response& response){
             if (state == http::Request::State::DONE){
-                if (response.status_code != 200)
+                if (response.status_code != 200) {
                     if (logger_)
                         logger_->e("[proxy:client] [listen] send request #%i failed with code=%i",
                                    reqid, response.status_code);
-                requests_.erase(reqid);
+                    opstate->ok.store(false);
+                    if (not response.aborted and response.status_code == 0)
+                        opFailed();
+                }
+                if (not isDestroying_) {
+                    std::lock_guard<std::mutex> l(requestLock_);
+                    requests_.erase(reqid);
+                }
             }
         });
-        if (serverCertificate_)
-            request->set_certificate_authority(serverCertificate_);
-        if (clientIdentity_.first and clientIdentity_.second)
-            request->set_identity(clientIdentity_);
+        {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_[reqid] = request;
+        }
         request->send();
-        requests_[reqid] = request;
     }
     catch (const std::exception &e){
         if (logger_)
-            logger_->e("[proxy:client] [listen] request #%i failed: %s", reqid, e.what());
-        requests_.erase(reqid);
+            logger_->e("[proxy:client] [listen] request failed: %s", e.what());
     }
 }
 
 void
 DhtProxyClient::opFailed()
 {
+    if (isDestroying_)
+        return;
     if (logger_)
         logger_->e("[proxy:client] proxy request failed");
     {
@@ -1125,17 +1047,15 @@ DhtProxyClient::restartListeners()
         auto key = search.first;
         for (auto& put : search.second.puts) {
             if (!*put.second.ok) {
-                auto ok = put.second.ok;
-                doPut(key, put.second.value, [ok](bool result, const std::vector<std::shared_ptr<dht::Node>>&){
+                doPut(key, put.second.value, [ok = put.second.ok](bool result){
                     *ok = result;
                 }, time_point::max(), true);
                 if (!put.second.refreshPutTimer){
                     put.second.refreshPutTimer = std::make_unique<asio::steady_timer>(httpContext_);
                 }
-                put.second.refreshPutTimer->expires_at(std::chrono::steady_clock::now() +
-                                                       proxy::OP_TIMEOUT - proxy::OP_MARGIN);
+                put.second.refreshPutTimer->expires_at(std::chrono::steady_clock::now() + proxy::OP_TIMEOUT - proxy::OP_MARGIN);
                 put.second.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this,
-                                                       std::placeholders::_1, key, put.first, put.second.ok));
+                                                        std::placeholders::_1, key, put.first));
             }
         }
     }
@@ -1207,7 +1127,7 @@ DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string
                     put.refreshPutTimer = std::make_unique<asio::steady_timer>(httpContext_, std::chrono::steady_clock::now());
                 else
                     put.refreshPutTimer->expires_at(std::chrono::steady_clock::now());
-                put.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this, std::placeholders::_1, key, vid, put.ok));
+                put.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this, std::placeholders::_1, key, vid));
             } else {
                 // Refresh listen
                 for (auto& list : search.listeners)
@@ -1333,10 +1253,7 @@ DhtProxyClient::fillBody(bool resubscribe)
         // This is the first listen, we want to retrieve previous values.
         body["refresh"] = true;
     }
-    Json::StreamWriterBuilder wbuilder;
-    wbuilder["commentStyle"] = "None";
-    wbuilder["indentation"] = "";
-    auto content = Json::writeString(wbuilder, body) + "\n";
+    auto content = Json::writeString(jsonBuilder_, body) + "\n";
     std::replace(content.begin(), content.end(), '\n', ' ');
     return content;
 }

src/dht_proxy_server.cpp

@@ -71,37 +71,30 @@ constexpr const std::chrono::minutes PRINT_STATS_PERIOD {2};
 class opendht_logger_t
 {
 public:
-    opendht_logger_t(std::shared_ptr<dht::Logger> logger = {}){
-        if (logger)
-            m_logger = logger;
+    opendht_logger_t(std::shared_ptr<Logger> logger = {}) : m_logger(std::move(logger)) {}
+
+    template <typename Builder>
+    void trace(Builder&& /* msg_builder */) {
+        /* if (m_logger) m_logger->d("[proxy:server] %s", msg_builder().c_str()); */
     }
 
     template <typename Builder>
-    void trace(Builder && msg_builder){
-        if (m_logger)
-            m_logger->d("[proxy:server] %s", msg_builder().c_str());
+    void info(Builder&& msg_builder) {
+        if (m_logger) m_logger->d("[proxy:server] %s", msg_builder().c_str());
     }
 
     template <typename Builder>
-    void info(Builder && msg_builder){
-        if (m_logger)
-            m_logger->d("[proxy:server] %s", msg_builder().c_str());
+    void warn(Builder&& msg_builder) {
+        if (m_logger) m_logger->w("[proxy:server] %s", msg_builder().c_str());
     }
 
     template <typename Builder>
-    void warn(Builder && msg_builder){
-        if (m_logger)
-            m_logger->w("[proxy:server] %s", msg_builder().c_str());
-    }
-
-    template <typename Builder>
-    void error(Builder && msg_builder){
-        if (m_logger)
-            m_logger->e("[proxy:server] %s", msg_builder().c_str());
+    void error(Builder&& msg_builder) {
+        if (m_logger) m_logger->e("[proxy:server] %s", msg_builder().c_str());
     }
 
 private:
-    std::shared_ptr<dht::Logger> m_logger;
+    std::shared_ptr<Logger> m_logger;
 };
 
 // connection listener
@@ -110,10 +103,7 @@ class DhtProxyServer::ConnectionListener
 {
 public:
     ConnectionListener() {};
-    ConnectionListener(std::shared_ptr<dht::DhtRunner> dht,
-        std::shared_ptr<std::map<restinio::connection_id_t, http::ListenerSession>> listeners,
-        std::shared_ptr<std::mutex> lock, std::shared_ptr<dht::Logger> logger):
-        dht_(dht), lock_(lock), listeners_(listeners), logger_(logger) {};
+    ConnectionListener(std::function<void(restinio::connection_id_t)> onClosed) : onClosed_(std::move(onClosed)) {};
     ~ConnectionListener() {};
 
     /**
@@ -123,54 +113,28 @@ public:
     void state_changed(const restinio::connection_state::notice_t& notice) noexcept;
 
 private:
-    std::string to_str( restinio::connection_state::cause_t cause ) noexcept;
-
-    std::shared_ptr<dht::DhtRunner> dht_;
-    std::shared_ptr<std::mutex> lock_;
-    std::shared_ptr<std::map<restinio::connection_id_t, http::ListenerSession>> listeners_;
-
-    std::shared_ptr<dht::Logger> logger_;
+    std::function<void(restinio::connection_id_t)> onClosed_;
 };
 
 void
 DhtProxyServer::ConnectionListener::state_changed(const restinio::connection_state::notice_t& notice) noexcept
 {
-    std::lock_guard<std::mutex> lock(*lock_);
-    auto id = notice.connection_id();
-    auto cause = to_str(notice.cause());
-
-    if (listeners_->find(id) != listeners_->end()){
-        if (notice.cause() == restinio::connection_state::cause_t::closed){
-            if (logger_)
-                logger_->d("[proxy:server] [connection:%li] cancelling listener", id);
-            dht_->cancelListen(listeners_->at(id).hash,
-                               std::move(listeners_->at(id).token));
-            listeners_->erase(id);
-            if (logger_)
-                logger_->d("[proxy:server] %li listeners are connected", listeners_->size());
-        }
+    if (restinio::holds_alternative<restinio::connection_state::closed_t>(notice.cause())) {
+        onClosed_(notice.connection_id());
     }
 }
 
-std::string
-DhtProxyServer::ConnectionListener::to_str(restinio::connection_state::cause_t cause) noexcept
+void
+DhtProxyServer::onConnectionClosed(restinio::connection_id_t id)
 {
-    std::string result;
-    switch(cause)
-    {
-    case restinio::connection_state::cause_t::accepted:
-        result = "accepted";
-        break;
-    case restinio::connection_state::cause_t::closed:
-        result = "closed";
-        break;
-    case restinio::connection_state::cause_t::upgraded_to_websocket:
-        result = "upgraded";
-        break;
-    default:
-        result = "unknown";
+    std::lock_guard<std::mutex> lock(lockListener_);
+    auto it = listeners_.find(id);
+    if (it != listeners_.end()) {
+        dht_->cancelListen(it->second.hash, std::move(it->second.token));
+        listeners_.erase(it);
+        if (logger_)
+            logger_->d("[proxy:server] [connection:%li] listener cancelled, %li still connected", id, listeners_.size());
     }
-    return result;
 }
 
 struct DhtProxyServer::RestRouterTraitsTls : public restinio::default_tls_traits_t
@@ -195,13 +159,12 @@ struct DhtProxyServer::RestRouterTraits : public restinio::default_traits_t
 };
 
 DhtProxyServer::DhtProxyServer(
-    dht::crypto::Identity identity,
+    crypto::Identity identity,
     std::shared_ptr<DhtRunner> dht, in_port_t port, const std::string& pushServer,
-    std::shared_ptr<dht::Logger> logger
+    std::shared_ptr<Logger> logger
 )
-    :   dht_(dht), logger_(logger), lockListener_(std::make_shared<std::mutex>()),
-        listeners_(std::make_shared<std::map<restinio::connection_id_t, http::ListenerSession>>()),
-        connListener_(std::make_shared<ConnectionListener>(dht, listeners_, lockListener_, logger)),
+    :   dht_(dht), logger_(logger),
+        connListener_(std::make_shared<ConnectionListener>(std::bind(&DhtProxyServer::onConnectionClosed, this, std::placeholders::_1))),
         pushServer_(pushServer)
 {
     if (not dht_)
@@ -310,6 +273,27 @@ DhtProxyServer::io_context() const
 
 DhtProxyServer::~DhtProxyServer()
 {
+    if (dht_) {
+        std::lock_guard<std::mutex> lock(lockListener_);
+        for (auto& l : listeners_) {
+            dht_->cancelListen(l.second.hash, std::move(l.second.token));
+            if (l.second.response)
+                l.second.response->done();
+        }
+#ifdef OPENDHT_PUSH_NOTIFICATIONS
+        for (auto& lm: pushListeners_)  {
+            for (auto& ls: lm.second.listeners)
+                for (auto& l : ls.second) {
+                    if (l.expireNotifyTimer)
+                        l.expireNotifyTimer->cancel();
+                    if (l.expireTimer)
+                        l.expireTimer->cancel();
+                    dht_->cancelListen(ls.first, std::move(l.internalToken));
+                }
+        }
+        pushListeners_.clear();
+#endif
+    }
     if (logger_)
         logger_->d("[proxy:server] closing http server");
     if (httpServer_)
@@ -365,7 +349,7 @@ DhtProxyServer::updateStats() const
     stats_.pushListenersCount = pushListeners_.size();
 #endif
     stats_.putCount = puts_.size();
-    stats_.listenCount = listeners_->size();
+    stats_.listenCount = listeners_.size();
     stats_.nodeInfo = nodeInfo_;
 }
 
@@ -402,7 +386,6 @@ HttpResponse DhtProxyServer::initHttpResponse(HttpResponse response) const
     response.append_header("Server", "RESTinio");
     response.append_header(restinio::http_field::content_type, "application/json");
     response.append_header(restinio::http_field::access_control_allow_origin, "*");
-    response.connection_keep_alive();
     return response;
 }
 
@@ -490,14 +473,14 @@ DhtProxyServer::getNodeInfo(restinio::request_handle_t request,
     std::lock_guard<std::mutex> lck(statsMutex_);
     if (nodeInfo_.ipv4.good_nodes == 0 &&
         nodeInfo_.ipv6.good_nodes == 0){
-        nodeInfo_ = this->dht_->getNodeInfo();
+        nodeInfo_ = dht_->getNodeInfo();
     }
     result = nodeInfo_.toJson();
     // [ipv6:ipv4]:port or ipv4:port
     result["public_ip"] = request->remote_endpoint().address().to_string();
     auto output = Json::writeString(jsonBuilder_, result) + "\n";
 
-    auto response = this->initHttpResponse(request->create_response());
+    auto response = initHttpResponse(request->create_response());
     response.append_body(output);
     return response.done();
 }
@@ -510,17 +493,17 @@ DhtProxyServer::getStats(restinio::request_handle_t request,
     try {
         if (dht_){
             auto output = Json::writeString(jsonBuilder_, stats_.toJson()) + "\n";
-            auto response = this->initHttpResponse(request->create_response());
+            auto response = initHttpResponse(request->create_response());
             response.append_body(output);
             response.done();
         } else {
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_service_unavailable()));
             response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
             return response.done();
         }
     } catch (...){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -533,22 +516,22 @@ DhtProxyServer::get(restinio::request_handle_t request,
                     restinio::router::route_params_t params)
 {
     requestNum_++;
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
 
     auto response = std::make_shared<ResponseByPartsBuilder>(
-        this->initHttpResponse(request->create_response<ResponseByParts>()));
+        initHttpResponse(request->create_response<ResponseByParts>()));
     response->flush();
     try {
-        dht_->get(infoHash, [this, response](const dht::Sp<dht::Value>& value){
+        dht_->get(infoHash, [this, response](const Sp<Value>& value){
             auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
             response->append_chunk(output);
             response->flush();
@@ -558,7 +541,7 @@ DhtProxyServer::get(restinio::request_handle_t request,
             response->done();
         });
     } catch (const std::exception& e){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -571,27 +554,27 @@ DhtProxyServer::listen(restinio::request_handle_t request,
                        restinio::router::route_params_t params)
 {
     requestNum_++;
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
     auto response = std::make_shared<ResponseByPartsBuilder>(
-        this->initHttpResponse(request->create_response<ResponseByParts>()));
+        initHttpResponse(request->create_response<ResponseByParts>()));
     response->flush();
     try {
-        std::lock_guard<std::mutex> lock(*lockListener_);
+        std::lock_guard<std::mutex> lock(lockListener_);
         // save the listener to handle a disconnect
-        auto &session = (*listeners_)[request->connection_id()];
+        auto &session = listeners_[request->connection_id()];
         session.hash = infoHash;
         session.response = response;
         session.token = dht_->listen(infoHash, [this, response]
-                (const std::vector<dht::Sp<dht::Value>>& values, bool expired){
+                (const std::vector<Sp<Value>>& values, bool expired){
             for (const auto& value: values){
                 auto jsonVal = value->toJson();
                 if (expired)
@@ -604,7 +587,7 @@ DhtProxyServer::listen(restinio::request_handle_t request,
         });
 
     } catch (const std::exception& e){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -620,12 +603,12 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
 {
     requestNum_++;
 
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
@@ -633,18 +616,17 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
     try {
         std::string err;
         Json::Value root;
-        Json::CharReaderBuilder rbuilder;
         auto* char_data = reinterpret_cast<const char*>(request->body().data());
-        auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
         if (!reader->parse(char_data, char_data + request->body().size(), &root, &err)){
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_JSON_INCORRECT);
             return response.done();
         }
         auto pushToken = root["key"].asString();
         if (pushToken.empty()){
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_NO_TOKEN);
             return response.done();
@@ -674,11 +656,11 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
                 listener.expireNotifyTimer->expires_at(timeout - proxy::OP_MARGIN);
                 // Send response header
                 auto response = std::make_shared<ResponseByPartsBuilder>(
-                    this->initHttpResponse(request->create_response<ResponseByParts>()));
+                    initHttpResponse(request->create_response<ResponseByParts>()));
                 response->flush();
                 // No Refresh
                 if (!root.isMember("refresh") or !root["refresh"].asBool()){
-                    dht_->get(infoHash, [this, response](const dht::Sp<dht::Value>& value){
+                    dht_->get(infoHash, [this, response](const Sp<Value>& value){
                         auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
                         response->append_chunk(output);
                         response->flush();
@@ -740,12 +722,12 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
             listener.expireTimer->expires_at(timeout);
         listener.expireTimer->async_wait(std::bind(&DhtProxyServer::handleCancelPushListen, this,
                                          std::placeholders::_1, pushToken, infoHash, clientId));
-        auto response = this->initHttpResponse(request->create_response());
+        auto response = initHttpResponse(request->create_response());
         response.set_body("{}\n");
         return response.done();
     }
     catch (...) {
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -759,12 +741,12 @@ DhtProxyServer::unsubscribe(restinio::request_handle_t request,
 {
     requestNum_++;
 
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
@@ -775,12 +757,11 @@ DhtProxyServer::unsubscribe(restinio::request_handle_t request,
     try {
         std::string err;
         Json::Value root;
-        Json::CharReaderBuilder rbuilder;
         auto* char_data = reinterpret_cast<const char*>(request->body().data());
-        auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
 
         if (!reader->parse(char_data, char_data + request->body().size(), &root, &err)){
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_JSON_INCORRECT);
             return response.done();
@@ -791,11 +772,11 @@ DhtProxyServer::unsubscribe(restinio::request_handle_t request,
         auto clientId = root["client_id"].asString();
 
         handleCancelPushListen(asio::error_code() /*success*/, pushToken, infoHash, clientId);
-        auto response = this->initHttpResponse(request->create_response());
+        auto response = initHttpResponse(request->create_response());
         return response.done();
     }
     catch (...) {
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -819,7 +800,7 @@ DhtProxyServer::handleNotifyPushListenExpire(const asio::error_code &ec, const s
 
 void
 DhtProxyServer::handleCancelPushListen(const asio::error_code &ec, const std::string pushToken,
-                                       const dht::InfoHash key, const std::string clientId)
+                                       const InfoHash key, const std::string clientId)
 {
     if (ec == asio::error::operation_aborted)
         return;
@@ -831,7 +812,7 @@ DhtProxyServer::handleCancelPushListen(const asio::error_code &ec, const std::st
     if (logger_)
         logger_->d("[proxy:server] [listen:push %s] cancelled for %s",
                    key.toString().c_str(), clientId.c_str());
-    std::lock_guard<std::mutex> lock(*lockListener_);
+    std::lock_guard<std::mutex> lock(lockListener_);
 
     auto pushListener = pushListeners_.find(pushToken);
     if (pushListener == pushListeners_.end())
@@ -861,13 +842,13 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
     if (pushServer_.empty())
         return;
 
-    auto request = std::make_shared<http::Request>(io_context(), pushHostPort_.first, pushHostPort_.second,
-                                                                 httpsServer_ ? true : false, logger_);
-    auto reqid = request->id();
+    unsigned reqid = 0;
     try {
+        auto request = std::make_shared<http::Request>(io_context(), pushHostPort_.first, pushHostPort_.second,
+                                                                    httpsServer_ ? true : false, logger_);
+        reqid = request->id();
         request->set_target("/api/push");
         request->set_method(restinio::http_method_post());
-
         request->set_header_field(restinio::http_field_t::host, pushServer_.c_str());
         request->set_header_field(restinio::http_field_t::user_agent, "RESTinio client");
         request->set_header_field(restinio::http_field_t::accept, "*/*");
@@ -888,29 +869,29 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
 
         Json::Value content;
         content["notifications"] = std::move(notifications);
-
-        Json::StreamWriterBuilder wbuilder;
-        wbuilder["commentStyle"] = "None";
-        wbuilder["indentation"] = "";
-
-        auto body = Json::writeString(wbuilder, content);
-        request->set_body(body);
-
+        request->set_body(Json::writeString(jsonBuilder_, content));
         request->add_on_state_change_callback([this, reqid]
-                                              (const http::Request::State state, const http::Response response){
+                                              (http::Request::State state, const http::Response& response){
             if (state == http::Request::State::DONE){
                 if (logger_ and response.status_code != 200)
                     logger_->e("[proxy:server] [notification] push failed: %i", response.status_code);
+                std::lock_guard<std::mutex> l(requestLock_);
                 requests_.erase(reqid);
             }
         });
+        {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_[reqid] = request;
+        }
         request->send();
-        requests_[reqid] = request;
     }
     catch (const std::exception &e){
         if (logger_)
             logger_->e("[proxy:server] [notification] error send push: %i", e.what());
-        requests_.erase(reqid);
+        if (reqid) {
+            std::lock_guard<std::mutex> l(requestLock_);
+            requests_.erase(reqid);
+        }
     }
 }
 
@@ -948,19 +929,17 @@ DhtProxyServer::put(restinio::request_handle_t request,
                     restinio::router::route_params_t params)
 {
     requestNum_++;
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
-            request->create_response(restinio::status_service_unavailable()));
+        auto response = initHttpResponse(request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
     else if (request->body().empty()){
-        auto response = this->initHttpResponse(
-            request->create_response(restinio::status_bad_request()));
+        auto response = initHttpResponse(request->create_response(restinio::status_bad_request()));
         response.set_body(RESP_MSG_MISSING_PARAMS);
         return response.done();
     }
@@ -968,12 +947,11 @@ DhtProxyServer::put(restinio::request_handle_t request,
     try {
         std::string err;
         Json::Value root;
-        Json::CharReaderBuilder rbuilder;
         auto* char_data = reinterpret_cast<const char*>(request->body().data());
-        auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
 
         if (reader->parse(char_data, char_data + request->body().size(), &root, &err)){
-            auto value = std::make_shared<dht::Value>(root);
+            auto value = std::make_shared<Value>(root);
             bool permanent = root.isMember("permanent");
             if (logger_)
                 logger_->d("[proxy:server] [put %s] %s %s", infoHash.toString().c_str(),
@@ -1029,18 +1007,18 @@ DhtProxyServer::put(restinio::request_handle_t request,
             dht_->put(infoHash, value, [this, request, value](bool ok){
                 if (ok){
                     auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
-                    auto response = this->initHttpResponse(request->create_response());
+                    auto response = initHttpResponse(request->create_response());
                     response.append_body(output);
                     response.done();
                 } else {
-                    auto response = this->initHttpResponse(request->create_response(
+                    auto response = initHttpResponse(request->create_response(
                         restinio::status_bad_gateway()));
                     response.set_body(RESP_MSG_PUT_FAILED);
                     response.done();
                 }
-            }, dht::time_point::max(), permanent);
+            }, time_point::max(), permanent);
         } else {
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_JSON_INCORRECT);
             return response.done();
@@ -1048,7 +1026,7 @@ DhtProxyServer::put(restinio::request_handle_t request,
     } catch (const std::exception& e){
         if (logger_)
             logger_->d("[proxy:server] error in put: %s", e.what());
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -1058,22 +1036,23 @@ DhtProxyServer::put(restinio::request_handle_t request,
 
 #ifdef OPENDHT_PROXY_SERVER_IDENTITY
 
-RequestStatus DhtProxyServer::putSigned(restinio::request_handle_t request,
-                                        restinio::router::route_params_t params) const
+RequestStatus
+DhtProxyServer::putSigned(restinio::request_handle_t request,
+                          restinio::router::route_params_t params) const
 {
     requestNum_++;
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
-    if (!dht_){
-        auto response = this->initHttpResponse(
+    if (!dht_) {
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
     else if (request->body().empty()){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_bad_request()));
         response.set_body(RESP_MSG_MISSING_PARAMS);
         return response.done();
@@ -1082,9 +1061,8 @@ RequestStatus DhtProxyServer::putSigned(restinio::request_handle_t request,
     try {
         std::string err;
         Json::Value root;
-        Json::CharReaderBuilder rbuilder;
         auto* char_data = reinterpret_cast<const char*>(request->body().data());
-        auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
 
         if (reader->parse(char_data, char_data + request->body().size(), &root, &err)){
 
@@ -1093,18 +1071,18 @@ RequestStatus DhtProxyServer::putSigned(restinio::request_handle_t request,
             dht_->putSigned(infoHash, value, [this, request, value](bool ok){
                 if (ok){
                     auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
-                    auto response = this->initHttpResponse(request->create_response());
+                    auto response = initHttpResponse(request->create_response());
                     response.append_body(output);
                     response.done();
                 } else {
-                    auto response = this->initHttpResponse(request->create_response(
+                    auto response = initHttpResponse(request->create_response(
                         restinio::status_bad_gateway()));
                     response.set_body(RESP_MSG_PUT_FAILED);
                     response.done();
                 }
             });
         } else {
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_JSON_INCORRECT);
             return response.done();
@@ -1112,7 +1090,7 @@ RequestStatus DhtProxyServer::putSigned(restinio::request_handle_t request,
     } catch (const std::exception& e){
         if (logger_)
             logger_->d("[proxy:server] error in put: %s", e.what());
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -1125,18 +1103,18 @@ DhtProxyServer::putEncrypted(restinio::request_handle_t request,
                              restinio::router::route_params_t params)
 {
     requestNum_++;
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
     else if (request->body().empty()){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_bad_request()));
         response.set_body(RESP_MSG_MISSING_PARAMS);
         return response.done();
@@ -1145,14 +1123,13 @@ DhtProxyServer::putEncrypted(restinio::request_handle_t request,
     try {
         std::string err;
         Json::Value root;
-        Json::CharReaderBuilder rbuilder;
         auto* char_data = reinterpret_cast<const char*>(request->body().data());
-        auto reader = std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
+        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
 
         if (reader->parse(char_data, char_data + request->body().size(), &root, &err)){
             InfoHash to(root["to"].asString());
             if (!to){
-                auto response = this->initHttpResponse(
+                auto response = initHttpResponse(
                     request->create_response(restinio::status_bad_request()));
                 response.set_body(RESP_MSG_DESTINATION_NOT_FOUND);
                 return response.done();
@@ -1161,18 +1138,18 @@ DhtProxyServer::putEncrypted(restinio::request_handle_t request,
             dht_->putEncrypted(infoHash, to, value, [this, request, value](bool ok){
                 if (ok){
                     auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
-                    auto response = this->initHttpResponse(request->create_response());
+                    auto response = initHttpResponse(request->create_response());
                     response.append_body(output);
                     response.done();
                 } else {
-                    auto response = this->initHttpResponse(request->create_response(
+                    auto response = initHttpResponse(request->create_response(
                         restinio::status_bad_gateway()));
                     response.set_body(RESP_MSG_PUT_FAILED);
                     response.done();
                 }
             });
         } else {
-            auto response = this->initHttpResponse(
+            auto response = initHttpResponse(
                 request->create_response(restinio::status_bad_request()));
             response.set_body(RESP_MSG_JSON_INCORRECT);
             return response.done();
@@ -1180,7 +1157,7 @@ DhtProxyServer::putEncrypted(restinio::request_handle_t request,
     } catch (const std::exception& e){
         if (logger_)
             logger_->d("[proxy:server] error in put: %s", e.what());
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();
@@ -1194,7 +1171,7 @@ RequestStatus
 DhtProxyServer::options(restinio::request_handle_t request,
                         restinio::router::route_params_t /*params*/)
 {
-    this->requestNum_++;
+    requestNum_++;
 #ifdef OPENDHT_PROXY_SERVER_IDENTITY
     const auto methods = "OPTIONS, GET, POST, LISTEN, SIGN, ENCRYPT";
 #else
@@ -1213,34 +1190,33 @@ DhtProxyServer::getFiltered(restinio::request_handle_t request,
 {
     requestNum_++;
     auto value = params["value"].to_string();
-    dht::InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"].to_string());
     if (!infoHash)
-        infoHash = dht::InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"].to_string());
 
     if (!dht_){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_service_unavailable()));
         response.set_body(RESP_MSG_SERVICE_UNAVAILABLE);
         return response.done();
     }
 
     auto response = std::make_shared<ResponseByPartsBuilder>(
-        this->initHttpResponse(request->create_response<ResponseByParts>()));
+        initHttpResponse(request->create_response<ResponseByParts>()));
     response->flush();
     try {
-        dht_->get(infoHash, [this, response](const dht::Sp<dht::Value>& value){
-            auto output = Json::writeString(jsonBuilder_, value->toJson()) + "\n";
-            response->append_chunk(output);
-            response->flush();
-            return true;
-        },
-        [response] (bool /*ok*/){
-            response->done();
-        },
-            {}, value
-        );
+        dht_->get(infoHash,
+            [this, response](const Sp<Value>& value) {
+                response->append_chunk(Json::writeString(jsonBuilder_, value->toJson()) + "\n");
+                response->flush();
+                return true;
+            },
+            [response] (bool /*ok*/){
+                response->done();
+            },
+            {}, value);
     } catch (const std::exception& e){
-        auto response = this->initHttpResponse(
+        auto response = initHttpResponse(
             request->create_response(restinio::status_internal_server_error()));
         response.set_body(RESP_MSG_INTERNAL_SERVER_ERRROR);
         return response.done();

src/dhtrunner.cpp

@@ -100,7 +100,7 @@ DhtRunner::run(const char* ip4, const char* ip6, const char* service, const Conf
 void
 DhtRunner::run(const SockAddr& local4, const SockAddr& local6, const Config& config, Context&& context)
 {
-    if (not running) {
+    if (running == State::Idle) {
         if (not context.sock)
             context.sock.reset(new net::UdpSocket(local4, local6, context.logger ? *context.logger : Logger{}));
         run(config, std::move(context));
@@ -111,11 +111,14 @@ void
 DhtRunner::run(const Config& config, Context&& context)
 {
     std::lock_guard<std::mutex> lck(dht_mtx);
-    if (running)
+    auto expected = State::Idle;
+    if (not running.compare_exchange_strong(expected, State::Running))
         return;
 
-    if (context.logger)
+    if (context.logger) {
         logger_ = context.logger;
+        logger_->d("[runner %p] state changed to Running", this);
+    }
 
     context.sock->setOnReceive([&] (std::unique_ptr<net::ReceivedPacket>&& pkt) {
         {
@@ -148,16 +151,15 @@ DhtRunner::run(const Config& config, Context&& context)
             dht_via_proxy_->setLocalCertificateStore(std::move(context.certificateStore));
     }
 
-    running = true;
     if (not config.threaded)
         return;
     dht_thread = std::thread([this]() {
-        while (running) {
+        while (running != State::Idle) {
             std::unique_lock<std::mutex> lk(dht_mtx);
             time_point wakeup = loop_();
 
             auto hasJobToDo = [this]() {
-                if (not running)
+                if (running == State::Idle)
                     return true;
                 {
                     std::lock_guard<std::mutex> lck(sock_mtx);
@@ -219,36 +221,84 @@ DhtRunner::run(const Config& config, Context&& context)
 
 void
 DhtRunner::shutdown(ShutdownCallback cb) {
-    if (not running) {
-        cb();
+    auto expected = State::Running;
+    if (not running.compare_exchange_strong(expected, State::Stopping)) {
+        if (expected == State::Stopping and ongoing_ops) {
+            std::lock_guard<std::mutex> lck(storage_mtx);
+            shutdownCallbacks_.emplace_back(std::move(cb));
+        }
+        else if (cb) cb();
         return;
     }
+    if (logger_)
+        logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", this, ongoing_ops.load());
     std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    shutdownCallbacks_.emplace_back(std::move(cb));
     pending_ops_prio.emplace([=](SecureDht&) mutable {
+        auto onShutdown = [this]{ opEnded(); };
 #ifdef OPENDHT_PROXY_CLIENT
         if (dht_via_proxy_)
-            dht_via_proxy_->shutdown(cb);
+            dht_via_proxy_->shutdown(onShutdown);
 #endif
         if (dht_)
-            dht_->shutdown(cb);
+            dht_->shutdown(onShutdown);
     });
     cv.notify_all();
 }
 
+void
+DhtRunner::opEnded() {
+    if (--ongoing_ops == 0)
+        checkShutdown();
+}
+
+DoneCallback
+DhtRunner::bindOpDoneCallback(DoneCallback&& cb) {
+    return [this, cb = std::move(cb)](bool ok, const std::vector<std::shared_ptr<Node>>& nodes){
+        if (cb) cb(ok, nodes);
+        opEnded();
+    };
+}
+
+DoneCallbackSimple
+DhtRunner::bindOpDoneCallback(DoneCallbackSimple&& cb) {
+    return [this, cb = std::move(cb)](bool ok){
+        if (cb) cb(ok);
+        opEnded();
+    };
+}
+
+bool
+DhtRunner::checkShutdown() {
+    if (running != State::Stopping or ongoing_ops)
+        return false;
+    decltype(shutdownCallbacks_) cbs;
+    {
+        std::lock_guard<std::mutex> lck(storage_mtx);
+        cbs = std::move(shutdownCallbacks_);
+    }
+    for (auto& cb : cbs)
+        if (cb) cb();
+    return true;
+}
+
 void
 DhtRunner::join()
 {
-    if (peerDiscovery_)
-        peerDiscovery_->stop();
-
     {
         std::lock_guard<std::mutex> lck(dht_mtx);
-        running = false;
+        if (running.exchange(State::Idle) == State::Idle)
+            return;
         cv.notify_all();
         bootstrap_cv.notify_all();
+        if (peerDiscovery_)
+            peerDiscovery_->stop();
         if (dht_)
             if (auto sock = dht_->getSocket())
                 sock->stop();
+        if (logger_)
+            logger_->d("[runner %p] state changed to Idle", this);
     }
 
     if (dht_thread.joinable())
@@ -257,14 +307,14 @@ DhtRunner::join()
     if (bootstrap_thread.joinable())
         bootstrap_thread.join();
 
-    if (peerDiscovery_) {
+    if (peerDiscovery_)
         peerDiscovery_->join();
-    }
 
     {
         std::lock_guard<std::mutex> lck(storage_mtx);
         pending_ops = decltype(pending_ops)();
         pending_ops_prio = decltype(pending_ops_prio)();
+        ongoing_ops = 0;
     }
     {
         std::lock_guard<std::mutex> lck(dht_mtx);
@@ -283,6 +333,15 @@ DhtRunner::getBound(sa_family_t af) const {
     return SockAddr{};
 }
 
+in_port_t
+DhtRunner::getBoundPort(sa_family_t af) const {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (dht_)
+        if (auto sock = dht_->getSocket())
+            return sock->getPort(af);
+    return 0;
+}
+
 void
 DhtRunner::dumpTables() const
 {
@@ -409,6 +468,7 @@ DhtRunner::getNodeInfo() const {
     NodeInfo info;
     info.id = getId();
     info.node_id = getNodeId();
+    info.ongoing_ops = ongoing_ops;
     info.ipv4 = dht_->getNodesStats(AF_INET);
     info.ipv6 = dht_->getNodesStats(AF_INET6);
     return info;
@@ -563,12 +623,15 @@ DhtRunner::loop_()
 void
 DhtRunner::get(InfoHash hash, GetCallback vcb, DoneCallback dcb, Value::Filter f, Where w)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) mutable {
-            dht.get(hash, std::move(vcb), std::move(dcb), std::move(f), std::move(w));
-        });
+    if (running != State::Running) {
+        if (dcb) dcb(false, {});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    pending_ops.emplace([=](SecureDht& dht) mutable {
+        dht.get(hash, std::move(vcb), bindOpDoneCallback(std::move(dcb)), std::move(f), std::move(w));
+    });
     cv.notify_all();
 }
 
@@ -579,12 +642,15 @@ DhtRunner::get(const std::string& key, GetCallback vcb, DoneCallbackSimple dcb,
 }
 void
 DhtRunner::query(const InfoHash& hash, QueryCallback cb, DoneCallback done_cb, Query q) {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) mutable {
-            dht.query(hash, std::move(cb), std::move(done_cb), std::move(q));
-        });
+    if (running != State::Running) {
+        if (done_cb) done_cb(false, {});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    pending_ops.emplace([=](SecureDht& dht) mutable {
+        dht.query(hash, std::move(cb), bindOpDoneCallback(std::move(done_cb)), std::move(q));
+    });
     cv.notify_all();
 }
 
@@ -592,32 +658,34 @@ std::future<size_t>
 DhtRunner::listen(InfoHash hash, ValueCallback vcb, Value::Filter f, Where w)
 {
     auto ret_token = std::make_shared<std::promise<size_t>>();
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) mutable {
-#ifdef OPENDHT_PROXY_CLIENT
-            auto tokenbGlobal = listener_token_++;
-            auto& listener = listeners_[tokenbGlobal];
-            listener.hash = hash;
-            listener.f = std::move(f);
-            listener.w = std::move(w);
-            listener.gcb = [hash,vcb,tokenbGlobal,this](const std::vector<Sp<Value>>& vals, bool expired) {
-                if (not vcb(vals, expired)) {
-                    cancelListen(hash, tokenbGlobal);
-                    return false;
-                }
-                return true;
-            };
-            if (auto token = dht.listen(hash, listener.gcb, listener.f, listener.w)) {
-                if (use_proxy)  listener.tokenProxyDht = token;
-                else            listener.tokenClassicDht = token;
-            }
-            ret_token->set_value(tokenbGlobal);
-#else
-            ret_token->set_value(dht.listen(hash, std::move(vcb), std::move(f), std::move(w)));
-#endif
-        });
+    if (running != State::Running) {
+        ret_token->set_value(0);
+        return ret_token->get_future();
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    pending_ops.emplace([=](SecureDht& dht) mutable {
+#ifdef OPENDHT_PROXY_CLIENT
+        auto tokenbGlobal = listener_token_++;
+        auto& listener = listeners_[tokenbGlobal];
+        listener.hash = hash;
+        listener.f = std::move(f);
+        listener.w = std::move(w);
+        listener.gcb = [hash,vcb,tokenbGlobal,this](const std::vector<Sp<Value>>& vals, bool expired) {
+            if (not vcb(vals, expired)) {
+                cancelListen(hash, tokenbGlobal);
+                return false;
+            }
+            return true;
+        };
+        if (auto token = dht.listen(hash, listener.gcb, listener.f, listener.w)) {
+            if (use_proxy)  listener.tokenProxyDht = token;
+            else            listener.tokenClassicDht = token;
+        }
+        ret_token->set_value(tokenbGlobal);
+#else
+        ret_token->set_value(dht.listen(hash, std::move(vcb), std::move(f), std::move(w)));
+#endif
+    });
     cv.notify_all();
     return ret_token->get_future();
 }
@@ -631,73 +699,77 @@ DhtRunner::listen(const std::string& key, GetCallback vcb, Value::Filter f, Wher
 void
 DhtRunner::cancelListen(InfoHash h, size_t token)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
+    std::lock_guard<std::mutex> lck(storage_mtx);
 #ifdef OPENDHT_PROXY_CLIENT
-        pending_ops.emplace([=](SecureDht&) {
-            auto it = listeners_.find(token);
-            if (it == listeners_.end()) return;
-            if (it->second.tokenClassicDht)
-                dht_->cancelListen(h, it->second.tokenClassicDht);
-            if (it->second.tokenProxyDht and dht_via_proxy_)
-                dht_via_proxy_->cancelListen(h, it->second.tokenProxyDht);
-            listeners_.erase(it);
-        });
+    pending_ops.emplace([=](SecureDht&) {
+        auto it = listeners_.find(token);
+        if (it == listeners_.end()) return;
+        if (it->second.tokenClassicDht)
+            dht_->cancelListen(h, it->second.tokenClassicDht);
+        if (it->second.tokenProxyDht and dht_via_proxy_)
+            dht_via_proxy_->cancelListen(h, it->second.tokenProxyDht);
+        listeners_.erase(it);
+    });
 #else
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.cancelListen(h, token);
-        });
+    pending_ops.emplace([=](SecureDht& dht) {
+        dht.cancelListen(h, token);
+    });
 #endif // OPENDHT_PROXY_CLIENT
-    }
     cv.notify_all();
 }
 
 void
 DhtRunner::cancelListen(InfoHash h, std::shared_future<size_t> ftoken)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
+    std::lock_guard<std::mutex> lck(storage_mtx);
 #ifdef OPENDHT_PROXY_CLIENT
-        pending_ops.emplace([=](SecureDht&) {
-            auto it = listeners_.find(ftoken.get());
-            if (it == listeners_.end()) return;
-            if (it->second.tokenClassicDht)
-                dht_->cancelListen(h, it->second.tokenClassicDht);
-            if (it->second.tokenProxyDht and dht_via_proxy_)
-                dht_via_proxy_->cancelListen(h, it->second.tokenProxyDht);
-            listeners_.erase(it);
-        });
+    pending_ops.emplace([=](SecureDht&) {
+        auto it = listeners_.find(ftoken.get());
+        if (it == listeners_.end()) return;
+        if (it->second.tokenClassicDht)
+            dht_->cancelListen(h, it->second.tokenClassicDht);
+        if (it->second.tokenProxyDht and dht_via_proxy_)
+            dht_via_proxy_->cancelListen(h, it->second.tokenProxyDht);
+        listeners_.erase(it);
+    });
 #else
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.cancelListen(h, ftoken.get());
-        });
+    pending_ops.emplace([=](SecureDht& dht) {
+        dht.cancelListen(h, ftoken.get());
+    });
 #endif // OPENDHT_PROXY_CLIENT
-    }
     cv.notify_all();
 }
 
 void
 DhtRunner::put(InfoHash hash, Value&& value, DoneCallback cb, time_point created, bool permanent)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        auto sv = std::make_shared<Value>(std::move(value));
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.put(hash, sv, cb, created, permanent);
-        });
+    if (running != State::Running) {
+        if (cb) cb(false, {});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    pending_ops.emplace([=,
+        cb = std::move(cb),
+        sv = std::make_shared<Value>(std::move(value))
+    ] (SecureDht& dht) mutable {
+        dht.put(hash, sv, bindOpDoneCallback(std::move(cb)), created, permanent);
+    });
     cv.notify_all();
 }
 
 void
 DhtRunner::put(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb, time_point created, bool permanent)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.put(hash, value, cb, created, permanent);
-        });
+    if (running != State::Running) {
+        if (cb) cb(false, {});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    pending_ops.emplace([=, cb = std::move(cb)](SecureDht& dht) mutable {
+        dht.put(hash, value, bindOpDoneCallback(std::move(cb)), created, permanent);
+    });
     cv.notify_all();
 }
 
@@ -708,63 +780,83 @@ DhtRunner::put(const std::string& key, Value&& value, DoneCallbackSimple cb, tim
 }
 
 void
-DhtRunner::cancelPut(const InfoHash& h , const Value::Id& id)
+DhtRunner::cancelPut(const InfoHash& h, Value::Id id)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.cancelPut(h, id);
-        });
-    }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    pending_ops.emplace([=](SecureDht& dht) {
+        dht.cancelPut(h, id);
+    });
     cv.notify_all();
 }
 
 void
-DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb)
+DhtRunner::cancelPut(const InfoHash& h, const std::shared_ptr<Value>& value)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.putSigned(hash, value, cb);
-        });
-    }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    pending_ops.emplace([=](SecureDht& dht) {
+        dht.cancelPut(h, value->id);
+    });
     cv.notify_all();
 }
 
 void
-DhtRunner::putSigned(InfoHash hash, Value&& value, DoneCallback cb)
+DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
 {
-    putSigned(hash, std::make_shared<Value>(std::move(value)), std::move(cb));
-}
-
-void
-DhtRunner::putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb)
-{
-    putSigned(InfoHash::get(key), std::forward<Value>(value), std::move(cb));
-}
-
-void
-DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb)
-{
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.putEncrypted(hash, to, value, cb);
-        });
+    if (running != State::Running) {
+        if (cb) cb(false, {});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    ongoing_ops++;
+    pending_ops.emplace([=,
+        cb = std::move(cb),
+        value = std::move(value)
+    ](SecureDht& dht) mutable {
+        dht.putSigned(hash, value, bindOpDoneCallback(std::move(cb)), permanent);
+    });
     cv.notify_all();
 }
 
 void
-DhtRunner::putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb)
+DhtRunner::putSigned(InfoHash hash, Value&& value, DoneCallback cb, bool permanent)
 {
-    putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb));
+    putSigned(hash, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
 }
 
 void
-DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb)
+DhtRunner::putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb, bool permanent)
 {
-    putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), std::move(cb));
+    putSigned(InfoHash::get(key), std::forward<Value>(value), std::move(cb), permanent);
+}
+
+void
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
+{
+    if (running != State::Running) {
+        if (cb) cb(false, {});
+        return;
+    }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    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
@@ -796,7 +888,7 @@ DhtRunner::tryBootstrapContinuously()
                     ++ping_count;
                     try {
                         bootstrap(SockAddr::resolve(it->first, it->second), [&](bool) {
-                            if (not running)
+                            if (running != State::Running)
                                 return;
                             {
                                 std::unique_lock<std::mutex> blck(mtx);
@@ -810,15 +902,15 @@ DhtRunner::tryBootstrapContinuously()
                     }
                 }
                 // wait at least until the next BOOTSTRAP_PERIOD
-                bootstrap_cv.wait_until(blck, next, [&]() { return not running; });
+                bootstrap_cv.wait_until(blck, next, [&]() { return running != State::Running; });
                 // wait for bootstrap requests to end.
-                if (running)
-                   bootstrap_cv.wait(blck, [&]() { return not running or ping_count == 0; });
+                if (running != State::Running)
+                   bootstrap_cv.wait(blck, [&]() { return running != State::Running or ping_count == 0; });
             }
             // update state
             {
                 std::lock_guard<std::mutex> lck(dht_mtx);
-                bootstraping = running and
+                bootstraping = running == State::Running and
                                status4 == NodeStatus::Disconnected and
                                status6 == NodeStatus::Disconnected;
             }
@@ -855,19 +947,28 @@ DhtRunner::clearBootstrap()
 void
 DhtRunner::bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple&& cb)
 {
+    if (running != State::Running) {
+        cb(false);
+        return;
+    }
     std::lock_guard<std::mutex> lck(storage_mtx);
-    pending_ops_prio.emplace([=](SecureDht& dht) mutable {
+    ongoing_ops++;
+    pending_ops_prio.emplace([
+        cb = bindOpDoneCallback(std::move(cb)),
+        nodes = std::move(nodes)
+    ] (SecureDht& dht) mutable {
         auto rem = cb ? std::make_shared<std::pair<size_t, bool>>(nodes.size(), false) : nullptr;
         for (auto& node : nodes) {
             if (node.getPort() == 0)
                 node.setPort(net::DHT_DEFAULT_PORT);
-            dht.pingNode(std::move(node), cb ? [rem,cb](bool ok) {
+            dht.pingNode(std::move(node), [rem,cb](bool ok) {
                 auto& r = *rem;
                 r.first--;
                 r.second |= ok;
-                if (not r.first)
+                if (r.first == 0) {
                     cb(r.second);
-            } : DoneCallbackSimple{});
+                }
+            });
         }
     });
     cv.notify_all();
@@ -876,8 +977,13 @@ DhtRunner::bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple&& cb)
 void
 DhtRunner::bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb)
 {
+    if (running != State::Running) {
+        if (cb) cb(false);
+        return;
+    }
     std::lock_guard<std::mutex> lck(storage_mtx);
-    pending_ops_prio.emplace([addr, cb](SecureDht& dht) mutable {
+    ongoing_ops++;
+    pending_ops_prio.emplace([addr, cb = bindOpDoneCallback(std::move(cb))](SecureDht& dht) mutable {
         dht.pingNode(std::move(addr), std::move(cb));
     });
     cv.notify_all();
@@ -886,48 +992,52 @@ DhtRunner::bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb)
 void
 DhtRunner::bootstrap(const InfoHash& id, const SockAddr& address)
 {
-    {
-        std::unique_lock<std::mutex> lck(storage_mtx);
-        pending_ops_prio.emplace([id, address](SecureDht& dht) mutable {
-            dht.insertNode(id, address);
-        });
-    }
+    if (running != State::Running)
+        return;
+    std::unique_lock<std::mutex> lck(storage_mtx);
+    pending_ops_prio.emplace([id, address](SecureDht& dht) mutable {
+        dht.insertNode(id, address);
+    });
     cv.notify_all();
 }
 
 void
 DhtRunner::bootstrap(const std::vector<NodeExport>& nodes)
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops_prio.emplace([=](SecureDht& dht) {
-            for (auto& node : nodes)
-                dht.insertNode(node);
-        });
-    }
+    if (running != State::Running)
+        return;
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    pending_ops_prio.emplace([=](SecureDht& dht) {
+        for (auto& node : nodes)
+            dht.insertNode(node);
+    });
     cv.notify_all();
 }
 
 void
 DhtRunner::connectivityChanged()
 {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops_prio.emplace([=](SecureDht& dht) {
-            dht.connectivityChanged();
-        });
-    }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    pending_ops_prio.emplace([=](SecureDht& dht) {
+        dht.connectivityChanged();
+    });
     cv.notify_all();
 }
 
 void
-DhtRunner::findCertificate(InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>)> cb) {
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        pending_ops.emplace([=](SecureDht& dht) {
-            dht.findCertificate(hash, cb);
-        });
+DhtRunner::findCertificate(InfoHash hash, std::function<void(const Sp<crypto::Certificate>&)> cb) {
+    if (running != State::Running) {
+        cb({});
+        return;
     }
+    std::lock_guard<std::mutex> lck(storage_mtx);
+    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();
 }
 

src/network_engine.cpp

@@ -41,7 +41,6 @@ constexpr std::chrono::seconds NetworkEngine::RX_MAX_PACKET_TIME;
 constexpr std::chrono::seconds NetworkEngine::RX_TIMEOUT;
 
 const std::string NetworkEngine::my_v {"RNG1"};
-constexpr size_t NetworkEngine::MAX_REQUESTS_PER_SEC;
 
 static constexpr uint8_t v4prefix[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0, 0, 0, 0};
 
@@ -100,10 +99,10 @@ RequestAnswer::RequestAnswer(ParsedMessage&& msg)
 {}
 
 NetworkEngine::NetworkEngine(Logger& log, Scheduler& scheduler, std::unique_ptr<DatagramSocket>&& sock)
-    : myid(zeroes), dht_socket(std::move(sock)), DHT_LOG(log), scheduler(scheduler)
+    : myid(zeroes), dht_socket(std::move(sock)), DHT_LOG(log), rate_limiter((size_t)-1), scheduler(scheduler)
 {}
 
-NetworkEngine::NetworkEngine(InfoHash& myid, NetId net, std::unique_ptr<DatagramSocket>&& sock, Logger& log, Scheduler& scheduler,
+NetworkEngine::NetworkEngine(InfoHash& myid, NetworkConfig c, std::unique_ptr<DatagramSocket>&& sock, Logger& log, Scheduler& scheduler,
         decltype(NetworkEngine::onError)&& onError,
         decltype(NetworkEngine::onNewNode)&& onNewNode,
         decltype(NetworkEngine::onReportedAddr)&& onReportedAddr,
@@ -122,7 +121,9 @@ NetworkEngine::NetworkEngine(InfoHash& myid, NetId net, std::unique_ptr<Datagram
     onListen(std::move(onListen)),
     onAnnounce(std::move(onAnnounce)),
     onRefresh(std::move(onRefresh)),
-    myid(myid), network(net), dht_socket(std::move(sock)), DHT_LOG(log), scheduler(scheduler)
+    myid(myid), config(c), dht_socket(std::move(sock)), DHT_LOG(log),
+    rate_limiter(config.max_req_per_sec),
+    scheduler(scheduler)
 {}
 
 NetworkEngine::~NetworkEngine() {
@@ -148,7 +149,7 @@ NetworkEngine::tellListenerRefreshed(Sp<Node> n, Tid socket_id, const InfoHash&,
 {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_U);
     pk.pack_map(1 + (not values.empty()?1:0) + (not token.empty()?1:0));
@@ -165,8 +166,8 @@ NetworkEngine::tellListenerRefreshed(Sp<Node> n, Tid socket_id, const InfoHash&,
     pk.pack(KEY_TID); pk.pack(socket_id);
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     // send response
@@ -178,7 +179,7 @@ NetworkEngine::tellListenerExpired(Sp<Node> n, Tid socket_id, const InfoHash&, c
 {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_U);
     pk.pack_map(1 + (not values.empty()?1:0) + (not token.empty()?1:0));
@@ -195,8 +196,8 @@ NetworkEngine::tellListenerExpired(Sp<Node> n, Tid socket_id, const InfoHash&, c
     pk.pack(KEY_TID); pk.pack(socket_id);
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     // send response
@@ -245,7 +246,7 @@ NetworkEngine::requestStep(Sp<Request> sreq)
     auto now = scheduler.time();
     auto& node = *req.node;
     if (req.isExpired(now)) {
-        DHT_LOG.d(node.id, "[node %s] expired !", node.toString().c_str());
+        // DHT_LOG.d(node.id, "[node %s] expired !", node.toString().c_str());
         node.setExpired();
         if (not node.id)
             requests.erase(req.tid);
@@ -300,7 +301,7 @@ NetworkEngine::rateLimit(const SockAddr& addr)
     const auto& now = scheduler.time();
 
     // occasional IP limiter maintenance (a few times every second at max rate)
-    if (limiter_maintenance++ == MAX_REQUESTS_PER_SEC/8) {
+    if (limiter_maintenance++ == config.max_peer_req_per_sec) {
         for (auto it = address_rate_limiter.begin(); it != address_rate_limiter.end();) {
             if (it->second.maintain(now) == 0)
                 address_rate_limiter.erase(it++);
@@ -311,7 +312,11 @@ NetworkEngine::rateLimit(const SockAddr& addr)
     }
 
     // invoke per IP, then global rate limiter
-    return address_rate_limiter[addr].limit(now) and rate_limiter.limit(now);
+    return (config.max_peer_req_per_sec < 0
+            or address_rate_limiter
+                .emplace(addr, config.max_peer_req_per_sec).first->second
+                .limit(now))
+            and rate_limiter.limit(now);
 }
 
 bool
@@ -380,8 +385,8 @@ NetworkEngine::processMessage(const uint8_t *buf, size_t buflen, SockAddr f)
         return;
     }
 
-    if (msg->network != network) {
-        DHT_LOG.d("Received message from other network %u", msg->network);
+    if (msg->network != config.network) {
+        DHT_LOG.d("Received message from other config.network %u", msg->network);
         return;
     }
 
@@ -476,7 +481,8 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
                 node->received(now, req);
                 if (not node->isClient())
                     onNewNode(node, 1);
-                throw DhtProtocolException {DhtProtocolException::UNKNOWN_TID, "Can't find transaction", msg->id};
+                DHT_LOG.d(node->id, "[node %s] can't find transaction with id %u", node->toString().c_str(), msg->tid);
+                return;
             }
         }
 
@@ -619,7 +625,7 @@ NetworkEngine::sendPing(Sp<Node> node, RequestCb&& on_done, RequestExpiredCb&& o
     TransId tid (node->getNewTid());
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     pk.pack(KEY_A); pk.pack_map(1);
      pk.pack(KEY_REQ_ID); pk.pack(myid);
@@ -629,8 +635,8 @@ NetworkEngine::sendPing(Sp<Node> node, RequestCb&& on_done, RequestExpiredCb&& o
                               pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y); pk.pack(KEY_Q);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::Ping, tid.toInt(), node,
@@ -656,7 +662,7 @@ void
 NetworkEngine::sendPong(const SockAddr& addr, Tid tid) {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_R); pk.pack_map(2);
       pk.pack(KEY_REQ_ID); pk.pack(myid);
@@ -667,8 +673,8 @@ NetworkEngine::sendPong(const SockAddr& addr, Tid tid) {
                                pk.pack_bin_body((const char*)t.data(), t.size());
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     send(addr, buffer.data(), buffer.size());
@@ -680,7 +686,7 @@ NetworkEngine::sendFindNode(Sp<Node> n, const InfoHash& target, want_t want,
     TransId tid (n->getNewTid());
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     pk.pack(KEY_A); pk.pack_map(2 + (want>0?1:0));
       pk.pack(KEY_REQ_ID);     pk.pack(myid);
@@ -697,8 +703,8 @@ NetworkEngine::sendFindNode(Sp<Node> n, const InfoHash& target, want_t want,
                                pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y); pk.pack(KEY_Q);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::FindNode, tid.toInt(), n,
@@ -726,7 +732,7 @@ NetworkEngine::sendGetValues(Sp<Node> n, const InfoHash& info_hash, const Query&
     TransId tid (n->getNewTid());
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     pk.pack(KEY_A);  pk.pack_map(2 +
                                 (query.where.getFilter() or not query.select.getSelection().empty() ? 1:0) +
@@ -746,8 +752,8 @@ NetworkEngine::sendGetValues(Sp<Node> n, const InfoHash& info_hash, const Query&
                                pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y); pk.pack(KEY_Q);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::GetValues, tid.toInt(), n,
@@ -861,9 +867,9 @@ NetworkEngine::sendValueParts(const TransId& tid, const std::vector<Blob>& svals
             end = std::min(start + MTU, v.size());
             buffer.clear();
             msgpack::packer<msgpack::sbuffer> pk(&buffer);
-            pk.pack_map(3+(network?1:0));
-            if (network) {
-                pk.pack(KEY_NETID); pk.pack(network);
+            pk.pack_map(3+(config.network?1:0));
+            if (config.network) {
+                pk.pack(KEY_NETID); pk.pack(config.network);
             }
             pk.pack(KEY_Y); pk.pack(KEY_V);
             pk.pack(KEY_TID); pk.pack_bin(tid.size());
@@ -886,7 +892,7 @@ NetworkEngine::sendNodesValues(const SockAddr& addr, Tid tid, const Blob& nodes,
 {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_R);
     pk.pack_map(2 + (not st.empty()?1:0) + (nodes.size()>0?1:0) + (nodes6.size()>0?1:0) + (not token.empty()?1:0));
@@ -927,8 +933,8 @@ NetworkEngine::sendNodesValues(const SockAddr& addr, Tid tid, const Blob& nodes,
                       pk.pack_bin_body((const char*)t.data(), t.size());
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     // send response
@@ -1017,7 +1023,7 @@ NetworkEngine::sendListen(Sp<Node> n,
 
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     auto has_query = query.where.getFilter() or not query.select.getSelection().empty();
     pk.pack(KEY_A); pk.pack_map(4 + has_query);
@@ -1035,8 +1041,8 @@ NetworkEngine::sendListen(Sp<Node> n,
                                pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y); pk.pack(KEY_Q);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::Listen, tid.toInt(), n,
@@ -1060,7 +1066,7 @@ void
 NetworkEngine::sendListenConfirmation(const SockAddr& addr, Tid tid) {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_R); pk.pack_map(2);
       pk.pack(KEY_REQ_ID); pk.pack(myid);
@@ -1071,8 +1077,8 @@ NetworkEngine::sendListenConfirmation(const SockAddr& addr, Tid tid) {
                                pk.pack_bin_body((const char*)t.data(), t.size());
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     send(addr, buffer.data(), buffer.size());
@@ -1090,7 +1096,7 @@ NetworkEngine::sendAnnounceValue(Sp<Node> n,
     TransId tid (n->getNewTid());
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     pk.pack(KEY_A); pk.pack_map((created < scheduler.time() ? 5 : 4));
       pk.pack(KEY_REQ_ID);     pk.pack(myid);
@@ -1107,8 +1113,8 @@ NetworkEngine::sendAnnounceValue(Sp<Node> n,
                       pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y);   pk.pack(KEY_Q);
     pk.pack(KEY_UA);  pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::AnnounceValue, tid.toInt(), n,
@@ -1148,7 +1154,7 @@ NetworkEngine::sendRefreshValue(Sp<Node> n,
     TransId tid (n->getNewTid());
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(5+(network?1:0));
+    pk.pack_map(5+(config.network?1:0));
 
     pk.pack(KEY_A); pk.pack_map(4);
       pk.pack(KEY_REQ_ID);       pk.pack(myid);
@@ -1161,8 +1167,8 @@ NetworkEngine::sendRefreshValue(Sp<Node> n,
                                pk.pack_bin_body((const char*)tid.data(), tid.size());
     pk.pack(KEY_Y); pk.pack(KEY_Q);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     auto req = std::make_shared<Request>(MessageType::Refresh, tid.toInt(), n,
@@ -1193,7 +1199,7 @@ void
 NetworkEngine::sendValueAnnounced(const SockAddr& addr, Tid tid, Value::Id vid) {
     msgpack::sbuffer buffer;
     msgpack::packer<msgpack::sbuffer> pk(&buffer);
-    pk.pack_map(4+(network?1:0));
+    pk.pack_map(4+(config.network?1:0));
 
     pk.pack(KEY_R); pk.pack_map(3);
       pk.pack(KEY_REQ_ID);  pk.pack(myid);
@@ -1205,8 +1211,8 @@ NetworkEngine::sendValueAnnounced(const SockAddr& addr, Tid tid, Value::Id vid)
                                pk.pack_bin_body((const char*)t.data(), t.size());
     pk.pack(KEY_Y); pk.pack(KEY_R);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     send(addr, buffer.data(), buffer.size());
@@ -1237,8 +1243,8 @@ NetworkEngine::sendError(const SockAddr& addr,
                                pk.pack_bin_body((const char*)t.data(), t.size());
     pk.pack(KEY_Y); pk.pack(KEY_E);
     pk.pack(KEY_UA); pk.pack(my_v);
-    if (network) {
-        pk.pack(KEY_NETID); pk.pack(network);
+    if (config.network) {
+        pk.pack(KEY_NETID); pk.pack(config.network);
     }
 
     send(addr, buffer.data(), buffer.size());

src/network_utils.cpp

@@ -26,6 +26,7 @@
 #define close(x) closesocket(x)
 #define write(s, b, f) send(s, b, (int)strlen(b), 0)
 #else
+#include <sys/select.h>
 #include <fcntl.h>
 #endif
 
@@ -112,11 +113,13 @@ UdpSocket::UdpSocket(in_port_t port, const Logger& l) : logger(l) {
     SockAddr bind6;
     bind6.setFamily(AF_INET6);
     bind6.setPort(port);
+    std::lock_guard<std::mutex> lk(lock);
     openSockets(bind4, bind6);
 }
 
 UdpSocket::UdpSocket(const SockAddr& bind4, const SockAddr& bind6, const Logger& l) : logger(l)
 {
+    std::lock_guard<std::mutex> lk(lock);
     openSockets(bind4, bind6);
 }
 
@@ -154,6 +157,7 @@ UdpSocket::sendTo(const SockAddr& dest, const uint8_t* data, size_t size, bool r
         int err = errno;
         logger.d("Can't send message to %s: %s", dest.toString().c_str(), strerror(err));
         if (err == EPIPE || err == ENOTCONN || err == ECONNRESET) {
+            std::lock_guard<std::mutex> lk(lock);
             auto bind4 = std::move(bound4), bind6 = std::move(bound6);
             openSockets(bind4, bind6);
             return sendTo(dest, data, size, false);
@@ -180,8 +184,8 @@ UdpSocket::openSockets(const SockAddr& bind4, const SockAddr& bind6)
     udpPipe(stopfds);
 #endif
     int stop_readfd = stopfds[0];
-    stopfd = stopfds[1];
 
+    stopfd = stopfds[1];
     s4 = -1;
     s6 = -1;
 
@@ -224,18 +228,18 @@ UdpSocket::openSockets(const SockAddr& bind4, const SockAddr& bind6)
     }
 
     running = true;
-    rcv_thread = std::thread([this, stop_readfd]() {
-        int selectFd = std::max({s4, s6, stop_readfd}) + 1;
+    rcv_thread = std::thread([this, stop_readfd, ls4=s4, ls6=s6]() mutable {
+        int selectFd = std::max({ls4, ls6, stop_readfd}) + 1;
         try {
             while (running) {
                 fd_set readfds;
 
                 FD_ZERO(&readfds);
                 FD_SET(stop_readfd, &readfds);
-                if(s4 >= 0)
-                    FD_SET(s4, &readfds);
-                if(s6 >= 0)
-                    FD_SET(s6, &readfds);
+                if(ls4 >= 0)
+                    FD_SET(ls4, &readfds);
+                if(ls6 >= 0)
+                    FD_SET(ls6, &readfds);
 
                 int rc = select(selectFd, &readfds, nullptr, nullptr, nullptr);
                 if (rc < 0) {
@@ -259,10 +263,10 @@ UdpSocket::openSockets(const SockAddr& bind4, const SockAddr& bind6)
                             break;
                         }
                     }
-                    else if (s4 >= 0 && FD_ISSET(s4, &readfds))
-                        rc = recvfrom(s4, (char*)buf.data(), buf.size(), 0, (sockaddr*)&from, &from_len);
-                    else if (s6 >= 0 && FD_ISSET(s6, &readfds))
-                        rc = recvfrom(s6, (char*)buf.data(), buf.size(), 0, (sockaddr*)&from, &from_len);
+                    else if (ls4 >= 0 && FD_ISSET(ls4, &readfds))
+                        rc = recvfrom(ls4, (char*)buf.data(), buf.size(), 0, (sockaddr*)&from, &from_len);
+                    else if (ls6 >= 0 && FD_ISSET(ls6, &readfds))
+                        rc = recvfrom(ls6, (char*)buf.data(), buf.size(), 0, (sockaddr*)&from, &from_len);
                     else
                         continue;
 
@@ -276,25 +280,28 @@ UdpSocket::openSockets(const SockAddr& bind4, const SockAddr& bind6)
                         logger.e("Error receiving packet: %s", strerror(errno));
                         int err = errno;
                         if (err == EPIPE || err == ENOTCONN || err == ECONNRESET) {
-                            if (s4 >= 0) {
-                                close(s4);
+                            std::lock_guard<std::mutex> lk(lock);
+                            if (ls4 >= 0) {
+                                close(ls4);
                                 try {
-                                    s4 = bindSocket(bound4, bound4);
+                                    ls4 = bindSocket(bound4, bound4);
                                 } catch (const DhtException& e) {
                                     logger.e("Can't bind inet socket: %s", e.what());
                                 }
                             }
-                            if (s6 >= 0) {
-                                close(s6);
+                            if (ls6 >= 0) {
+                                close(ls6);
                                 try {
-                                    s6 = bindSocket(bound6, bound6);
+                                    ls6 = bindSocket(bound6, bound6);
                                 } catch (const DhtException& e) {
                                     logger.e("Can't bind inet6 socket: %s", e.what());
                                 }
                             }
-                            if (s4 < 0 && s6 < 0)
+                            if (ls4 < 0 && ls6 < 0)
                                 break;
-                            selectFd = std::max({s4, s6, stop_readfd}) + 1;
+                            s4 = ls4;
+                            s6 = ls6;
+                            selectFd = std::max({ls4, ls6, stop_readfd}) + 1;
                         }
                     }
                 }
@@ -302,16 +309,17 @@ UdpSocket::openSockets(const SockAddr& bind4, const SockAddr& bind6)
         } catch (const std::exception& e) {
             logger.e("Error in UdpSocket rx thread: %s", e.what());
         }
-        if (s4 >= 0)
-            close(s4);
-        if (s6 >= 0)
-            close(s6);
+        if (ls4 >= 0)
+            close(ls4);
+        if (ls6 >= 0)
+            close(ls6);
+        if (stop_readfd != -1)
+            close(stop_readfd);
+        std::lock_guard<std::mutex> lk(lock);
         s4 = -1;
         s6 = -1;
         bound4 = {};
         bound6 = {};
-        if (stop_readfd != -1)
-            close(stop_readfd);
         if (stopfd != -1)
             close(stopfd);
         stopfd = -1;

tests/cryptotester.cpp

@@ -19,7 +19,7 @@
 
 #include "cryptotester.h"
 
-#include "opendht/crypto.h"
+#include <opendht/crypto.h>
 
 namespace test {
 CPPUNIT_TEST_SUITE_REGISTRATION(CryptoTester);
@@ -34,16 +34,41 @@ CryptoTester::testSignatureEncryption() {
     auto key = dht::crypto::PrivateKey::generate();
     auto public_key = key.getPublicKey();
 
-    std::vector<uint8_t> data {5, 10};
-    std::vector<uint8_t> signature = key.sign(data);
+    std::vector<uint8_t> data1 {5, 10};
+    std::vector<uint8_t> data2(64 * 1024, 10);
+
+    std::vector<uint8_t> signature1 = key.sign(data1);
+    std::vector<uint8_t> signature2 = key.sign(data2);
 
     // check signature
-    CPPUNIT_ASSERT(public_key.checkSignature(data, signature));
+    CPPUNIT_ASSERT(public_key.checkSignature(data1, signature1));
+    CPPUNIT_ASSERT(public_key.checkSignature(data2, signature2));
 
     // encrypt data
-    std::vector<uint8_t> encrypted = public_key.encrypt(data);
-    std::vector<uint8_t> decrypted = key.decrypt(encrypted);
-    CPPUNIT_ASSERT(data == decrypted);
+    {
+        std::vector<uint8_t> encrypted = public_key.encrypt(data1);
+        std::vector<uint8_t> decrypted = key.decrypt(encrypted);
+        CPPUNIT_ASSERT(data1 == decrypted);
+    }
+
+    {
+        std::vector<uint8_t> encrypted = public_key.encrypt(data2);
+        std::vector<uint8_t> decrypted = key.decrypt(encrypted);
+        CPPUNIT_ASSERT(data2 == decrypted);
+    }
+
+    // encrypt data (invalid)
+    {
+        std::vector<uint8_t> encrypted = public_key.encrypt(data1);
+        encrypted[1]++;
+        CPPUNIT_ASSERT_THROW(key.decrypt(encrypted), std::runtime_error);
+    }
+
+    {
+        std::vector<uint8_t> encrypted = public_key.encrypt(data2);
+        encrypted[2]++;
+        CPPUNIT_ASSERT_THROW(key.decrypt(encrypted), std::runtime_error);
+    }
 }
 
 void

tests/dhtproxytester.cpp

@@ -27,56 +27,58 @@
 #include <chrono>
 #include <condition_variable>
 
+using namespace std::chrono_literals;
 
 namespace test {
 CPPUNIT_TEST_SUITE_REGISTRATION(DhtProxyTester);
 
 void
 DhtProxyTester::setUp() {
-    logger = dht::log::getStdLogger();
-
-    nodePeer.run(0, /*identity*/{}, /*threaded*/true);
+    nodePeer.run(0);
 
     nodeProxy = std::make_shared<dht::DhtRunner>();
-    nodeProxy->run(0, /*identity*/{}, /*threaded*/true);
+    nodeProxy->run(0);
     nodeProxy->bootstrap(nodePeer.getBound());
 
     auto serverCAIdentity = dht::crypto::generateEcIdentity("DHT Node CA");
     auto serverIdentity = dht::crypto::generateIdentity("DHT Node", serverCAIdentity);
 
-    serverProxy = std::unique_ptr<dht::DhtProxyServer>(
-        new dht::DhtProxyServer(
+    serverProxy = std::make_unique<dht::DhtProxyServer>(
             //dht::crypto::Identity{}, // http
             serverIdentity,            // https
-            nodeProxy, 8080, /*pushServer*/"127.0.0.1:8090", logger));
+            nodeProxy, 8080, /*pushServer*/"127.0.0.1:8090");
 
     clientConfig.server_ca = serverCAIdentity.second;
     clientConfig.client_identity = dht::crypto::generateIdentity("DhtProxyTester");
     clientConfig.dht_config.node_config.maintain_storage = false;
     clientConfig.threaded = true;
     clientConfig.push_node_id = "dhtnode";
-    clientContext.logger = logger;
-
-    nodeClient = std::make_shared<dht::DhtRunner>();
-    nodeClient->run(0, clientConfig, std::move(clientContext));
-    nodeClient->bootstrap(nodePeer.getBound());
-    nodeClient->setProxyServer("https://127.0.0.1:8080");
-    nodeClient->enableProxy(true); // creates DhtProxyClient
+    clientConfig.proxy_server = "https://127.0.0.1:8080";
 }
 
 void
 DhtProxyTester::tearDown() {
-    logger->d("[tester:proxy] stopping peer node");
     nodePeer.join();
-    nodeClient->join();
-    logger->d("[tester:proxy] stopping proxy server");
-    serverProxy.reset(nullptr);
-    logger->d("[tester:proxy] stopping proxy node");
-    nodeProxy->join();
+    nodeClient.join();
+
+    bool done = false;
+    std::condition_variable cv;
+    std::mutex cv_m;
+    nodeProxy->shutdown([&]{
+        std::lock_guard<std::mutex> lk(cv_m);
+        done = true;
+        cv.notify_all();
+    });
+    std::unique_lock<std::mutex> lk(cv_m);
+    CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]{ return done; }));
+    serverProxy.reset();
+    nodeProxy.reset();
 }
 
 void
 DhtProxyTester::testGetPut() {
+    nodeClient.run(0, clientConfig);
+
     bool done = false;
     std::condition_variable cv;
     std::mutex cv_m;
@@ -85,22 +87,24 @@ DhtProxyTester::testGetPut() {
     dht::Value val {"Hey! It's been a long time. How have you been?"};
     auto val_data = val.data;
     {
-        std::unique_lock<std::mutex> lk(cv_m);
         nodePeer.put(key, std::move(val), [&](bool) {
             std::lock_guard<std::mutex> lk(cv_m);
             done = true;
             cv.notify_all();
         });
-        CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+        std::unique_lock<std::mutex> lk(cv_m);
+        CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
     }
 
-    auto vals = nodeClient->get(key).get();
+    auto vals = nodeClient.get(key).get();
     CPPUNIT_ASSERT(not vals.empty());
     CPPUNIT_ASSERT(vals.front()->data == val_data);
 }
 
 void
 DhtProxyTester::testListen() {
+    nodeClient.run(0, clientConfig);
+
     std::condition_variable cv;
     std::mutex cv_m;
     std::unique_lock<std::mutex> lk(cv_m);
@@ -117,11 +121,11 @@ DhtProxyTester::testListen() {
         done = true;
         cv.notify_all();
     });
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
     done = false;
 
     std::vector<dht::Blob> values;
-    auto token = nodeClient->listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>& v, bool expired) {
+    auto token = nodeClient.listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>& v, bool expired) {
         if (not expired) {
             std::lock_guard<std::mutex> lk(cv_m);
             for (const auto& value : v)
@@ -131,7 +135,7 @@ DhtProxyTester::testListen() {
         }
         return true;
     });
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
     done = false;
     // Here values should contains 1 values
     CPPUNIT_ASSERT_EQUAL(static_cast<int>(values.size()), 1);
@@ -142,8 +146,8 @@ DhtProxyTester::testListen() {
     dht::Value secondVal {"You're a monster"};
     auto secondVal_data = secondVal.data;
     nodePeer.put(key, std::move(secondVal));
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
-    nodeClient->cancelListen(key, std::move(token));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
+    nodeClient.cancelListen(key, std::move(token));
     // Here values should contains 2 values
     CPPUNIT_ASSERT_EQUAL(static_cast<int>(values.size()), 2);
     CPPUNIT_ASSERT(values.back() == secondVal_data);
@@ -151,7 +155,8 @@ DhtProxyTester::testListen() {
 
 void
 DhtProxyTester::testResubscribeGetValues() {
-    nodeClient->setPushNotificationToken("atlas");
+    clientConfig.push_token = "atlas";
+    nodeClient.run(0, clientConfig);
 
     bool done = false;
     std::condition_variable cv;
@@ -159,68 +164,65 @@ DhtProxyTester::testResubscribeGetValues() {
     std::unique_lock<std::mutex> lk(cv_m);
     auto key = dht::InfoHash::get("GLaDOs");
 
-    // If a peer send a value, the listen operation from the client
+    // If a peer sent a value, the listen operation from the client
     // should retrieve this value
     dht::Value firstVal {"Hey! It's been a long time. How have you been?"};
     auto firstVal_data = firstVal.data;
-    nodePeer.put(key, std::move(firstVal), [&](bool) {
+    nodePeer.put(key, std::move(firstVal), [&](bool ok) {
         std::lock_guard<std::mutex> lk(cv_m);
+        CPPUNIT_ASSERT(ok);
         done = true;
         cv.notify_all();
     });
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
     done = false;
 
     // Send a first subscribe, the value is sent via a push notification
     // So ignore values here.
-    nodeClient->listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>&, bool) {
+    nodeClient.listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>&, bool) {
         return true;
     });
     cv.wait_for(lk, std::chrono::seconds(1));
 
     // Reboot node (to avoid cache)
-    nodeClient->join();
-    nodeClient->run(0, clientConfig, std::move(clientContext));
-    nodeClient->bootstrap(nodePeer.getBound());
-    nodeClient->setProxyServer("https://127.0.0.1:8080");
-    nodeClient->enableProxy(true);
-    nodeClient->setPushNotificationToken("atlas");
+    nodeClient.join();
+    clientConfig.push_token = "";
+    nodeClient.run(0, clientConfig);
 
     // For the second subscribe, the proxy will return the value in the body
-    auto values = std::vector<dht::Blob>();
-    auto ftoken = nodeClient->listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>& v, bool expired) {
+    std::vector<std::shared_ptr<dht::Value>> values;
+    auto ftoken = nodeClient.listen(key, [&](const std::vector<std::shared_ptr<dht::Value>>& v, bool expired) {
         if (not expired) {
             std::lock_guard<std::mutex> lk(cv_m);
-            for (const auto& value : v)
-                values.emplace_back(value->data);
+            values.insert(values.end(), v.begin(), v.end());
             done = true;
             cv.notify_all();
         }
         return true;
     });
 
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done; }));
     auto token = ftoken.get();
     CPPUNIT_ASSERT(token);
-    nodeClient->cancelListen(key, token);
+    nodeClient.cancelListen(key, token);
     // Here values should still contains 1 values
     CPPUNIT_ASSERT_EQUAL((size_t)1u, values.size());
-    CPPUNIT_ASSERT(firstVal_data == values.front());
+    CPPUNIT_ASSERT(firstVal_data == values.front()->data);
 }
 
 void
 DhtProxyTester::testPutGet40KChars()
 {
+    nodeClient.run(0, clientConfig);
+    constexpr size_t N = 40000;
+
     // Arrange
     auto key = dht::InfoHash::get("testPutGet40KChars");
     std::vector<std::shared_ptr<dht::Value>> values;
-    std::string mtu = "";
-    for (int i = 0; i < 40000; i++){
-        if (i % 2 == 0)
-            mtu.append("M");
-        else
-            mtu.append("T");
-    }
+    std::vector<uint8_t> mtu;
+    mtu.reserve(N);
+    for (size_t i = 0; i < N; i++)
+        mtu.emplace_back((i % 2) ? 'T' : 'M');
     std::condition_variable cv;
     std::mutex cv_m;
     std::unique_lock<std::mutex> lk(cv_m);
@@ -229,28 +231,61 @@ DhtProxyTester::testPutGet40KChars()
 
     // Act
     dht::Value val {mtu};
-    nodeClient->put(key, std::move(val), [&](bool ok) {
+    nodePeer.put(key, std::move(val), [&](bool ok) {
         std::lock_guard<std::mutex> lk(cv_m);
         done_put = ok;
         cv.notify_all();
     });
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done_put; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done_put; }));
 
-    nodeClient->get(key, [&](const std::vector<std::shared_ptr<dht::Value>>& vals){
-        values = vals;
+    nodeClient.get(key, [&](const std::vector<std::shared_ptr<dht::Value>>& vals){
+        values.insert(values.end(), vals.begin(), vals.end());
         return true;
     },[&](bool ok){
         std::lock_guard<std::mutex> lk(cv_m);
         done_get = ok;
         cv.notify_all();
     });
-    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done_get; }));
+    CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]{ return done_get; }));
 
     // Assert
-    dht::Value mtu_val {mtu};
-    for (const auto &value: values){
-        CPPUNIT_ASSERT(value->data == mtu_val.data);
+    CPPUNIT_ASSERT_EQUAL((size_t)1u, values.size());
+    for (const auto &value: values)
+        CPPUNIT_ASSERT(value->data == mtu);
+}
+
+void
+DhtProxyTester::testFuzzy()
+{
+    constexpr size_t N = 40000;
+
+    // Arrange
+    auto key = dht::InfoHash::get("testFuzzy");
+    std::vector<std::shared_ptr<dht::Value>> values;
+    std::vector<uint8_t> mtu;
+    mtu.reserve(N);
+    for (size_t i = 0; i < N; i++)
+        mtu.emplace_back((i % 2) ? 'T' : 'M');
+
+    // Act
+    for (size_t i = 0; i < 100; i++) {
+        auto nodeTest = std::make_shared<dht::DhtRunner>();
+        nodeTest->run(0, clientConfig);
+        nodeTest->put(key, dht::Value(mtu), [&](bool ok) {
+            CPPUNIT_ASSERT(ok);
+        });
+        nodeTest->get(key, [&](const std::vector<std::shared_ptr<dht::Value>>& vals){
+            values.insert(values.end(), vals.begin(), vals.end());
+            return true;
+        },[&](bool ok){
+            CPPUNIT_ASSERT(ok);
+        });
+        std::this_thread::sleep_for(10ms);
     }
+
+    // Assert
+    for (const auto &value: values)
+        CPPUNIT_ASSERT(value->data == mtu);
 }
 
 }  // namespace test

tests/dhtproxytester.h

@@ -35,6 +35,7 @@ class DhtProxyTester : public CppUnit::TestFixture {
     CPPUNIT_TEST(testListen);
     CPPUNIT_TEST(testResubscribeGetValues);
     CPPUNIT_TEST(testPutGet40KChars);
+    CPPUNIT_TEST(testFuzzy);
     CPPUNIT_TEST_SUITE_END();
 
  public:
@@ -65,16 +66,14 @@ class DhtProxyTester : public CppUnit::TestFixture {
     */
    void testPutGet40KChars();
 
- private:
-    dht::DhtRunner nodePeer;
+   void testFuzzy();
 
-    std::shared_ptr<dht::DhtRunner> nodeClient;
+ private:
+    dht::DhtRunner::Config clientConfig {};
+    dht::DhtRunner nodePeer;
+    dht::DhtRunner nodeClient;
     std::shared_ptr<dht::DhtRunner> nodeProxy;
     std::unique_ptr<dht::DhtProxyServer> serverProxy;
-
-    dht::DhtRunner::Context clientContext {};
-    dht::DhtRunner::Config clientConfig {};
-    std::shared_ptr<dht::Logger> logger {};
 };
 
 }  // namespace test

tests/dhtrunnertester.cpp

@@ -22,19 +22,32 @@
 #include <chrono>
 #include <mutex>
 #include <condition_variable>
+using namespace std::chrono_literals;
 
 namespace test {
 CPPUNIT_TEST_SUITE_REGISTRATION(DhtRunnerTester);
 
 void
 DhtRunnerTester::setUp() {
-    node1.run(42222, {}, true);
-    node2.run(42232, {}, true);
+    node1.run(42222);
+    node2.run(42232);
     node2.bootstrap(node1.getBound());
 }
 
 void
 DhtRunnerTester::tearDown() {
+    unsigned done {0};
+    std::condition_variable cv;
+    std::mutex cv_m;
+    auto shutdown = [&]{
+        std::lock_guard<std::mutex> lk(cv_m);
+        done++;
+        cv.notify_all();
+    };
+    node1.shutdown(shutdown);
+    node2.shutdown(shutdown);
+    std::unique_lock<std::mutex> lk(cv_m);
+    CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]{ return done == 2; }));
     node1.join();
     node2.join();
 }
@@ -90,27 +103,22 @@ DhtRunnerTester::testListen() {
 
     for (unsigned i=0; i<N; i++) {
         node2.put(a, dht::Value("v1"), [&](bool ok) {
-            {
-                std::lock_guard<std::mutex> lock(mutex);
-                putCount++;
-                if (ok) putOkCount++;
-            }
+            std::lock_guard<std::mutex> lock(mutex);
+            putCount++;
+            if (ok) putOkCount++;
             cv.notify_all();
         });
         node2.put(b, dht::Value("v2"), [&](bool ok) {
-            {
-                std::lock_guard<std::mutex> lock(mutex);
-                putCount++;
-                if (ok) putOkCount++;
-            }
+            std::lock_guard<std::mutex> lock(mutex);
+            putCount++;
+            if (ok) putOkCount++;
             cv.notify_all();
         });
     }
 
     {
         std::unique_lock<std::mutex> lk(mutex);
-        cv.wait_for(lk, std::chrono::seconds(30), [&]{ return putCount == N * 2u; });
-        CPPUNIT_ASSERT_EQUAL(N * 2u, putCount);
+        CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]{ return putCount == N * 2u; }));
         CPPUNIT_ASSERT_EQUAL(N * 2u, putOkCount);
     }
 

tests/httptester.cpp

@@ -19,14 +19,15 @@
 
 #include "httptester.h"
 
-// std
+#include <opendht/log.h>
+#include <opendht/value.h>
+#include <opendht/dhtrunner.h>
+
 #include <iostream>
 #include <string>
-
 #include <chrono>
 #include <condition_variable>
 
-
 namespace test {
 CPPUNIT_TEST_SUITE_REGISTRATION(HttpTester);
 
@@ -34,26 +35,22 @@ void
 HttpTester::setUp() {
     logger = dht::log::getStdLogger();
 
-    nodePeer.run(0, /*identity*/{}, /*threaded*/true);
+    nodePeer = std::make_shared<dht::DhtRunner>();
+    nodePeer->run(0);
 
-    nodeProxy = std::make_shared<dht::DhtRunner>();
+    auto nodeProxy = std::make_shared<dht::DhtRunner>();
     nodeProxy->run(0, /*identity*/{}, /*threaded*/true);
-    nodeProxy->bootstrap(nodePeer.getBound());
+    nodeProxy->bootstrap(nodePeer->getBound());
 
     serverProxy = std::unique_ptr<dht::DhtProxyServer>(
         new dht::DhtProxyServer(
             /*http*/dht::crypto::Identity{}, nodeProxy, 8080, /*pushServer*/"127.0.0.1:8090", logger));
-
 }
 
 void
 HttpTester::tearDown() {
-    logger->d("[tester:http] stopping peer node");
-    nodePeer.join();
-    logger->d("[tester:http] stopping proxy server");
-    serverProxy.reset(nullptr);
-    logger->d("[tester:http] stopping proxy node");
-    nodeProxy->join();
+    serverProxy.reset();
+    nodePeer->join();
 }
 
 void
@@ -248,7 +245,7 @@ HttpTester::test_send_json() {
         if (status_code != 200 and logger)
             logger->e("[tester] [status] failed with code=%i", status_code);
         std::cout << "[tester] got response:\n" << value << std::endl;
-        resp_val = value;
+        resp_val = std::move(value);
         status = status_code;
         done = true;
         cv.notify_all();
@@ -258,7 +255,42 @@ HttpTester::test_send_json() {
     // Assert
     CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
     CPPUNIT_ASSERT(status == 200);
-    CPPUNIT_ASSERT(resp_val["data"] == val.toJson()["data"]);
+    CPPUNIT_ASSERT(resp_val["data"] == json["data"]);
+
+    done = false;
+    request = std::make_shared<dht::http::Request>(serverProxy->io_context(), "http://google.ca",
+                   [&](const dht::http::Response& response){
+        logger->w("got answer: %.*s", response.body.size(), response.body.data());
+        status = response.status_code;
+        done = true;
+        cv.notify_all();
+    }, logger);
+    request->send();
+    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    //CPPUNIT_ASSERT(status == 200);
+
+    done = false;
+    request = std::make_shared<dht::http::Request>(serverProxy->io_context(), "https://google.ca",
+                   [&](const dht::http::Response& response){
+        logger->w("got answer: %.*s", response.body.size(), response.body.data());
+        status = response.status_code;
+        done = true;
+        cv.notify_all();
+    }, logger);
+    request->send();
+    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
+    //CPPUNIT_ASSERT(status == 200);
+
+    done = false;
+    request = std::make_shared<dht::http::Request>(serverProxy->io_context(), "https://google.ca/sdbjklwGBIP",
+                   [&](const dht::http::Response& response){
+        logger->w("got answer: %.*s", response.body.size(), response.body.data());
+        status = response.status_code;
+        done = true;
+        cv.notify_all();
+    }, logger);
+    request->send();
+    CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(10), [&]{ return done; }));
 }
 
 }  // namespace test

tests/httptester.h

@@ -23,12 +23,12 @@
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 
-#include <opendht/value.h>
-#include <opendht/log.h>
 #include <opendht/http.h>
-
-#include <opendht/dhtrunner.h>
 #include <opendht/dht_proxy_server.h>
+#include <asio.hpp>
+
+#include <thread>
+#include <memory>
 
 namespace test {
 
@@ -89,9 +89,7 @@ class HttpTester : public CppUnit::TestFixture {
 
  private:
     std::shared_ptr<dht::Logger> logger {};
-
-    dht::DhtRunner nodePeer;
-    std::shared_ptr<dht::DhtRunner> nodeProxy;
+    std::shared_ptr<dht::DhtRunner> nodePeer;
     std::unique_ptr<dht::DhtProxyServer> serverProxy;
 };
 

tools/CMakeLists.txt

@@ -3,9 +3,9 @@ add_executable (dhtnode dhtnode.cpp tools_common.h)
 add_executable (dhtscanner dhtscanner.cpp tools_common.h)
 add_executable (dhtchat dhtchat.cpp tools_common.h)
 
-target_link_libraries (dhtnode LINK_PUBLIC readline)
-target_link_libraries (dhtscanner LINK_PUBLIC readline)
-target_link_libraries (dhtchat LINK_PUBLIC readline)
+target_link_libraries (dhtnode LINK_PUBLIC ${READLINE_LIBRARIES})
+target_link_libraries (dhtscanner LINK_PUBLIC ${READLINE_LIBRARIES})
+target_link_libraries (dhtchat LINK_PUBLIC ${READLINE_LIBRARIES})
 
 if (OPENDHT_SHARED)
 	target_link_libraries (dhtnode LINK_PUBLIC opendht)
@@ -19,7 +19,7 @@ endif ()
 
 if (OPENDHT_C)
 	add_executable (dhtcnode dhtcnode.c)
-	target_link_libraries (dhtcnode LINK_PUBLIC opendht-c readline)
+	target_link_libraries (dhtcnode LINK_PUBLIC opendht-c ${READLINE_LIBRARIES})
 endif ()
 
 if (NOT DEFINED CMAKE_INSTALL_BINDIR)

tools/Makefile.am

@@ -1,7 +1,7 @@
 bin_PROGRAMS = dhtnode dhtchat dhtscanner
 noinst_HEADERS = tools_common.h
 
-AM_CPPFLAGS = -I../include @JsonCpp_CFLAGS@ @MsgPack_CFLAGS@
+AM_CPPFLAGS = -isystem @top_srcdir@/include @JsonCpp_CFLAGS@ @MsgPack_CFLAGS@
 
 dhtnode_SOURCES = dhtnode.cpp
 dhtnode_LDFLAGS = -lopendht -lreadline -L@top_builddir@/src/.libs @Argon2_LDFLAGS@ @GnuTLS_LIBS@

tools/dhtchat.cpp

@@ -37,11 +37,6 @@ const std::string printTime(const std::time_t& now) {
     return buf;
 }
 
-void print_node_info(const DhtRunner& dht, const dht_params&) {
-    std::cout << "OpenDht node " << dht.getNodeId() << " running on port " <<  dht.getBoundPort() << std::endl;
-    std::cout << "Public key ID " << dht.getId() << std::endl;
-}
-
 void print_usage() {
     std::cout << "Usage: dhtchat [-n network_id] [-p local_port] [-b bootstrap_host[:port]]" << std::endl << std::endl;
     std::cout << "dhtchat, a simple OpenDHT command line chat client." << std::endl;
@@ -62,48 +57,13 @@ main(int argc, char **argv)
 
     DhtRunner dht;
     try {
-        if (not params.id.first) {
-            auto node_ca = std::make_unique<dht::crypto::Identity>(dht::crypto::generateEcIdentity("DHT Node CA"));
-            params.id = dht::crypto::generateIdentity("DHT Chat Node", *node_ca);
-            if (not params.save_identity.empty()) {
-                dht::crypto::saveIdentity(*node_ca, params.save_identity + "_ca", params.privkey_pwd);
-                dht::crypto::saveIdentity(params.id, params.save_identity, params.privkey_pwd);
-            }
-        }
-
-        dht::DhtRunner::Config config {};
-        config.dht_config.node_config.network = params.network;
-        config.dht_config.node_config.maintain_storage = false;
-        config.dht_config.node_config.persist_path = params.persist_path;
-        config.dht_config.id = params.id;
-        config.threaded = true;
-        config.proxy_server = params.proxyclient;
-        config.push_node_id = "dhtnode";
-        config.push_token = params.devicekey;
-        config.peer_discovery = params.peer_discovery;
-        config.peer_publish = params.peer_discovery;
-
-        dht::DhtRunner::Context context {};
-        if (params.log) {
-            if (params.syslog or (params.daemonize and params.logfile.empty()))
-                context.logger = log::getSyslogLogger("dhtnode");
-            else if (not params.logfile.empty())
-                context.logger = log::getFileLogger(params.logfile);
-            else
-                context.logger = log::getStdLogger();
-        }
-        dht.run(params.port, config, std::move(context));
+        params.generate_identity = true;
+        auto dhtConf = getDhtConfig(params);
+        dht.run(params.port, dhtConf.first, std::move(dhtConf.second));
 
         if (not params.bootstrap.first.empty())
             dht.bootstrap(params.bootstrap.first.c_str(), params.bootstrap.second.c_str());
 
-#ifdef OPENDHT_PROXY_CLIENT
-    if (!params.proxyclient.empty()) {
-        dht.setProxyServer(params.proxyclient);
-        dht.enableProxy(true);
-    }
-#endif //OPENDHT_PROXY_CLIENT
-
         print_node_info(dht, params);
         std::cout << "  type 'c {hash}' to join a channel" << std::endl << std::endl;
 

tools/dhtcnode.c

@@ -15,6 +15,7 @@ bool dht_value_callback(const dht_value* value, bool expired, void* user_data)
 {
     dht_data_view data = dht_value_get_data(value);
     printf("Value callback %s: %.*s.\n", expired ? "expired" : "new", (int)data.size, data.data);
+    return true;
 }
 
 bool dht_get_callback(const dht_value* value, void* user_data)
@@ -22,15 +23,16 @@ bool dht_get_callback(const dht_value* value, void* user_data)
     dht_runner* runner = (dht_runner*)user_data;
     dht_data_view data = dht_value_get_data(value);
     printf("Get callback: %.*s.\n", (int)data.size, data.data);
+    return true;
 }
 
-bool dht_done_callback(bool ok, void* user_data)
+void dht_done_callback(bool ok, void* user_data)
 {
     dht_runner* runner = (dht_runner*)user_data;
     printf("Done callback. %s\n", ok ? "Success !" : "Failure :-(");
 }
 
-bool op_context_free(void* user_data)
+void op_context_free(void* user_data)
 {
     struct op_context* ctx = (struct op_context*)user_data;
     printf("op_context_free %d.\n", ctx->d);
@@ -60,6 +62,22 @@ char* print_addr(const struct sockaddr* addr) {
 
 int main()
 {
+    dht_identity id = dht_identity_generate("testNode", NULL);
+    dht_infohash cert_id = dht_certificate_get_id(id.certificate);
+    printf("Cert ID: %s\n", dht_infohash_print(&cert_id));
+
+    dht_publickey* pk = dht_certificate_get_publickey(id.certificate);
+    dht_infohash pk_id = dht_publickey_get_id(pk);
+    printf("PK ID: %s\n", dht_infohash_print(&pk_id));
+    dht_publickey_delete(pk);
+
+    pk = dht_privatekey_get_publickey(id.privatekey);
+    pk_id = dht_publickey_get_id(pk);
+    printf("Key ID: %s\n", dht_infohash_print(&pk_id));
+    dht_publickey_delete(pk);
+
+    dht_identity_delete(&id);
+
     dht_runner* runner = dht_runner_new();
     dht_runner_run(runner, 4040);
 
@@ -71,7 +89,7 @@ int main()
     // Put data
     const char* data_str = "yo, this is some data";
     dht_value* val = dht_value_new(data_str, strlen(data_str));
-    dht_runner_put(runner, &h, val, dht_done_callback, runner);
+    dht_runner_put(runner, &h, val, dht_done_callback, runner, false);
     dht_value_unref(val);
 
     // Get data

tools/dhtnode.cpp

@@ -48,18 +48,6 @@ void print_id_req() {
     std::cout << "An identity is required to perform this operation (run with -i)" << std::endl;
 }
 
-void print_node_info(const std::shared_ptr<DhtRunner>& node, const dht_params& params) {
-    std::cout << "OpenDHT node " << node->getNodeId() << " running on ";
-    auto port4 = node->getBoundPort(AF_INET);
-    auto port6 = node->getBoundPort(AF_INET6);
-    if (port4 == port6)
-        std::cout << "port " << port4 << std::endl;
-    else
-        std::cout << "IPv4 port " << port4 << ", IPv6 port " << port6 << std::endl;
-    if (params.id.first)
-        std::cout << "Public key ID " << node->getId() << std::endl;
-}
-
 void print_help() {
     std::cout << "OpenDHT command line interface (CLI)" << std::endl;
     std::cout << "Possible commands:" << std::endl
@@ -123,7 +111,7 @@ void cmd_loop(std::shared_ptr<DhtRunner>& node, dht_params& params
 #endif
 )
 {
-    print_node_info(node, params);
+    print_node_info(*node, params);
     std::cout << " (type 'h' or 'help' for a list of possible commands)" << std::endl << std::endl;
 
 #ifndef WIN32_NATIVE
@@ -152,11 +140,13 @@ void cmd_loop(std::shared_ptr<DhtRunner>& node, dht_params& params
             print_help();
             continue;
         } else if (op == "ll") {
-            print_node_info(node, params);
+            auto nodeInfo = node->getNodeInfo();
+            print_node_info(*node, params);
+            std::cout << nodeInfo.ongoing_ops << " ongoing operations" << std::endl;
             std::cout << "IPv4 stats:" << std::endl;
-            std::cout << node->getNodesStats(AF_INET).toString() << std::endl;
+            std::cout << nodeInfo.ipv4.toString() << std::endl;
             std::cout << "IPv6 stats:" << std::endl;
-            std::cout << node->getNodesStats(AF_INET6).toString() << std::endl;
+            std::cout << nodeInfo.ipv6.toString() << std::endl;
 #ifdef OPENDHT_PROXY_SERVER
             for (const auto& proxy : proxies) {
                 std::cout << "Stats for proxy on port " << proxy.first << std::endl;
@@ -532,37 +522,8 @@ main(int argc, char **argv)
 
     auto node = std::make_shared<DhtRunner>();
     try {
-        if (not params.id.first and params.generate_identity) {
-            auto node_ca = std::make_unique<dht::crypto::Identity>(dht::crypto::generateEcIdentity("DHT Node CA"));
-            params.id = dht::crypto::generateIdentity("DHT Node", *node_ca);
-            if (not params.save_identity.empty()) {
-                dht::crypto::saveIdentity(*node_ca, params.save_identity + "_ca", params.privkey_pwd);
-                dht::crypto::saveIdentity(params.id, params.save_identity, params.privkey_pwd);
-            }
-        }
-
-        dht::DhtRunner::Config config {};
-        config.dht_config.node_config.network = params.network;
-        config.dht_config.node_config.maintain_storage = false;
-        config.dht_config.node_config.persist_path = params.persist_path;
-        config.dht_config.id = params.id;
-        config.threaded = true;
-        config.proxy_server = params.proxyclient;
-        config.push_node_id = "dhtnode";
-        config.push_token = params.devicekey;
-        config.peer_discovery = params.peer_discovery;
-        config.peer_publish = params.peer_discovery;
-
-        dht::DhtRunner::Context context {};
-        if (params.log) {
-            if (params.syslog or (params.daemonize and params.logfile.empty()))
-                context.logger = log::getSyslogLogger("dhtnode");
-            else if (not params.logfile.empty())
-                context.logger = log::getFileLogger(params.logfile);
-            else
-                context.logger = log::getStdLogger();
-        }
-        node->run(params.port, config, std::move(context));
+        auto dhtConf = getDhtConfig(params);
+        node->run(params.port, dhtConf.first, std::move(dhtConf.second));
 
         if (not params.bootstrap.first.empty()) {
             std::cout << "Bootstrap: " << params.bootstrap.first << ":" << params.bootstrap.second << std::endl;
@@ -576,13 +537,13 @@ main(int argc, char **argv)
 #ifdef OPENDHT_PROXY_SERVER
             proxies.emplace(params.proxyserverssl, std::unique_ptr<DhtProxyServer>(
                 new DhtProxyServer(params.proxy_id,
-                                   node, params.proxyserverssl, params.pushserver, context.logger)));
+                                   node, params.proxyserverssl, params.pushserver, dhtConf.second.logger)));
         }
         if (params.proxyserver) {
             proxies.emplace(params.proxyserver, std::unique_ptr<DhtProxyServer>(
                 new DhtProxyServer(
                     dht::crypto::Identity{},
-                    node, params.proxyserver, params.pushserver, context.logger)));
+                    node, params.proxyserver, params.pushserver, dhtConf.second.logger)));
 #else
             std::cerr << "DHT proxy server requested but OpenDHT built without proxy server support." << std::endl;
             exit(EXIT_FAILURE);

tools/dhtscanner.cpp

@@ -85,21 +85,13 @@ main(int argc, char **argv)
 
     DhtRunner dht;
     try {
-        dht.run(params.port, {}, true, params.network);
-
-        if (params.log) {
-            if (params.syslog)
-                log::enableSyslog(dht, "dhtnode");
-            else if (not params.logfile.empty())
-                log::enableFileLogging(dht, params.logfile);
-            else
-                log::enableLogging(dht);
-        }
+        auto dhtConf = getDhtConfig(params);
+        dht.run(params.port, dhtConf.first, std::move(dhtConf.second));
 
         if (not params.bootstrap.first.empty())
             dht.bootstrap(params.bootstrap.first.c_str(), params.bootstrap.second.c_str());
 
-        std::cout << "OpenDht node " << dht.getNodeId() << " running on port " <<  params.port << std::endl;
+        print_node_info(dht, params);
         std::cout << "Scanning network..." << std::endl;
         auto all_nodes = std::make_shared<NodeSet>();
 

tools/tools_common.h

@@ -131,8 +131,66 @@ struct dht_params {
     std::string privkey_pwd {};
     std::string proxy_privkey_pwd {};
     std::string save_identity {};
+    bool no_rate_limit {false};
 };
 
+std::pair<dht::DhtRunner::Config, dht::DhtRunner::Context>
+getDhtConfig(dht_params& params)
+{
+    if (not params.id.first and params.generate_identity) {
+        auto node_ca = std::make_unique<dht::crypto::Identity>(dht::crypto::generateEcIdentity("DHT Node CA"));
+        params.id = dht::crypto::generateIdentity("DHT Node", *node_ca);
+        if (not params.save_identity.empty()) {
+            dht::crypto::saveIdentity(*node_ca, params.save_identity + "_ca", params.privkey_pwd);
+            dht::crypto::saveIdentity(params.id, params.save_identity, params.privkey_pwd);
+        }
+    }
+
+    dht::DhtRunner::Config config {};
+    config.dht_config.node_config.network = params.network;
+    config.dht_config.node_config.maintain_storage = false;
+    config.dht_config.node_config.persist_path = params.persist_path;
+    config.dht_config.id = params.id;
+    config.threaded = true;
+    config.proxy_server = params.proxyclient;
+    config.push_node_id = "dhtnode";
+    config.push_token = params.devicekey;
+    config.peer_discovery = params.peer_discovery;
+    config.peer_publish = params.peer_discovery;
+    if (params.no_rate_limit) {
+        config.dht_config.node_config.max_req_per_sec = -1;
+        config.dht_config.node_config.max_peer_req_per_sec = -1;
+    }
+
+    dht::DhtRunner::Context context {};
+    if (params.log) {
+        if (params.syslog or (params.daemonize and params.logfile.empty()))
+            context.logger = dht::log::getSyslogLogger("dhtnode");
+        else if (not params.logfile.empty())
+            context.logger = dht::log::getFileLogger(params.logfile);
+        else
+            context.logger = dht::log::getStdLogger();
+    }
+    if (context.logger) {
+        context.statusChangedCallback = [logger = *context.logger](dht::NodeStatus status4, dht::NodeStatus status6) {
+            logger.WARN("Connectivity changed: IPv4: %s, IPv6: %s", dht::statusToStr(status4), dht::statusToStr(status6));
+        };
+    }
+    return {std::move(config), std::move(context)};
+}
+
+void print_node_info(const dht::DhtRunner& node, const dht_params& params) {
+    std::cout << "OpenDHT node " << node.getNodeId() << " running on ";
+    auto port4 = node.getBoundPort(AF_INET);
+    auto port6 = node.getBoundPort(AF_INET6);
+    if (port4 == port6)
+        std::cout << "port " << port4 << std::endl;
+    else
+        std::cout << "IPv4 port " << port4 << ", IPv6 port " << port6 << std::endl;
+    if (params.id.first)
+        std::cout << "Public key ID " << node.getId() << std::endl;
+}
+
 static const constexpr struct option long_options[] = {
     {"help",                    no_argument      , nullptr, 'h'},
     {"port",                    required_argument, nullptr, 'p'},
@@ -147,6 +205,7 @@ static const constexpr struct option long_options[] = {
     {"daemonize",               no_argument      , nullptr, 'd'},
     {"service",                 no_argument      , nullptr, 's'},
     {"peer-discovery",          no_argument      , nullptr, 'D'},
+    {"no-rate-limit",           no_argument      , nullptr, 'U'},
     {"persist",                 required_argument, nullptr, 'f'},
     {"logfile",                 required_argument, nullptr, 'l'},
     {"syslog",                  no_argument      , nullptr, 'L'},
@@ -168,7 +227,7 @@ parseArgs(int argc, char **argv) {
     int opt;
     std::string privkey;
     std::string proxy_privkey;
-    while ((opt = getopt_long(argc, argv, "hidsvDp:n:b:f:l:", long_options, nullptr)) != -1) {
+    while ((opt = getopt_long(argc, argv, "hidsvDUp:n:b:f:l:", long_options, nullptr)) != -1) {
         switch (opt) {
         case 'p': {
                 int port_arg = atoi(optarg);
@@ -212,6 +271,9 @@ parseArgs(int argc, char **argv) {
         case 'n':
             params.network = strtoul(optarg, nullptr, 0);
             break;
+        case 'U':
+            params.no_rate_limit = true;
+            break;
         case 'b':
             params.bootstrap = dht::splitPort((optarg[0] == '=') ? optarg+1 : optarg);
             if (not params.bootstrap.first.empty() and params.bootstrap.second.empty()) {