update version to 3.4.0

proxy client: provide result for pushNotificationReceived

.github/workflows/ccpp.yml

@@ -2,7 +2,7 @@ name: C/C++ CI
 
 env:
   LLHTTP_VERSION: "v9.2.1"
-  RESTINIO_VERSION: "0.7.3"
+  RESTINIO_VERSION: "0.7.6"
   EXPECTED_LITE_URL: "https://raw.githubusercontent.com/martinmoene/expected-lite/master/include/nonstd/expected.hpp"
   UBUNTU_FULL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev autotools-dev autoconf libfmt-dev libmsgpack-dev libargon2-dev"
   UBUNTU_MESON_DEPS: "ninja-build libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-dev python3-setuptools python3-pip libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
@@ -42,7 +42,7 @@ jobs:
       - name: Build restinio dependency
         run: |
           mkdir restinio && cd restinio
-          wget "https://github.com/Stiffstream/restinio/releases/download/v.${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2"
+          wget "https://github.com/Stiffstream/restinio/releases/download/v${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2"
           tar -xjf restinio-${RESTINIO_VERSION}.tar.bz2
           cd restinio-${RESTINIO_VERSION}/dev
           cmake -DCMAKE_INSTALL_PREFIX=/usr/local \
@@ -126,7 +126,7 @@ jobs:
       - name: Build restinio dependency
         run: |
           mkdir restinio && cd restinio
-          wget "https://github.com/Stiffstream/restinio/releases/download/v.${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2"
+          wget "https://github.com/Stiffstream/restinio/releases/download/v${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2"
           tar -xjf restinio-${RESTINIO_VERSION}.tar.bz2
           cd restinio-${RESTINIO_VERSION}/dev
           cmake -DCMAKE_INSTALL_PREFIX=/usr/local \

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.16..3.28)
+cmake_minimum_required (VERSION 3.16..3.31)
 if(POLICY CMP0135)
   cmake_policy(SET CMP0135 NEW)
 endif()
@@ -13,7 +13,7 @@ include(CTest)
 include(FetchContent)
 
 set (opendht_VERSION_MAJOR 3)
-set (opendht_VERSION_MINOR 3.0)
+set (opendht_VERSION_MINOR 4.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -97,29 +97,35 @@ if (NOT MSVC)
         find_package(Restinio REQUIRED)
 
         # llhttp
-        find_path(LLHTTP_INCLUDE_DIR llhttp.h)
-        find_library(LLHTTP_LIBRARY NAMES llhttp libllhttp)
-        if (LLHTTP_INCLUDE_DIR AND LLHTTP_LIBRARY)
-            message(STATUS "Found llhttp ${LLHTTP_INCLUDE_DIR} ${LLHTTP_LIBRARY}")
-            add_library(llhttp_static STATIC IMPORTED)
-            set_target_properties(llhttp_static PROPERTIES
-                IMPORTED_LOCATION ${LLHTTP_LIBRARY}
-                INTERFACE_INCLUDE_DIRECTORIES ${LLHTTP_INCLUDE_DIR}
-            )
-            set(llhttp_target llhttp_static)
+        pkg_search_module(LLHTTP IMPORTED_TARGET llhttp libllhttp)
+        if (LLHTTP_FOUND)
+            message(STATUS "Found llhttp ${LLHTTP_INCLUDE_DIRS}")
+            set(llhttp_target PkgConfig::LLHTTP)
         else()
-            FetchContent_Declare(llhttp-local URL "https://github.com/nodejs/llhttp/archive/refs/tags/release/v9.2.1.tar.gz")
-            if (BUILD_SHARED_LIBS)
-                set(BUILD_SHARED_LIBS ON CACHE INTERNAL "")
-            else()
-                set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "")
-                set(BUILD_STATIC_LIBS ON CACHE INTERNAL "")
-            endif()
-            FetchContent_MakeAvailable(llhttp-local)
-            if (BUILD_SHARED_LIBS)
-                set(llhttp_target llhttp_shared)
-            else()
+            find_path(LLHTTP_INCLUDE_DIR llhttp.h)
+            find_library(LLHTTP_LIBRARY NAMES llhttp libllhttp)
+            if (LLHTTP_INCLUDE_DIR AND LLHTTP_LIBRARY)
+                message(STATUS "Found llhttp ${LLHTTP_INCLUDE_DIR} ${LLHTTP_LIBRARY}")
+                add_library(llhttp_static STATIC IMPORTED)
+                set_target_properties(llhttp_static PROPERTIES
+                    IMPORTED_LOCATION ${LLHTTP_LIBRARY}
+                    INTERFACE_INCLUDE_DIRECTORIES ${LLHTTP_INCLUDE_DIR}
+                )
                 set(llhttp_target llhttp_static)
+            else()
+                FetchContent_Declare(llhttp-local URL "https://github.com/nodejs/llhttp/archive/refs/tags/release/v9.2.1.tar.gz")
+                if (BUILD_SHARED_LIBS)
+                    set(BUILD_SHARED_LIBS ON CACHE INTERNAL "")
+                else()
+                    set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "")
+                    set(BUILD_STATIC_LIBS ON CACHE INTERNAL "")
+                endif()
+                FetchContent_MakeAvailable(llhttp-local)
+                if (BUILD_SHARED_LIBS)
+                    set(llhttp_target llhttp_shared)
+                else()
+                    set(llhttp_target llhttp_static)
+                endif()
             endif()
         endif()
         set(http_lib "-lllhttp")

cmake/CheckAtomic.cmake

@@ -49,10 +49,15 @@ elseif(LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL")
   check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
   # If not, check if the library exists, and atomics work with it.
   if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
-    list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
-    check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
-    if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
-      message(FATAL_ERROR "Host compiler must support std::atomic!")
+    check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
+    if(HAVE_LIBATOMIC)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+      check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
+      if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
+        message(FATAL_ERROR "Host compiler must support std::atomic!")
+      endif()
+    else()
+      #message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
     endif()
   endif()
 endif()
@@ -65,14 +70,32 @@ elseif(LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL")
   check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
   # If not, check if the library exists, and atomics work with it.
   if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
-    list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
-    check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
-    if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
-      message(FATAL_ERROR "Host compiler must support 64-bit std::atomic!")
+    check_library_exists(atomic __atomic_load_8 "" HAVE_CXX_LIBATOMICS64)
+    if(HAVE_CXX_LIBATOMICS64)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+      check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
+      if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
+        message(FATAL_ERROR "Host compiler must support 64-bit std::atomic!")
+      endif()
+    else()
+      #message(FATAL_ERROR "Host compiler appears to require libatomic for 64-bit operations, but cannot find it.")
     endif()
   endif()
 endif()
 
+# Set variable LLVM_ATOMIC_LIB specifying flags for linking against libatomic.
+if(HAVE_CXX_ATOMICS_WITH_LIB OR HAVE_CXX_ATOMICS64_WITH_LIB)
+  # Use options --push-state, --as-needed and --pop-state if linker is known to support them.
+  # Use single option -Wl of compiler driver to avoid incorrect re-ordering of options by CMake.
+  if(LLVM_LINKER_IS_GNULD OR LLVM_LINKER_IS_GOLD OR LLVM_LINKER_IS_LLD OR LLVM_LINKER_IS_MOLD)
+    set(LLVM_ATOMIC_LIB "-Wl,--push-state,--as-needed,-latomic,--pop-state")
+  else()
+    set(LLVM_ATOMIC_LIB "-latomic")
+  endif()
+else()
+  set(LLVM_ATOMIC_LIB)
+endif()
+
 ## TODO: This define is only used for the legacy atomic operations in
 ## llvm's Atomic.h, which should be replaced.  Other code simply
 ## assumes C++11 <atomic> works.

configure.ac

@@ -1,6 +1,6 @@
 dnl define macros
 m4_define([opendht_major_version], 3)
-m4_define([opendht_minor_version], 3)
+m4_define([opendht_minor_version], 4)
 m4_define([opendht_patch_version], 0)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])

include/opendht/crypto.h

@@ -512,12 +512,18 @@ struct OPENDHT_PUBLIC Certificate {
 
     Blob getSerialNumber() const;
 
+    /** Read certificate full DN as described in RFC4514 */ 
+    std::string getDN() const;
+
     /** Read certificate Common Name (CN) */
     std::string getName() const;
 
     /** Read certificate User ID (UID) */
     std::string getUID() const;
 
+    /** Read certificate issuer DN as described in RFC4514 */
+    std::string getIssuerDN() const;
+
     /** Read certificate issuer Common Name (CN) */
     std::string getIssuerName() const;
 

include/opendht/dhtrunner.h

@@ -384,7 +384,7 @@ public:
     // securedht methods
 
     void findCertificate(InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>&)>);
-    void registerCertificate(std::shared_ptr<crypto::Certificate> cert);
+    void registerCertificate(const std::shared_ptr<crypto::Certificate>& cert);
     void setLocalCertificateStore(CertificateStoreQuery&& query_method);
 
     /**

include/opendht/infohash.h

@@ -110,7 +110,7 @@ public:
     bool operator!=(const Hash& h) const { return !(*this == h); }
 
     bool operator<(const Hash& o) const {
-        for(unsigned i = 0; i < N; i++) {
+        for (unsigned i = 0; i < N; i++) {
             if(data_[i] != o.data_[i])
                 return data_[i] < o.data_[i];
         }
@@ -119,7 +119,7 @@ public:
 
     Hash operator^(const Hash& o) const {
         Hash result;
-        for(auto i = 0u; i < N; i++) {
+        for (auto i = 0u; i < N; i++) {
             result[i] = data_[i] ^ o.data_[i];
         }
         return result;
@@ -345,8 +345,8 @@ Hash<N>::getRandom(Rd& rdev)
 }
 
 struct alignas(std::max_align_t) HexMap : public std::array<std::array<char, 2>, 256> {
-    HexMap() {
-        for (size_t i=0; i<size(); i++) {
+    constexpr HexMap() : std::array<std::array<char, 2>, 256>() {
+        for (size_t i = 0; i < size(); i++) {
             auto& e = (*this)[i];
             e[0] = hex_digits[(i >> 4) & 0x0F];
             e[1] = hex_digits[i & 0x0F];
@@ -356,7 +356,7 @@ private:
     static constexpr const char* hex_digits = "0123456789abcdef";
 };
 
-OPENDHT_PUBLIC extern const HexMap hex_map;
+OPENDHT_PUBLIC constexpr HexMap hex_map = {};
 
 inline std::string
 toHex(const uint8_t* data, size_t size) {
@@ -380,10 +380,11 @@ Hash<N>::to_c_str() const
 {
     alignas(std::max_align_t) thread_local std::array<char, N*2+1> buf;
     for (size_t i=0; i<N; i++) {
-        auto b = buf.data()+i*2;
+        auto b = buf.data() + i*2;
         const auto& m = hex_map[data_[i]];
         *((uint16_t*)b) = *((uint16_t*)&m);
     }
+    buf[N*2] = '\0';
     return buf.data();
 }
 

include/opendht/securedht.h

@@ -136,7 +136,7 @@ public:
     void findPublicKey(const InfoHash& node, const std::function<void(const Sp<crypto::PublicKey>)>& cb);
 
     Sp<crypto::Certificate> registerCertificate(const InfoHash& node, const Blob& cert);
-    void registerCertificate(Sp<crypto::Certificate>& cert);
+    void registerCertificate(const Sp<crypto::Certificate>& cert);
 
     Sp<crypto::Certificate> getCertificate(const InfoHash& node) const;
     Sp<crypto::PublicKey> getPublicKey(const InfoHash& node) const;
@@ -387,7 +387,7 @@ const ValueType CERTIFICATE_TYPE = {
     },
     [](InfoHash, const Sp<Value>& o, Sp<Value>& n, const InfoHash&, const SockAddr&) {
         try {
-            return crypto::Certificate(o->data).getPublicKey().getId() == crypto::Certificate(n->data).getPublicKey().getId();
+            return crypto::Certificate(o->data).getPublicKey().getLongId() == crypto::Certificate(n->data).getPublicKey().getLongId();
         } catch (const std::exception& e) {}
         return false;
     }

include/opendht/value.h

@@ -137,8 +137,6 @@ private:
     std::map<ValueType::Id, ValueType> types {};
 };
 
-struct CryptoValueCache;
-
 /**
  * A "value" is data potentially stored on the Dht, with some metadata.
  *

meson.build

@@ -1,5 +1,5 @@
 project('opendht', 'c', 'cpp', 'cython',
-    version: '3.3.0',
+    version: '3.4.0',
     default_options: [
         'cpp_std=c++17',
         'warning_level=3'

src/crypto.cpp

@@ -646,7 +646,7 @@ GnuTLSFromType(NameType type)
 }
 
 static std::string
-getDN(gnutls_x509_crq_t request, const char* oid)
+readDN(gnutls_x509_crq_t request, const char* oid)
 {
     std::string dn;
     dn.resize(512);
@@ -704,13 +704,13 @@ CertificateRequest::setName(const std::string& name)
 std::string
 CertificateRequest::getName() const
 {
-    return getDN(request, GNUTLS_OID_X520_COMMON_NAME);
+    return readDN(request, GNUTLS_OID_X520_COMMON_NAME);
 }
 
 std::string
 CertificateRequest::getUID() const
 {
-    return getDN(request, GNUTLS_OID_LDAP_UID);
+    return readDN(request, GNUTLS_OID_LDAP_UID);
 }
 
 void
@@ -769,7 +769,21 @@ CertificateRequest::toString() const
 // Certificate
 
 static std::string
-getDN(gnutls_x509_crt_t cert, const char* oid, bool issuer = false)
+readDN(gnutls_x509_crt_t cert, bool issuer = false)
+{
+    gnutls_datum_t dn;
+    int err = issuer
+            ? gnutls_x509_crt_get_issuer_dn3(cert, &dn, 0)
+            : gnutls_x509_crt_get_dn3(       cert, &dn, 0);
+    if (err != GNUTLS_E_SUCCESS)
+        return {};
+    std::string ret((const char*)dn.data, dn.size);
+    gnutls_free(dn.data);
+    return ret;
+}
+
+static std::string
+readDN(gnutls_x509_crt_t cert, const char* oid, bool issuer = false)
 {
     std::string dn;
     dn.resize(512);
@@ -927,28 +941,40 @@ Certificate::getSerialNumber() const
     return {serial, serial + size};
 }
 
+std::string
+Certificate::getDN() const
+{
+    return readDN(cert);
+}
+
 std::string
 Certificate::getName() const
 {
-    return getDN(cert, GNUTLS_OID_X520_COMMON_NAME);
+    return readDN(cert, GNUTLS_OID_X520_COMMON_NAME);
 }
 
 std::string
 Certificate::getUID() const
 {
-    return getDN(cert, GNUTLS_OID_LDAP_UID);
+    return readDN(cert, GNUTLS_OID_LDAP_UID);
+}
+
+std::string
+Certificate::getIssuerDN() const
+{
+    return readDN(cert, true);
 }
 
 std::string
 Certificate::getIssuerName() const
 {
-    return getDN(cert, GNUTLS_OID_X520_COMMON_NAME, true);
+    return readDN(cert, GNUTLS_OID_X520_COMMON_NAME, true);
 }
 
 std::string
 Certificate::getIssuerUID() const
 {
-    return getDN(cert, GNUTLS_OID_LDAP_UID, true);
+    return readDN(cert, GNUTLS_OID_LDAP_UID, true);
 }
 
 std::vector<std::pair<NameType, std::string>>

src/dhtrunner.cpp

@@ -619,7 +619,7 @@ DhtRunner::getPublicAddress(std::function<void(std::vector<SockAddr>&&)> cb, sa_
 }
 
 void
-DhtRunner::registerCertificate(std::shared_ptr<crypto::Certificate> cert) {
+DhtRunner::registerCertificate(const std::shared_ptr<crypto::Certificate>& cert) {
     std::lock_guard<std::mutex> lck(dht_mtx);
     dht_->registerCertificate(cert);
 }

src/http.cpp

@@ -456,7 +456,7 @@ Connection::set_ssl_verification(const std::string& hostname, const asio::ssl::v
                     }
 
                     // starts from CA and goes down the presented chain
-                    auto verifier = asio::ssl::rfc2818_verification(hostname);
+                    auto verifier = asio::ssl::host_name_verification(hostname);
                     bool verified = verifier(preverified, ctx);
                     auto verify_ec = X509_STORE_CTX_get_error(ctx.native_handle());
                     if (verify_ec != 0 /*X509_V_OK*/ and logger)
@@ -591,12 +591,12 @@ Connection::async_write(BytesHandlerCb cb)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!is_open()) {
-        if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
+        if (cb) asio::post(ctx_, [cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
     if (ssl_socket_)  asio::async_write(*ssl_socket_, write_buf_, wrapCallback(std::move(cb)));
     else if (socket_) asio::async_write(*socket_, write_buf_, wrapCallback(std::move(cb)));
-    else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
+    else if (cb)      asio::post(ctx_, [cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
 void
@@ -604,12 +604,12 @@ Connection::async_read_until(const char* delim, BytesHandlerCb cb)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!is_open()) {
-        if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
+        if (cb) asio::post(ctx_, [cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
     if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallback(std::move(cb)));
     else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallback(std::move(cb)));
-    else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
+    else if (cb)      asio::post(ctx_, [cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
 void
@@ -617,12 +617,12 @@ Connection::async_read_until(char delim, BytesHandlerCb cb)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!is_open()) {
-        if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
+        if (cb) asio::post(ctx_, [cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
     if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallback(std::move(cb)));
     else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallback(std::move(cb)));
-    else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
+    else if (cb)      asio::post(ctx_, [cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
 void
@@ -630,12 +630,12 @@ Connection::async_read(size_t bytes, BytesHandlerCb cb)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!is_open()) {
-        if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
+        if (cb) asio::post(ctx_, [cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
     if (ssl_socket_)  asio::async_read(*ssl_socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallback(std::move(cb)));
     else if (socket_) asio::async_read(*socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallback(std::move(cb)));
-    else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
+    else if (cb)      asio::post(ctx_, [cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
 void
@@ -643,7 +643,7 @@ Connection::async_read_some(size_t bytes, BytesHandlerCb cb)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!is_open()) {
-        if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
+        if (cb) asio::post(ctx_, [cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
     auto buf = read_buf_.prepare(bytes);
@@ -818,10 +818,21 @@ Resolver::add_callback(ResolverCb cb, sa_family_t family)
 }
 
 void
-Resolver::resolve(const std::string& host, const std::string& service)
+Resolver::resolve(const std::string& host, const std::string& serviceName)
 {
-    asio::ip::tcp::resolver::query query_(host, service);
-    resolver_.async_resolve(query_, [this, host, service, destroyed = destroyed_]
+    auto service = serviceName;
+    // The async_resolve function used below typically relies on the contents of the
+    // /etc/services (Linux/POSIX) or c:\windows\system32\drivers\etc\services (Windows)
+    // file in order to resolve a descriptive service name into a port number. A
+    // resolution attempt that would otherwise succeed can therefore fail if the file
+    // is inaccessible or corrupted (which is rare but can happen in practice). We
+    // hardcode the port numbers for http and https to prevent this failure mode.
+    if (service == "http") {
+        service = "80";
+    } else if (service == "https") {
+        service = "443";
+    }
+    resolver_.async_resolve(host, service, [this, host, service, destroyed = destroyed_]
         (const asio::error_code& ec, asio::ip::tcp::resolver::results_type endpoints)
     {
         if (ec == asio::error::operation_aborted or *destroyed)

src/peer_discovery.cpp

@@ -97,7 +97,7 @@ PeerDiscovery::DomainPeerDiscovery::DomainPeerDiscovery(asio::ip::udp domain, in
     , ioContext_(ioContext)
     , peerDiscoveryTimer(*ioContext_)
     , sockFd_(*ioContext_, domain)
-    , sockAddrSend_(asio::ip::address::from_string(domain.family() == AF_INET ? MULTICAST_ADDRESS_IPV4
+    , sockAddrSend_(asio::ip::make_address(domain.family() == AF_INET ? MULTICAST_ADDRESS_IPV4
                                                                               : MULTICAST_ADDRESS_IPV6), port)
 {
     try {
@@ -139,7 +139,7 @@ PeerDiscovery::DomainPeerDiscovery::startDiscovery(const std::string &type, Serv
     callbackmap_[type] = callback;
     if (not drunning_) {
         drunning_ = true;
-        ioContext_->post([this] () {
+        asio::post(*ioContext_, [this] () {
                     loopListener();
                     query(sockAddrSend_);
                 });
@@ -245,7 +245,7 @@ PeerDiscovery::DomainPeerDiscovery::startPublish(const std::string &type, const
     messages_[type] = std::move(pack_buf_c);
     reloadMessages();
     lrunning_ = true;
-    ioContext_->post([this] () { publish(sockAddrSend_); });
+    asio::post(*ioContext_, [this] () { publish(sockAddrSend_); });
 }
 
 bool
@@ -327,7 +327,7 @@ PeerDiscovery::DomainPeerDiscovery::reDiscover()
 void
 PeerDiscovery::DomainPeerDiscovery::connectivityChanged()
 {
-    ioContext_->post([this] () {
+    asio::post(*ioContext_, [this] () {
         reDiscover();
         publish(sockAddrSend_);
     });

src/securedht.cpp

@@ -158,7 +158,7 @@ SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
 }
 
 void
-SecureDht::registerCertificate(Sp<crypto::Certificate>& cert)
+SecureDht::registerCertificate(const Sp<crypto::Certificate>& cert)
 {
     if (cert)
         nodesCertificates_[cert->getId()] = cert;

src/storage.h

@@ -224,7 +224,7 @@ Storage::store(const InfoHash& id, const Sp<Value>& value, time_point created, t
             //DHT_LOG.DEBUG("Updating %s -> %s", id.toString().c_str(), value->toString().c_str());
             // clear quota for previous value
             if (it->store_bucket)
-                it->store_bucket->erase(id, *value, it->expiration);
+                it->store_bucket->erase(id, *it->data, it->expiration);
             it->expiration = expiration;
             // update quota for new value
             it->store_bucket = sb;

src/utils.cpp

@@ -39,8 +39,6 @@ const char* version() {
     return PACKAGE_VERSION;
 }
 
-const HexMap hex_map = {};
-
 static constexpr std::array<uint8_t, 12> MAPPED_IPV4_PREFIX {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}};
 
 std::pair<std::string, std::string>

tests/dhtrunnertester.cpp

@@ -358,7 +358,8 @@ DhtRunnerTester::testIdOps() {
 
     {
         std::unique_lock<std::mutex> lk(mutex);
-        CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]{ return valueCount == 7 && valueCountEdit == 2; }));
+        CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]{ return valueCount == 7; }));
+        CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]{ return valueCountEdit == 2; }));
     }
 
     // editValue->data = dht::packMsg("v2");