ci/github: update to latest action versions

CMakeLists.txt

@@ -85,9 +85,6 @@ if (NOT MSVC)
 
     if (OPENDHT_HTTP OR OPENDHT_PEER_DISCOVERY)
         find_path(ASIO_INCLUDE_DIR asio.hpp REQUIRED)
-        message(STATUS "Found ASIO ${ASIO_INCLUDE_DIR}")
-    else()
-        message(STATUS "ASIO not required")
     endif ()
 
     find_package(fmt)
@@ -97,7 +94,7 @@ if (NOT MSVC)
 
         # llhttp
         find_path(LLHTTP_INCLUDE_DIR llhttp.h)
-        find_library(LLHTTP_LIBRARY libllhttp)
+        find_library(LLHTTP_LIBRARY libllhttp.a)
         if (LLHTTP_INCLUDE_DIR AND LLHTTP_LIBRARY)
             message(STATUS "Found llhttp ${LLHTTP_INCLUDE_DIR} ${LLHTTP_LIBRARY}")
             add_library(llhttp_static STATIC IMPORTED)
@@ -163,9 +160,6 @@ endif ()
 
 if (OPENDHT_HTTP OR OPENDHT_PEER_DISCOVERY)
     add_definitions(-DASIO_STANDALONE)
-    if (UNIX AND NOT APPLE)
-        pkg_search_module(liburing IMPORTED_TARGET liburing)
-    endif ()
 endif()
 
 if (NOT MSVC)
@@ -407,11 +401,6 @@ else()
     if (OPENDHT_PROXY_OPENSSL)
         target_link_libraries(opendht PUBLIC PkgConfig::OPENSSL)
     endif()
-    if (liburing_FOUND)
-        set(iouring_lib ", liburing")
-        target_link_libraries(opendht PUBLIC PkgConfig::liburing)
-        target_compile_definitions(opendht PUBLIC ASIO_HAS_IO_URING ASIO_DISABLE_EPOLL)
-    endif()
 endif()
 
 if (BUILD_SHARED_LIBS)

include/opendht/dhtrunner.h

@@ -409,8 +409,7 @@ public:
     void run(const Config& config, Context&& context);
 
     void setOnStatusChanged(StatusCallback&& cb) {
-        if (cb)
-            statusCbs.emplace_back(std::move(cb));
+        statusCb = std::move(cb);
     }
 
     /**
@@ -520,8 +519,7 @@ private:
 
     NodeStatus status4 {NodeStatus::Disconnected},
                status6 {NodeStatus::Disconnected};
-
-    std::vector<StatusCallback> statusCbs {};
+    StatusCallback statusCb {nullptr};
 
     /** PeerDiscovery Parameters */
     std::shared_ptr<PeerDiscovery> peerDiscovery_;

include/opendht/peer_discovery.h

@@ -23,9 +23,7 @@
 #include "sockaddr.h"
 #include "infohash.h"
 #include "logger.h"
-#include "utils.h"
 
-#include <asio/steady_timer.hpp>
 #include <thread>
 
 namespace asio {
@@ -38,34 +36,31 @@ class OPENDHT_PUBLIC PeerDiscovery
 {
 public:
     static constexpr in_port_t DEFAULT_PORT = 8888;
-    using ServiceDiscoveredCallback = std::function<void(msgpack::object &&, SockAddr &&)>;
+    using ServiceDiscoveredCallback = std::function<void(msgpack::object&&, SockAddr&&)>;
 
-    PeerDiscovery(in_port_t port = DEFAULT_PORT,
-                std::shared_ptr<asio::io_context> ioContext = {},
-                std::shared_ptr<Logger> logger = {});
+    PeerDiscovery(in_port_t port = DEFAULT_PORT, std::shared_ptr<asio::io_context> ioContext = {}, std::shared_ptr<Logger> logger = {});
     ~PeerDiscovery();
 
     /**
-     * startDiscovery - Keep Listening data from the sender until node is joinned
-     * or stop is called
-     */
+     * startDiscovery - Keep Listening data from the sender until node is joinned or stop is called
+    */
     void startDiscovery(const std::string &type, ServiceDiscoveredCallback callback);
 
-    template <typename T>
-    void startDiscovery(const std::string &type, std::function<void(T &&, SockAddr &&)> cb) {
-        startDiscovery(type, [cb](msgpack::object &&ob, SockAddr &&addr) {
+    template<typename T>
+    void startDiscovery(const std::string &type, std::function<void(T&&, SockAddr&&)> cb) {
+        startDiscovery(type, [cb](msgpack::object&& ob, SockAddr&& addr) {
             cb(ob.as<T>(), std::move(addr));
         });
     }
 
     /**
      * startPublish - Keeping sending data until node is joinned or stop is called
-     */
+    */
     void startPublish(const std::string &type, const msgpack::sbuffer &pack_buf);
     void startPublish(sa_family_t domain, const std::string &type, const msgpack::sbuffer &pack_buf);
 
-    template <typename T>
-    void startPublish(const std::string &type, const T &object) {
+    template<typename T>
+    void startPublish(const std::string &type, const T& object) {
         msgpack::sbuffer buf;
         msgpack::pack(buf, object);
         startPublish(type, buf);
@@ -73,24 +68,22 @@ public:
 
     /**
      * Thread Stopper
-     */
+    */
     void stop();
 
     /**
      * Remove possible callBack to discovery
-     */
+    */
     bool stopDiscovery(const std::string &type);
 
     /**
      * Remove different serivce message to send
-     */
+    */
     bool stopPublish(const std::string &type);
     bool stopPublish(sa_family_t domain, const std::string &type);
 
     void connectivityChanged();
 
-    void stopConnectivityChanged();
-
 private:
     class DomainPeerDiscovery;
     std::unique_ptr<DomainPeerDiscovery> peerDiscovery4_;
@@ -99,4 +92,4 @@ private:
     std::thread ioRunnner_;
 };
 
-} // namespace dht
+}

meson.build

@@ -13,15 +13,10 @@ openssl = dependency('openssl', required: get_option('proxy_client'))
 jsoncpp = dependency('jsoncpp', required: get_option('proxy_client'))
 fmt = dependency('fmt')
 llhttp = dependency('llhttp', 'libllhttp', required: get_option('proxy_client'))
-io_uring = dependency('liburing', required: false)
 
-deps = [fmt, gnutls, nettle, msgpack, argon2, openssl, jsoncpp, llhttp, io_uring]
+deps = [fmt, gnutls, nettle, msgpack, argon2, openssl, jsoncpp, llhttp]
 
-add_project_arguments('-DMSGPACK_NO_BOOST', '-DASIO_STANDALONE', language : 'cpp')
-if io_uring.found()
-    add_project_arguments('-DASIO_HAS_IO_URING', '-DASIO_DISABLE_EPOLL', language : 'cpp')
-    conf_data.set('iouring_lib', ', liburing')
-endif
+add_project_arguments('-DMSGPACK_NO_BOOST', language : 'cpp')
 add_project_arguments(['-Wno-return-type','-Wno-deprecated','-Wnon-virtual-dtor','-pedantic-errors','-fvisibility=hidden'], language : 'cpp')
 
 opendht_inc = include_directories('include/opendht')

opendht.pc.in

@@ -8,5 +8,5 @@ Version: @VERSION@
 Libs: -L${libdir} -lopendht
 Libs.private: @http_lib@ -pthread
 Requires: gnutls >= 3.3@jsoncpp_lib@@openssl_lib@
-Requires.private: nettle >= 2.4@argon2_lib@@iouring_lib@
+Requires.private: nettle >= 2.4@argon2_lib@
 Cflags: -I${includedir}

src/compat/getif_workaround_android.h

@@ -22,7 +22,7 @@ get_interface(){
         if (if1->ifa_addr->sa_family != AF_INET)
             continue;
         if((if1->ifa_flags & IFF_MULTICAST) == IFF_MULTICAST){
-            auto sa_data = reinterpret_cast<uint8_t*>(if1->ifa_addr->sa_data);
+            char* sa_data = if1->ifa_addr->sa_data;
             uint32_t value = sa_data[2] << 24
                 | sa_data[3] << 16
                 | sa_data[4] << 8
@@ -36,4 +36,4 @@ get_interface(){
 }
 
 } /* namespace workaround */
-} /* namespace dht */
+} /* namespace dht */

src/crypto.cpp

@@ -93,27 +93,11 @@ Blob aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
         std::random_device rdev;
         std::generate_n(ret.begin(), GCM_IV_SIZE, std::bind(rand_byte, std::ref(rdev)));
     }
-
-    if (key.size() == AES_LENGTHS[0]) {
-        struct gcm_aes128_ctx aes;
-        gcm_aes128_set_key(&aes, key.data());
-        gcm_aes128_set_iv(&aes, GCM_IV_SIZE, ret.data());
-        gcm_aes128_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
-    } else if (key.size() == AES_LENGTHS[1]) {
-        struct gcm_aes192_ctx aes;
-        gcm_aes192_set_key(&aes, key.data());
-        gcm_aes192_set_iv(&aes, GCM_IV_SIZE, ret.data());
-        gcm_aes192_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
-    } else if (key.size() == AES_LENGTHS[2]) {
-        struct gcm_aes256_ctx aes;
-        gcm_aes256_set_key(&aes, key.data());
-        gcm_aes256_set_iv(&aes, GCM_IV_SIZE, ret.data());
-        gcm_aes256_encrypt(&aes, data_length, ret.data() + GCM_IV_SIZE, data);
-        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, ret.data() + GCM_IV_SIZE + data_length);
-    }
-
+    struct gcm_aes_ctx aes;
+    gcm_aes_set_key(&aes, key.size(), key.data());
+    gcm_aes_set_iv(&aes, GCM_IV_SIZE, ret.data());
+    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);
     return ret;
 }
 
@@ -134,28 +118,14 @@ Blob aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key)
 
     std::array<uint8_t, GCM_DIGEST_SIZE> digest;
 
+    struct gcm_aes_ctx aes;
+    gcm_aes_set_key(&aes, key.size(), key.data());
+    gcm_aes_set_iv(&aes, GCM_IV_SIZE, data);
+
     size_t data_sz = data_length - GCM_IV_SIZE - GCM_DIGEST_SIZE;
     Blob ret(data_sz);
-
-    if (key.size() == AES_LENGTHS[0]) {
-        struct gcm_aes128_ctx aes;
-        gcm_aes128_set_key(&aes, key.data());
-        gcm_aes128_set_iv(&aes, GCM_IV_SIZE, data);
-        gcm_aes128_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcm_aes128_digest(&aes, GCM_DIGEST_SIZE, digest.data());
-    } else if (key.size() == AES_LENGTHS[1]) {
-        struct gcm_aes192_ctx aes;
-        gcm_aes192_set_key(&aes, key.data());
-        gcm_aes192_set_iv(&aes, GCM_IV_SIZE, data);
-        gcm_aes192_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcm_aes192_digest(&aes, GCM_DIGEST_SIZE, digest.data());
-    } else if (key.size() == AES_LENGTHS[2]) {
-        struct gcm_aes256_ctx aes;
-        gcm_aes256_set_key(&aes, key.data());
-        gcm_aes256_set_iv(&aes, GCM_IV_SIZE, data);
-        gcm_aes256_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
-        gcm_aes256_digest(&aes, GCM_DIGEST_SIZE, digest.data());
-    }
+    gcm_aes_decrypt(&aes, data_sz, ret.data(), data + GCM_IV_SIZE);
+    gcm_aes_digest(&aes, GCM_DIGEST_SIZE, digest.data());
 
     if (not std::equal(digest.begin(), digest.end(), data + data_length - GCM_DIGEST_SIZE)) {
         throw DecryptError("Can't decrypt data");
@@ -257,7 +227,7 @@ PrivateKey::PrivateKey(const uint8_t* src, size_t src_size, const char* password
         throw CryptoException("Can't initialize private key !");
 
     const gnutls_datum_t dt {(uint8_t*)src, static_cast<unsigned>(src_size)};
-    int flags = (password_ptr == NULL || strlen(password_ptr)==0) ? GNUTLS_PKCS_PLAIN
+    int flags = password_ptr ? GNUTLS_PKCS_PLAIN
                 : ( GNUTLS_PKCS_PBES2_AES_128 | GNUTLS_PKCS_PBES2_AES_192  | GNUTLS_PKCS_PBES2_AES_256
                   | GNUTLS_PKCS_PKCS12_3DES   | GNUTLS_PKCS_PKCS12_ARCFOUR | GNUTLS_PKCS_PKCS12_RC2_40);
 
@@ -1182,19 +1152,12 @@ loadIdentity(const std::string &path,const std::string &privkey_password)
     pkStream.close();
     // Create a certificate
     gnutls_x509_crt_t gnuCert;
-    if (gnutls_x509_crt_init(&gnuCert))
+    if (gnutls_x509_crt_init(&gnuCert) != GNUTLS_E_SUCCESS)
         throw std::runtime_error("Failed to initialize gnutls certificate struct");
     gnutls_datum_t crtContent {nullptr, 0};
-
     // Read the certificate file
-    int err = gnutls_load_file((path + ".crt").c_str(), &crtContent);
-    if (err)
-        throw CryptoException(gnutls_strerror(err));
-
-    err = gnutls_x509_crt_import(gnuCert, &crtContent, GNUTLS_X509_FMT_PEM);
-    if (err)
-        throw CryptoException(gnutls_strerror(err));
-
+    gnutls_load_file((path + ".crt").c_str(), &crtContent);
+    gnutls_x509_crt_import(gnuCert, &crtContent, GNUTLS_X509_FMT_PEM);
     auto cert = std::make_shared<Certificate>(gnuCert);
     return {std::move(key), std::move(cert)};
 }
@@ -1241,47 +1204,31 @@ Certificate::generate(const PrivateKey& key, const std::string& name, const Iden
     auto pk_id = pk.getId();
     const std::string uid_str = pk_id.toString();
 
-    int err = gnutls_x509_crt_set_subject_key_id(cert, &pk_id, sizeof(pk_id));
-    if(err) {
-        throw CryptoException(std::string("Error when setting subject key id ") + gnutls_strerror(err));
-    }
-
-    err = gnutls_x509_crt_set_dn_by_oid(cert, GNUTLS_OID_X520_COMMON_NAME, 0, name.data(), name.length());
-    if(err) {
-        throw CryptoException(std::string("Error when setting subject key id ") + gnutls_strerror(err));
-    }
-    err = gnutls_x509_crt_set_dn_by_oid(cert, GNUTLS_OID_LDAP_UID, 0, uid_str.data(), uid_str.length());
-    if(err) {
-        throw CryptoException(std::string("Error when setting dn by oid ") + gnutls_strerror(err));
-    }
+    gnutls_x509_crt_set_subject_key_id(cert, &pk_id, sizeof(pk_id));
+    gnutls_x509_crt_set_dn_by_oid(cert, GNUTLS_OID_X520_COMMON_NAME, 0, name.data(), name.length());
+    gnutls_x509_crt_set_dn_by_oid(cert, GNUTLS_OID_LDAP_UID, 0, uid_str.data(), uid_str.length());
 
     setRandomSerial(cert);
 
     unsigned key_usage = 0;
     if (is_ca) {
-        err = gnutls_x509_crt_set_ca_status(cert, 1);
-        if(err) {
-            throw CryptoException(std::string("Error when setting ca status ") + gnutls_strerror(err));
-        }
+        gnutls_x509_crt_set_ca_status(cert, 1);
         key_usage |= GNUTLS_KEY_KEY_CERT_SIGN | GNUTLS_KEY_CRL_SIGN;
     } else {
         key_usage |= GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_DATA_ENCIPHERMENT;
     }
-    err = gnutls_x509_crt_set_key_usage(cert, key_usage);
-    if(err) {
-        throw CryptoException(std::string("Error when setting ca status ") + gnutls_strerror(err));
-    }
+    gnutls_x509_crt_set_key_usage(cert, key_usage);
 
     if (ca.first && ca.second) {
         if (not ca.second->isCA()) {
             throw CryptoException("Signing certificate must be CA");
         }
-        if (err = gnutls_x509_crt_privkey_sign(cert, ca.second->cert, ca.first->key, pk.getPreferredDigest(), 0)) {
+        if (int err = gnutls_x509_crt_privkey_sign(cert, ca.second->cert, ca.first->key, pk.getPreferredDigest(), 0)) {
             throw CryptoException(std::string("Error when signing certificate ") + gnutls_strerror(err));
         }
         ret.issuer = ca.second;
     } else {
-        if (err = gnutls_x509_crt_privkey_sign(cert, cert, key.key, pk.getPreferredDigest(), 0)) {
+        if (int err = gnutls_x509_crt_privkey_sign(cert, cert, key.key, pk.getPreferredDigest(), 0)) {
             throw CryptoException(std::string("Error when signing certificate ") + gnutls_strerror(err));
         }
     }

src/dhtrunner.cpp

@@ -180,9 +180,9 @@ DhtRunner::run(const Config& config, Context&& context)
         throw;
     }
 
-    statusCbs.clear();
-    if (context.statusChangedCallback)
-        statusCbs.emplace_back(std::move(context.statusChangedCallback));
+    if (context.statusChangedCallback) {
+        statusCb = std::move(context.statusChangedCallback);
+    }
     if (context.certificateStore) {
         dht_->setLocalCertificateStore(std::move(context.certificateStore));
     }
@@ -264,17 +264,6 @@ DhtRunner::run(const Config& config, Context&& context)
                 }
             }
         }
-        if (peerDiscovery_) {
-            statusCbs.emplace_back([this](NodeStatus status4, NodeStatus status6) {
-                if (status4 == NodeStatus::Disconnected && status6 == NodeStatus::Disconnected) {
-                    peerDiscovery_->connectivityChanged();
-                }
-                else if (status4 != NodeStatus::Connected || status6 != NodeStatus::Connected) {
-                    peerDiscovery_->stopConnectivityChanged();
-                }
-
-            });
-        }
 #endif
     }
 }
@@ -701,9 +690,8 @@ DhtRunner::loop_()
     if (nstatus4 != status4 || nstatus6 != status6) {
         status4 = nstatus4;
         status6 = nstatus6;
-        for (auto& cb : statusCbs){
-            cb(status4, status6);
-        }
+        if (statusCb)
+            statusCb(status4, status6);
     }
 
     return wakeup;

src/http.cpp

@@ -461,7 +461,7 @@ Connection::set_ssl_verification(const std::string& hostname, const asio::ssl::v
                     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)
-                        logger->error("[http::connection:{:d}] ssl verification error={:d} {}", id, verify_ec, verified);
+                        logger->error("[http::connection:{:d}] ssl verification error={:d} %d", id, verify_ec, verified);
                     if (verified and checkOcsp) {
                         std::unique_ptr<stack_st_X509, void(*)(stack_st_X509*)> chain(
                             X509_STORE_CTX_get1_chain(ctx.native_handle()),

src/peer_discovery.cpp

@@ -52,7 +52,6 @@ public:
 
     void connectivityChanged();
 
-    void stopConnectivityChanged();
 private:
     Sp<Logger> logger_;
     //dmtx_ for callbackmap_ and drunning_ (write)
@@ -60,14 +59,6 @@ private:
     //mtx_ for messages_ and lrunning (listen)
     std::mutex mtx_;
     std::shared_ptr<asio::io_context> ioContext_;
-
-    static constexpr dht::duration PeerDiscovery_PERIOD_MAX{
-        std::chrono::minutes(1)};
-    static constexpr std::chrono::seconds PeerDiscovery_PERIOD{10};
-    asio::steady_timer peerDiscoveryTimer;
-    std::chrono::steady_clock::duration peerDiscovery_period{
-        PeerDiscovery_PERIOD};
-
     asio::ip::udp::socket sockFd_;
     asio::ip::udp::endpoint sockAddrSend_;
 
@@ -95,7 +86,6 @@ private:
 PeerDiscovery::DomainPeerDiscovery::DomainPeerDiscovery(asio::ip::udp domain, in_port_t port, Sp<asio::io_context> ioContext, Sp<Logger> logger)
     : logger_(logger)
     , ioContext_(ioContext)
-    , peerDiscoveryTimer(*ioContext_)
     , sockFd_(*ioContext_, domain)
     , sockAddrSend_(asio::ip::address::from_string(domain.family() == AF_INET ? MULTICAST_ADDRESS_IPV4
                                                                               : MULTICAST_ADDRESS_IPV6), port)
@@ -327,30 +317,8 @@ PeerDiscovery::DomainPeerDiscovery::reDiscover()
 void
 PeerDiscovery::DomainPeerDiscovery::connectivityChanged()
 {
-    ioContext_->post([this] () {
-        reDiscover();
-        publish(sockAddrSend_);
-    });
-    if (logger_)
-        logger_->d("PeerDiscovery: connectivity changed");
-        
-    if (peerDiscovery_period == PeerDiscovery_PERIOD_MAX ){
-        peerDiscovery_period = PeerDiscovery_PERIOD;
-    }
-    else{
-        peerDiscoveryTimer.expires_after(peerDiscovery_period);
-        peerDiscoveryTimer.async_wait([this](const asio::error_code& ec) {
-            if (ec == asio::error::operation_aborted)
-                return;
-            connectivityChanged();
-        });
-        peerDiscovery_period = std::min(peerDiscovery_period * 2, PeerDiscovery_PERIOD_MAX);
-    }
-}
-
-void PeerDiscovery::DomainPeerDiscovery::stopConnectivityChanged() {
-    peerDiscoveryTimer.cancel();
-    peerDiscovery_period = PeerDiscovery_PERIOD;
+    reDiscover();
+    publish(sockAddrSend_);
 }
 
 PeerDiscovery::PeerDiscovery(in_port_t port, Sp<asio::io_context> ioContext, Sp<Logger> logger)
@@ -463,11 +431,4 @@ PeerDiscovery::connectivityChanged()
         peerDiscovery6_->connectivityChanged();
 }
 
-void PeerDiscovery::stopConnectivityChanged() {
-   if (peerDiscovery4_)
-       peerDiscovery4_->stopConnectivityChanged();
-    if (peerDiscovery6_)
-        peerDiscovery6_->stopConnectivityChanged();
-}
-
 } /* namespace dht */

tests/cryptotester.cpp

@@ -239,27 +239,6 @@ void CryptoTester::testAesEncryption() {
     CPPUNIT_ASSERT(data2 == decrypted2);
 }
 
-void CryptoTester::testAesEncryptionWithMultipleKeySizes() {
-    auto data = std::vector<uint8_t>(rand(), rand());
-
-    // Valid key sizes
-    for (auto key_length : {16, 24, 32}) {
-        auto key = std::vector<uint8_t>(key_length, rand());
-
-        auto encrypted_data = dht::crypto::aesEncrypt(data, key);
-        auto decrypted_data = dht::crypto::aesDecrypt(encrypted_data, key);
-
-        CPPUNIT_ASSERT(data == decrypted_data);
-    }
-
-    // Invalid key sizes
-    for (auto key_length : {12, 28, 36}) {
-        auto key = std::vector<uint8_t>(key_length, rand());
-
-        CPPUNIT_ASSERT_THROW(dht::crypto::aesEncrypt(data, key), dht::crypto::DecryptError);
-    }
-}
-
 void
 CryptoTester::tearDown() {
 

tests/cryptotester.h

@@ -34,7 +34,6 @@ class CryptoTester : public CppUnit::TestFixture {
     CPPUNIT_TEST(testCertificateSerialNumber);
     CPPUNIT_TEST(testOcsp);
     CPPUNIT_TEST(testAesEncryption);
-    CPPUNIT_TEST(testAesEncryptionWithMultipleKeySizes);
     CPPUNIT_TEST_SUITE_END();
 
  public:
@@ -70,7 +69,6 @@ class CryptoTester : public CppUnit::TestFixture {
      * Test key streching and aes encryption/decryption
      */
     void testAesEncryption();
-    void testAesEncryptionWithMultipleKeySizes();
 };
 
 }  // namespace test

tests/dhtrunnertester.cpp

@@ -289,7 +289,7 @@ DhtRunnerTester::testIdOps() {
         valueCountEdit++;
         cv.notify_all();
     });
-    node2.listen(key2, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool /*expired*/){
+    node2.listen(key2, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired){
         for (const auto& v : values) {
             if (v->seq == 0)
                 CPPUNIT_ASSERT_EQUAL("v1"s, dht::unpackMsg<std::string>(v->data));