securedht: destroy dht before other fields

.github/workflows/ccpp.yml

@@ -4,7 +4,7 @@ on: [push, pull_request]
 
 jobs:
   build-ubuntu:
-    name: Ubuntu/GCC autotools build
+    name: Ubuntu/GCC Autotools build
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
@@ -42,7 +42,7 @@ jobs:
     - uses: actions/checkout@v3
     - name: Dependencies
       run: |
-        sudo apt install libncurses5-dev libreadline-dev nettle-dev \
+        sudo apt install libncurses5-dev libreadline-dev nettle-dev libfmt-dev \
         libgnutls28-dev libcppunit-dev libmsgpack-dev libargon2-0-dev
     - name: Configure
       run: |

.github/workflows/release-package.yml

@@ -213,7 +213,7 @@ jobs:
         uses: docker/build-push-action@v3
         with:
           context: .
-          file: docker/DockerfileAlpineDeps
+          file: docker/DockerfileDepsAlpine
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

CMakeLists.txt

@@ -15,7 +15,7 @@ include(cmake/CheckAtomic.cmake)
 include(CTest)
 
 set (opendht_VERSION_MAJOR 2)
-set (opendht_VERSION_MINOR 5.0)
+set (opendht_VERSION_MINOR 6.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -23,7 +23,6 @@ set (VERSION "${opendht_VERSION}")
 # Options
 option (BUILD_SHARED_LIBS "Build shared library" ON)
 CMAKE_DEPENDENT_OPTION (OPENDHT_STATIC "Build static library" OFF BUILD_SHARED_LIBS ON)
-option (OPENDHT_LOG "Build with logs" ON)
 option (OPENDHT_PYTHON "Build Python bindings" OFF)
 option (OPENDHT_TOOLS "Build DHT tools" ON)
 option (OPENDHT_SYSTEMD "Install systemd module" OFF)
@@ -61,7 +60,13 @@ if (NOT MSVC)
     pkg_search_module (Nettle REQUIRED IMPORTED_TARGET nettle)
     check_include_file_cxx(msgpack.hpp HAVE_MSGPACKCXX)
     if (NOT HAVE_MSGPACKCXX)
-        find_package (msgpack REQUIRED CONFIG)
+        find_package(msgpack QUIET CONFIG NAMES msgpack msgpackc-cxx)
+        if (NOT msgpack_FOUND)
+            find_package(msgpack REQUIRED CONFIG NAMES msgpack-cxx)
+            set(MSGPACK_TARGET "msgpack-cxx")
+        else()
+            set(MSGPACK_TARGET "msgpackc-cxx")
+        endif()
     endif()
     if (OPENDHT_TOOLS)
         find_package (Readline 6 REQUIRED)
@@ -82,10 +87,10 @@ if (NOT MSVC)
         find_path(ASIO_INCLUDE_DIR asio.hpp REQUIRED)
     endif ()
 
+    find_package(fmt)
+
     if (OPENDHT_HTTP)
         find_package(Restinio REQUIRED)
-        find_library(FMT_LIBRARY fmt)
-        add_library(fmt SHARED IMPORTED)
         find_library(HTTP_PARSER_LIBRARY http_parser)
         add_library(http_parser SHARED IMPORTED)
         set(http_parser_lib "-lhttp_parser")
@@ -135,6 +140,7 @@ if (NOT MSVC)
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type -Wno-deprecated -Wall -Wextra -Wnon-virtual-dtor -pedantic-errors -fvisibility=hidden")
     if (OPENDHT_SANITIZE)
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fstack-protector-strong")
+        set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fstack-protector-strong")
     endif ()
 else ()
     add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS
@@ -149,11 +155,6 @@ endif ()
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_NO_BOOST -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")
 
 add_definitions(-DPACKAGE_VERSION="${opendht_VERSION}")
-if (OPENDHT_LOG)
-    add_definitions(-DOPENDHT_LOG=true)
-else ()
-    add_definitions(-DOPENDHT_LOG=false)
-endif()
 
 if (ASIO_INCLUDE_DIR)
     include_directories (SYSTEM "${ASIO_INCLUDE_DIR}")
@@ -172,8 +173,8 @@ include_directories (
 include (GNUInstallDirs)
 set (prefix ${CMAKE_INSTALL_PREFIX})
 set (exec_prefix "\${prefix}")
-set (libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-set (includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+set (libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
+set (includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
 set (bindir "${CMAKE_INSTALL_FULL_BINDIR}")
 set (sysconfdir "${CMAKE_INSTALL_FULL_SYSCONFDIR}")
 set (top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
@@ -226,7 +227,7 @@ list (APPEND opendht_HEADERS
     include/opendht/rate_limiter.h
     include/opendht/securedht.h
     include/opendht/log.h
-    include/opendht/log_enable.h
+    include/opendht/logger.h
     include/opendht/thread_pool.h
     include/opendht/network_utils.h
     include/opendht.h
@@ -342,24 +343,9 @@ add_library (opendht
     ${obj_libs}
 )
 set_target_properties (opendht PROPERTIES OUTPUT_NAME "opendht")
-target_link_libraries(opendht
-    PRIVATE
-        PkgConfig::argon2
-        PkgConfig::Nettle
-        ${HTTP_PARSER_LIBRARY}
-    PUBLIC
-        ${CMAKE_THREAD_LIBS_INIT}
-        PkgConfig::GnuTLS
-        ${FMT_LIBRARY}
-)
+
 if (NOT HAVE_MSGPACKCXX)
-    target_link_libraries(opendht PUBLIC msgpackc-cxx)
-endif()
-if (Jsoncpp_FOUND)
-    target_link_libraries(opendht PUBLIC PkgConfig::Jsoncpp)
-endif()
-if (OPENDHT_PROXY_OPENSSL)
-    target_link_libraries(opendht PUBLIC PkgConfig::OPENSSL)
+    target_link_libraries(opendht PUBLIC ${MSGPACK_TARGET})
 endif()
 if (APPLE)
     target_link_libraries(opendht PRIVATE SYSTEM "-framework CoreFoundation" "-framework Security")
@@ -369,7 +355,24 @@ if (MSVC)
         target_link_libraries(opendht PUBLIC ${Win32_STATIC_LIBRARIES} ${Win32_IMPORT_LIBRARIES})
         set_target_properties (opendht PROPERTIES OUTPUT_NAME "libopendht")
     endif()
-endif ()
+else()
+    target_link_libraries(opendht
+        PRIVATE
+            PkgConfig::argon2
+            PkgConfig::Nettle
+            ${HTTP_PARSER_LIBRARY}
+        PUBLIC
+            ${CMAKE_THREAD_LIBS_INIT}
+            PkgConfig::GnuTLS
+            fmt::fmt
+    )
+    if (Jsoncpp_FOUND)
+        target_link_libraries(opendht PUBLIC PkgConfig::Jsoncpp)
+    endif()
+    if (OPENDHT_PROXY_OPENSSL)
+        target_link_libraries(opendht PUBLIC PkgConfig::OPENSSL)
+    endif()
+endif()
 
 if (BUILD_SHARED_LIBS)
     set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
@@ -426,7 +429,7 @@ install (EXPORT opendht DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/opendht FILE o
 install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendhtConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/opendht)
 
 # Unit tests
-if (BUILD_TESTING)
+if (BUILD_TESTING AND NOT MSVC)
     pkg_search_module(Cppunit REQUIRED IMPORTED_TARGET cppunit)
     # unit testing
     list (APPEND test_FILES

configure.ac

@@ -1,6 +1,6 @@
 dnl define macros
 m4_define([opendht_major_version], 2)
-m4_define([opendht_minor_version], 5)
+m4_define([opendht_minor_version], 6)
 m4_define([opendht_patch_version], 0)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])
@@ -34,12 +34,6 @@ AC_LANG(C++)
 AC_PROG_CXX
 AX_CXX_COMPILE_STDCXX(17,[noext],[mandatory])
 
-dnl Check for logs
-AC_ARG_ENABLE([logs], [AS_HELP_STRING([--disable-logs], [Disable DHT logs])])
-AS_IF([test "x$enable_logs" != "xno"], [], [
-	AC_DEFINE([OPENDHT_LOG], [false], [Define if DHT logs are disabled])
-])
-
 dnl Check for C binding
 AC_ARG_ENABLE([c], [AS_HELP_STRING([--disable-c], [Disable DHT C binding])])
 AM_CONDITIONAL(ENABLE_C, test x$enable_c != "xno")
@@ -171,15 +165,16 @@ AS_IF([test "x$have_openssl" = "xyes"], [
     AC_MSG_NOTICE([Not using OpenSSL])
 ])
 
+PKG_CHECK_MODULES([Fmt], [fmt >= 5.3.0], [have_fmt=yes], [have_fmt=no])
+AS_IF([test "x$have_fmt" = "xyes"], [
+    AC_MSG_NOTICE([Using libfmt])
+], [
+    AC_MSG_NOTICE([Missing libfmt files])
+])
+
 AM_COND_IF([PROXY_CLIENT_OR_SERVER], [
     AC_CHECK_HEADERS([asio.hpp],, AC_MSG_ERROR([Missing Asio headers files]))
     CXXFLAGS="${CXXFLAGS} -DASIO_STANDALONE"
-    PKG_CHECK_MODULES([Fmt], [fmt >= 5.3.0], [have_fmt=yes], [have_fmt=no])
-    AS_IF([test "x$have_fmt" = "xyes"], [
-        AC_MSG_NOTICE([Using libfmt])
-    ], [
-        AC_MSG_NOTICE([Missing libfmt files])
-    ])
     # http_parser has no pkgconfig, instead we check with:
     AC_CHECK_LIB(http_parser, exit,, AC_MSG_ERROR([Missing HttpParser library files]))
     AC_CHECK_HEADERS([http_parser.h], [http_parser_headers=yes; break;])

docker/Dockerfile

@@ -2,8 +2,9 @@ FROM ghcr.io/savoirfairelinux/opendht/opendht-deps:latest
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
 
-RUN git clone https://github.com/savoirfairelinux/opendht.git \
-	&& cd opendht && mkdir build && cd build \
+COPY . opendht
+
+RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \

docker/DockerfileAlpine

@@ -1,27 +1,7 @@
-FROM alpine:3.17 AS build
+FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-alpine:latest AS build
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
 
-RUN apk add --no-cache \
-        build-base cmake ninja git wget \
-        cython python3-dev py3-setuptools \
-        ncurses-dev readline-dev nettle-dev \
-        cppunit-dev gnutls-dev jsoncpp-dev \
-        argon2-dev openssl-dev fmt-dev \
-        http-parser-dev asio-dev msgpack-cxx-dev \
-    && rm -rf /var/cache/apk/*
-
-RUN echo "*** Downloading RESTinio ***" \
-    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
-    && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
-    && cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/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
-
 COPY . opendht
 
 RUN mkdir /install

docker/DockerfileBionic

@@ -2,8 +2,9 @@ FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-bionic:latest
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
 
-RUN git clone https://github.com/savoirfairelinux/opendht.git \
-	&& cd opendht && mkdir build && cd build \
+COPY . opendht
+
+RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \

docker/DockerfileFocal

@@ -2,8 +2,9 @@ FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-bionic:latest
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
 
-RUN git clone https://github.com/savoirfairelinux/opendht.git \
-	&& cd opendht && mkdir build && cd build \
+COPY . opendht
+
+RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \

docker/DockerfileLlvm

@@ -2,8 +2,9 @@ FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-llvm:latest
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
 
-RUN git clone https://github.com/savoirfairelinux/opendht.git \
-	&& cd opendht && mkdir build && cd build \
+COPY . opendht
+
+RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \

include/opendht/dht.h

@@ -67,9 +67,6 @@ public:
      */
     Dht(std::unique_ptr<net::DatagramSocket>&& sock, const Config& config, const Sp<Logger>& l = {});
 
-    Dht(std::unique_ptr<net::DatagramSocket>&& sock, const Config& config, const Logger& l = {})
-        : Dht(std::move(sock), config, std::make_shared<Logger>(l)) {}
-
     virtual ~Dht();
 
     /**

include/opendht/dht_interface.h

@@ -19,7 +19,7 @@
 #pragma once
 
 #include "infohash.h"
-#include "log_enable.h"
+#include "logger.h"
 #include "node_export.h"
 
 #include <queue>
@@ -232,18 +232,6 @@ public:
 
     virtual std::vector<SockAddr> getPublicAddress(sa_family_t family = 0) = 0;
 
-    /**
-     * Enable or disable logging of DHT internal messages
-     */
-    virtual void setLoggers(LogMethod error = {}, LogMethod warn = {}, LogMethod debug = {}) {
-        if (logger_) {
-            logger_->DBG = std::move(debug);
-            logger_->WARN = std::move(warn);
-            logger_->ERR = std::move(error);
-        } else
-            logger_= std::make_shared<Logger>(std::move(error), std::move(warn), std::move(debug));
-    }
-
     virtual void setLogger(const Logger& l) {
         if (logger_)
             *logger_ = l;

include/opendht/dht_proxy_server.h

@@ -87,7 +87,7 @@ public:
      */
     DhtProxyServer(const std::shared_ptr<DhtRunner>& dht,
         const ProxyServerConfig& config = {},
-        const std::shared_ptr<dht::Logger>& logger = {});
+        const std::shared_ptr<log::Logger>& logger = {});
 
     virtual ~DhtProxyServer();
 
@@ -364,7 +364,7 @@ private:
     mutable std::mutex requestLock_;
     std::map<unsigned int /*id*/, std::shared_ptr<http::Request>> requests_;
 
-    std::shared_ptr<dht::Logger> logger_;
+    std::shared_ptr<log::Logger> logger_;
 
     std::shared_ptr<ServerStats> stats_;
     std::shared_ptr<NodeInfo> nodeInfo_ {};

include/opendht/dhtrunner.h

@@ -25,7 +25,7 @@
 #include "value.h"
 #include "callbacks.h"
 #include "sockaddr.h"
-#include "log_enable.h"
+#include "logger.h"
 #include "network_utils.h"
 #include "node_export.h"
 
@@ -349,7 +349,6 @@ public:
     void setLogger(const Logger& logger) {
         setLogger(std::make_shared<Logger>(logger));
     }
-    void setLoggers(LogMethod err = {}, LogMethod warn = {}, LogMethod debug = {});
 
     /**
      * Only print logs related to the given InfoHash (if given), or disable filter (if zeroes).

include/opendht/http.h

@@ -53,7 +53,9 @@ class tls_socket_t;
 }
 
 namespace dht {
+namespace log {
 struct Logger;
+}
 
 namespace crypto {
 struct Certificate;
@@ -88,9 +90,9 @@ public:
 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 = {});
+    Connection(asio::io_context& ctx, const bool ssl = true, std::shared_ptr<log::Logger> l = {});
     Connection(asio::io_context& ctx, std::shared_ptr<dht::crypto::Certificate> server_ca,
-               const dht::crypto::Identity& identity, std::shared_ptr<dht::Logger> l = {});
+               const dht::crypto::Identity& identity, std::shared_ptr<log::Logger> l = {});
     ~Connection();
 
     inline unsigned int id() const { return  id_; };
@@ -148,7 +150,7 @@ private:
     asio::ip::address local_address_;
 
     std::unique_ptr<asio::steady_timer> timeout_timer_;
-    std::shared_ptr<dht::Logger> logger_;
+    std::shared_ptr<log::Logger> logger_;
     bool checkOcsp_ {false};
 };
 
@@ -172,15 +174,15 @@ public:
     using ResolverCb = std::function<void(const asio::error_code& ec,
                                           const std::vector<asio::ip::tcp::endpoint>& endpoints)>;
 
-    Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
+    Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::Logger> logger = {});
     Resolver(asio::io_context& ctx, const std::string& host, const std::string& service,
-             const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
+             const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
 
     // 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 = {});
+             const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
     Resolver(asio::io_context& ctx, const std::string& url, std::vector<asio::ip::tcp::endpoint> endpoints,
-            std::shared_ptr<dht::Logger> logger = {});
+            std::shared_ptr<log::Logger> logger = {});
 
     ~Resolver();
 
@@ -190,7 +192,7 @@ public:
 
     void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC);
 
-    std::shared_ptr<Logger> getLogger() const {
+    std::shared_ptr<log::Logger> getLogger() const {
         return logger_;
     }
 
@@ -208,7 +210,7 @@ private:
     bool completed_ {false};
     std::queue<ResolverCb> cbs_;
 
-    std::shared_ptr<dht::Logger> logger_;
+    std::shared_ptr<log::Logger> logger_;
 };
 
 class Request;
@@ -240,14 +242,14 @@ public:
 
     // resolves implicitly
     Request(asio::io_context& ctx, const std::string& url, const Json::Value& json, OnJsonCb jsoncb,
-            std::shared_ptr<dht::Logger> logger = {});
+            std::shared_ptr<log::Logger> logger = {});
     Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb,
-            std::shared_ptr<dht::Logger> logger = {});
+            std::shared_ptr<log::Logger> logger = {});
 
-    Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::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 = {});
+            const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});
 
     // user defined resolver
     Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, sa_family_t family = AF_UNSPEC);
@@ -255,7 +257,7 @@ public:
 
     // user defined resolved endpoints
     Request(asio::io_context& ctx, std::vector<asio::ip::tcp::endpoint>&& endpoints,
-            const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
+            const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
 
     ~Request();
 
@@ -282,7 +284,7 @@ public:
 
     void set_certificate_authority(std::shared_ptr<dht::crypto::Certificate> certificate);
     void set_identity(const dht::crypto::Identity& identity);
-    void set_logger(std::shared_ptr<dht::Logger> logger);
+    void set_logger(std::shared_ptr<log::Logger> logger);
 
     /**
      * Define the HTTP header/body as per https://tools.ietf.org/html/rfc7230.
@@ -347,7 +349,7 @@ private:
 
     mutable std::mutex mutex_;
 
-    std::shared_ptr<dht::Logger> logger_;
+    std::shared_ptr<log::Logger> logger_;
 
     restinio::http_request_header_t header_;
     std::map<restinio::http_field_t, std::string> headers_;

include/opendht/infohash.h

@@ -22,6 +22,7 @@
 #include "rng.h"
 
 #include <msgpack.hpp>
+#include <fmt/core.h>
 
 #ifndef _WIN32
 #include <netinet/in.h>
@@ -229,6 +230,11 @@ public:
         return get(data.data(), data.size());
     }
 
+    template <size_t H>
+    static Hash get(const Hash<H>& o) {
+        return get(o.data(), o.size());
+    }
+
     /**
      * Computes the hash from a given data buffer of size data_len.
      */
@@ -389,3 +395,10 @@ Hash<N>::toString() const
 }
 
 }
+
+template <size_t N>
+struct fmt::formatter<dht::Hash<N>>: formatter<string_view> {
+  constexpr auto format(const dht::Hash<N>& c, format_context& ctx) const {
+    return formatter<string_view>::format(c.to_view(), ctx);
+  }
+};

include/opendht/log.h

@@ -20,7 +20,7 @@
 #pragma once
 
 #include "def.h"
-#include "log_enable.h"
+#include "logger.h"
 
 #include <iostream>
 #include <memory>
@@ -34,42 +34,6 @@ class DhtRunner;
  */
 namespace log {
 
-/**
- * Terminal colors for logging
- */
-namespace Color {
-    enum Code {
-        FG_RED      = 31,
-        FG_GREEN    = 32,
-        FG_YELLOW   = 33,
-        FG_BLUE     = 34,
-        FG_DEFAULT  = 39,
-        BG_RED      = 41,
-        BG_GREEN    = 42,
-        BG_BLUE     = 44,
-        BG_DEFAULT  = 49
-    };
-    class Modifier {
-        const Code code;
-    public:
-        constexpr Modifier(Code pCode) : code(pCode) {}
-        friend std::ostream&
-        operator<<(std::ostream& os, const Modifier& mod) {
-            return os << "\033[" << mod.code << 'm';
-        }
-    };
-}
-
-constexpr const Color::Modifier def(Color::FG_DEFAULT);
-constexpr const Color::Modifier red(Color::FG_RED);
-constexpr const Color::Modifier yellow(Color::FG_YELLOW);
-
-/**
- * Print va_list to std::ostream (used for logging).
- */
-OPENDHT_PUBLIC void
-printLog(std::ostream &s, char const *m, va_list args);
-
 OPENDHT_PUBLIC
 std::shared_ptr<Logger> getStdLogger();
 

include/opendht/log_enable.h

@@ -1,191 +0,0 @@
-/*
- *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
- *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "infohash.h"
-
-#include <cstdarg>
-
-#ifndef OPENDHT_LOG
-#define OPENDHT_LOG true
-#endif
-
-namespace dht {
-
-// Logging related utility functions
-
-/**
- * Wrapper for logging methods
- */
-struct LogMethod {
-    LogMethod() = default;
-
-    LogMethod(LogMethod&& l) : func(std::move(l.func)) {}
-    LogMethod(const LogMethod& l) : func(l.func) {}
-
-    LogMethod& operator=(dht::LogMethod&& l) {
-        func = std::forward<LogMethod>(l.func);
-        return *this;
-    }
-    LogMethod& operator=(const dht::LogMethod& l) {
-        func = l.func;
-        return *this;
-    }
-
-    template<typename T>
-    explicit LogMethod(T&& t) : func(std::forward<T>(t)) {}
-
-    template<typename T>
-    LogMethod(const T& t) : func(t) {}
-
-    void operator()(char const* format, ...) const {
-        va_list args;
-        va_start(args, format);
-        func(format, args);
-        va_end(args);
-    }
-    inline void log(char const* format, va_list args) const {
-        func(format, args);
-    }
-    explicit operator bool() const {
-        return (bool)func;
-    }
-
-    void logPrintable(const uint8_t *buf, size_t buflen) const {
-        std::string buf_clean(buflen, '\0');
-        for (size_t i=0; i<buflen; i++)
-            buf_clean[i] = isprint(buf[i]) ? buf[i] : '.';
-        (*this)("%s", buf_clean.c_str());
-    }
-private:
-    std::function<void(char const*, va_list)> func;
-};
-
-struct Logger {
-    LogMethod ERR = {};
-    LogMethod WARN = {};
-    LogMethod DBG = {};
-
-    Logger() = default;
-    Logger(LogMethod&& err, LogMethod&& warn, LogMethod&& dbg)
-        : ERR(std::move(err)), WARN(std::move(warn)), DBG(std::move(dbg)) {}
-    void setFilter(const InfoHash& f) {
-        filter_ = f;
-        filterEnable_ = static_cast<bool>(filter_);
-    }
-    inline void log0(const LogMethod& logger, char const* format, va_list args) const {
-#if OPENDHT_LOG
-        if (logger and not filterEnable_)
-            logger.log(format, args);
-#endif
-    }
-    inline void log1(const LogMethod& logger, const InfoHash& f, char const* format, va_list args) const {
-#if OPENDHT_LOG
-        if (logger and (not filterEnable_ or f == filter_))
-            logger.log(format, args);
-#endif
-    }
-    inline void log2(const LogMethod& logger, const InfoHash& f1, const InfoHash& f2, char const* format, va_list args) const {
-#if OPENDHT_LOG
-        if (logger and (not filterEnable_ or f1 == filter_ or f2 == filter_))
-            logger.log(format, args);
-#endif
-    }
-    inline void d(char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log0(DBG, format, args);
-        va_end(args);
-#endif
-    }
-    inline void d(const InfoHash& f, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log1(DBG, f, format, args);
-        va_end(args);
-#endif
-    }
-    inline void d(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log2(DBG, f1, f2, format, args);
-        va_end(args);
-#endif
-    }
-    inline void w(char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log0(WARN, format, args);
-        va_end(args);
-#endif
-    }
-    inline void w(const InfoHash& f, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log1(WARN, f, format, args);
-        va_end(args);
-#endif
-    }
-    inline void w(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log2(WARN, f1, f2, format, args);
-        va_end(args);
-#endif
-    }
-    inline void e(char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log0(ERR, format, args);
-        va_end(args);
-#endif
-    }
-    inline void e(const InfoHash& f, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log1(ERR, f, format, args);
-        va_end(args);
-#endif
-    }
-    inline void e(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
-#if OPENDHT_LOG
-        va_list args;
-        va_start(args, format);
-        log2(ERR, f1, f2, format, args);
-        va_end(args);
-#endif
-    }
-private:
-    bool filterEnable_ {false};
-    InfoHash filter_ {};
-};
-
-}

include/opendht/logger.h

@@ -0,0 +1,119 @@
+/*
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
+ *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "infohash.h"
+
+#include <fmt/format.h>
+#include <fmt/printf.h>
+
+#include <functional>
+#include <string_view>
+#include <cstdarg>
+
+namespace dht {
+namespace log {
+
+enum class LogLevel {
+    debug, warning, error
+};
+
+using LogMethod = std::function<void(LogLevel, std::string&&)>;
+
+struct Logger {
+    LogMethod logger = {};
+
+    Logger() = delete;
+    Logger(LogMethod&& l)
+        : logger(std::move(l)) {
+            if (!logger)
+                throw std::invalid_argument{"logger and loggerf must be set"};
+        }
+    void setFilter(const InfoHash& f) {
+        filter_ = f;
+        filterEnable_ = static_cast<bool>(filter_);
+    }
+    inline void log0(LogLevel level, fmt::string_view format, fmt::printf_args args) const {
+        if (not filterEnable_)
+            logger(level, fmt::vsprintf(format, args));
+    }
+    inline void log1(LogLevel level, const InfoHash& f, fmt::string_view format, fmt::printf_args args) const {
+        if (not filterEnable_ or f == filter_)
+            logger(level, fmt::vsprintf(format, args));
+    }
+    inline void log2(LogLevel level, const InfoHash& f1, const InfoHash& f2, fmt::string_view format, fmt::printf_args args) const {
+        if (not filterEnable_ or f1 == filter_ or f2 == filter_)
+            logger(level, fmt::vsprintf(format, args));
+    }
+    template<typename S, typename... Args>
+    inline void debug(S&& format, Args&&... args) const {
+        logger(LogLevel::debug, fmt::format(format, args...));
+    }
+    template<typename S, typename... Args>
+    inline void warn(S&& format, Args&&... args) const {
+        logger(LogLevel::warning, fmt::format(format, args...));
+    }
+    template<typename S, typename... Args>
+    inline void error(S&& format, Args&&... args) const {
+        logger(LogLevel::error, fmt::format(format, args...));
+    }
+    template <typename... T>
+    inline void d(fmt::format_string<T...> format, T&&... args) const {
+        log0(LogLevel::debug, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void d(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
+        log1(LogLevel::debug, f, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void d(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
+        log2(LogLevel::debug, f1, f2, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void w(fmt::format_string<T...> format, T&&... args) const {
+        log0(LogLevel::warning, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void w(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
+        log1(LogLevel::warning, f, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void w(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
+        log2(LogLevel::warning, f1, f2, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void e(fmt::format_string<T...> format, T&&... args) const {
+        log0(LogLevel::error, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void e(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
+        log1(LogLevel::error, f, format, fmt::make_printf_args(args...));
+    }
+    template <typename... T>
+    inline void e(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
+        log2(LogLevel::error, f1, f2, format, fmt::make_printf_args(args...));
+    }
+private:
+    bool filterEnable_ {false};
+    InfoHash filter_ {};
+};
+
+}
+using Logger = log::Logger;
+}

include/opendht/network_engine.h

@@ -27,7 +27,7 @@
 #include "utils.h"
 #include "rng.h"
 #include "rate_limiter.h"
-#include "log_enable.h"
+#include "logger.h"
 #include "network_utils.h"
 
 #include <vector>

include/opendht/network_utils.h

@@ -21,7 +21,7 @@
 
 #include "sockaddr.h"
 #include "utils.h"
-#include "log_enable.h"
+#include "logger.h"
 
 #ifdef _WIN32
 #include <ws2tcpip.h>

include/opendht/peer_discovery.h

@@ -22,7 +22,7 @@
 #include "def.h"
 #include "sockaddr.h"
 #include "infohash.h"
-#include "log_enable.h"
+#include "logger.h"
 
 #include <thread>
 

include/opendht/securedht.h

@@ -378,7 +378,7 @@ const ValueType CERTIFICATE_TYPE = {
         try {
             crypto::Certificate crt(v->data);
             // TODO check certificate signature
-            return crt.getPublicKey().getId() == id;
+            return crt.getPublicKey().getId() == id || InfoHash::get(crt.getPublicKey().getLongId()) == id;
         } catch (const std::exception& e) {}
         return false;
     },

include/opendht/sockaddr.h

@@ -20,6 +20,10 @@
 
 #include "def.h"
 
+#include <fmt/core.h>
+#include <fmt/format.h>
+#include <fmt/ostream.h>
+
 #ifndef _WIN32
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -48,6 +52,7 @@ typedef uint16_t in_port_t;
 
 namespace dht {
 
+OPENDHT_PUBLIC void print_addr(std::ostream& os, const sockaddr* sa, socklen_t slen);
 OPENDHT_PUBLIC std::string print_addr(const sockaddr* sa, socklen_t slen);
 OPENDHT_PUBLIC std::string print_addr(const sockaddr_storage& ss, socklen_t sslen);
 
@@ -289,6 +294,11 @@ public:
                                (uint8_t*)b.get()+start, len) < 0;
         }
     };
+    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const SockAddr& h) {
+        print_addr(s, h.get(), h.getLength());
+        return s;
+    }
+
 private:
     struct free_delete { void operator()(void* p) { ::free(p); } };
     std::unique_ptr<sockaddr, free_delete> addr {};
@@ -309,3 +319,7 @@ private:
 OPENDHT_PUBLIC bool operator==(const SockAddr& a, const SockAddr& b);
 
 }
+
+#if FMT_VERSION >= 90000
+template <> struct fmt::formatter<dht::SockAddr> : ostream_formatter {};
+#endif

meson.build

@@ -1,5 +1,5 @@
 project('opendht', 'c', 'cpp',
-    version: '2.5.0',
+    version: '2.6.0',
     default_options: [
         'cpp_std=c++17',
         'warning_level=3'
@@ -11,6 +11,7 @@ msgpack = dependency('msgpack-cxx', required : false)
 argon2 = dependency('libargon2')
 openssl = dependency('openssl', required: get_option('proxy_client'))
 jsoncpp = dependency('jsoncpp', required: get_option('proxy_client'))
+fmt = dependency('fmt')
 
 dirs=[]
 if host_machine.system() == 'freebsd'
@@ -19,7 +20,7 @@ elif host_machine.system() == 'darwin'
     dirs+='/opt/homebrew/lib'
 endif
 http_parser = meson.get_compiler('c').find_library('http_parser', dirs: dirs, required: get_option('proxy_client'))
-deps = [gnutls, nettle, msgpack, argon2, openssl, jsoncpp, http_parser]
+deps = [fmt, gnutls, nettle, msgpack, argon2, openssl, jsoncpp, http_parser]
 
 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')
@@ -79,6 +80,16 @@ if get_option('tools').enabled()
         link_with : opendht,
         dependencies : [readline, msgpack],
         install : true)
+    dhtchat = executable('dhtchat', 'tools/dhtchat.cpp',
+        include_directories : opendht_interface_inc,
+        link_with : opendht,
+        dependencies : [readline, msgpack],
+        install : true)
+    dhtscanner = executable('dhtscanner', 'tools/dhtscanner.cpp',
+        include_directories : opendht_interface_inc,
+        link_with : opendht,
+        dependencies : [readline, msgpack],
+        install : true)
     if http_parser.found()
         durl = executable('durl', 'tools/durl.cpp',
         include_directories : opendht_interface_inc,

python/tools/http_server.py

@@ -72,7 +72,7 @@ if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Launch an OpenDHT node with an HTTP control interface')
     parser.add_argument('-p', '--port', help='OpenDHT port to bind', type=int, default=4222)
     parser.add_argument('-hp', '--http-port', help='HTTP port to bind', type=int, default=8080)
-    parser.add_argument('-b', '--bootstrap', help='bootstrap address', default="bootstrap.ring.cx:4222")
+    parser.add_argument('-b', '--bootstrap', help='bootstrap address', default="bootstrap.jami.net:4222")
     args = parser.parse_args()
     endpoints.serverFromString(reactor, "tcp:"+str(args.http_port)).listen(server.Site(DhtServer(args.port, args.bootstrap)))
     reactor.run()

python/tools/network_monitor.py

@@ -24,7 +24,7 @@ from datetime import datetime
 import opendht as dht
 
 parser = argparse.ArgumentParser(description='Create a dht network of -n nodes')
-parser.add_argument('-b', '--bootstrap', help='bootstrap address', default='bootstrap.ring.cx')
+parser.add_argument('-b', '--bootstrap', help='bootstrap address', default='bootstrap.jami.net')
 parser.add_argument('-n', '--num-ops', help='number of concurrent operations on the DHT', type=int, default=8)
 parser.add_argument('-p', '--period', help='duration between each test (seconds)', type=int, default=60)
 parser.add_argument('-t', '--timeout', help='timeout for a test to complete (seconds)', type=float, default=15)

python/tools/pingpong.py

@@ -25,8 +25,7 @@ config.setRateLimit(-1, -1)
 ping_node = dht.DhtRunner()
 ping_node.run(config=config)
 #ping_node.enableLogging()
-#ping_node.bootstrap("bootstrap.ring.cx", "4222")
-
+#ping_node.bootstrap("bootstrap.jami.net", "4222")
 pong_node = dht.DhtRunner()
 pong_node.run(config=config)
 #pong_node.enableLogging()

src/Makefile.am

@@ -39,6 +39,7 @@ nobase_include_HEADERS = \
         ../include/opendht/dht.h \
         ../include/opendht/callbacks.h \
         ../include/opendht/node_cache.h \
+        ../include/opendht/node_export.h \
         ../include/opendht/routing_table.h \
         ../include/opendht/network_engine.h \
         ../include/opendht/scheduler.h \
@@ -53,7 +54,7 @@ nobase_include_HEADERS = \
         ../include/opendht/dhtrunner.h \
         ../include/opendht/default_types.h \
         ../include/opendht/log.h \
-        ../include/opendht/log_enable.h \
+        ../include/opendht/logger.h \
         ../include/opendht/network_utils.h \
         ../include/opendht/rng.h \
         ../include/opendht/thread_pool.h

src/compat/os_cert.cpp

@@ -18,7 +18,7 @@
 
 #include "os_cert.h"
 
-#include "log_enable.h"
+#include "logger.h"
 
 #ifdef _WIN32
 #include <windows.h>

src/compat/os_cert.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "log_enable.h"
+#include "logger.h"
 
 #include <memory>
 

src/dht.cpp

@@ -1840,7 +1840,7 @@ Dht::Dht(std::unique_ptr<net::DatagramSocket>&& sock, const Config& config, cons
     expire();
 
     if (logger_)
-        logger_->d("DHT node initialised with ID %s", myid.toString().c_str());
+        logger_->debug("DHT node initialised with ID {:s}", myid);
 }
 
 bool
@@ -2232,7 +2232,7 @@ Dht::pingNode(SockAddr sa, DoneCallbackSimple&& cb)
 {
     scheduler.syncTime();
     if (logger_)
-        logger_->d("Sending ping to %s", sa.toString().c_str());
+        logger_->debug("Sending ping to {}", sa);
     auto& count = dht(sa.getFamily()).pending_pings;
     count++;
     network_engine.sendPing(std::move(sa), [&count,cb](const net::Request&, net::RequestAnswer&&) {

src/dht_proxy_server.cpp

@@ -1053,7 +1053,7 @@ DhtProxyServer::handleCancelPushListen(const asio::error_code &ec, const std::st
 void
 DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& json, PushType type, bool highPriority, const std::string& topic)
 {
-    if (pushServer_.empty())
+    if (pushServer_.empty() && type != PushType::UnifiedPush)
         return;
 
     unsigned reqid = 0;

src/dhtrunner.cpp

@@ -93,7 +93,7 @@ DhtRunner::run(const Config& config, Context&& context)
     auto expected = State::Idle;
     if (not running.compare_exchange_strong(expected, State::Running)) {
         if (context.logger)
-            context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", this);
+            context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", fmt::ptr(this));
         return;
     }
 
@@ -102,7 +102,7 @@ DhtRunner::run(const Config& config, Context&& context)
         auto local6 = config.bind6;
         if (not local4 and not local6) {
             if (context.logger)
-                context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", this);
+                context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", fmt::ptr(this));
             local4.setFamily(AF_INET);
             local6.setFamily(AF_INET6);
         }
@@ -116,14 +116,14 @@ DhtRunner::run(const Config& config, Context&& context)
                 if (inConfig >> port) {
                     if (local4.getPort() == 0) {
                         if (context.logger)
-                            context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", this, port);
+                            context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", fmt::ptr(this), port);
                         local4.setPort(port);
                     }
                 }
                 if (inConfig >> port) {
                     if (local6.getPort() == 0) {
                         if (context.logger)
-                            context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", this, port);
+                            context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", fmt::ptr(this), port);
                         local6.setPort(port);
                     }
                 }
@@ -132,7 +132,7 @@ DhtRunner::run(const Config& config, Context&& context)
 
         if (context.logger) {
             logger_ = context.logger;
-            logger_->d("[runner %p] state changed to Running", this);
+            logger_->d("[runner %p] state changed to Running", fmt::ptr(this));
         }
 
 #ifdef OPENDHT_PROXY_CLIENT
@@ -155,7 +155,7 @@ DhtRunner::run(const Config& config, Context&& context)
                         dropped++;
                     }
                     if (dropped and logger_) {
-                        logger_->w("[runner %p] dropped %zu packets: queue is full!", this, dropped);
+                        logger_->w("[runner %p] dropped %zu packets: queue is full!", fmt::ptr(this), dropped);
                     }
                     ret = std::move(rcv_free);
                 }
@@ -281,7 +281,7 @@ DhtRunner::shutdown(ShutdownCallback cb, bool stop) {
         return;
     }
     if (logger_)
-        logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", this, ongoing_ops.load());
+        logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", fmt::ptr(this), ongoing_ops.load());
     ongoing_ops++;
     shutdownCallbacks_.emplace_back(std::move(cb));
     pending_ops.emplace([=](SecureDht&) mutable {
@@ -346,7 +346,7 @@ DhtRunner::join()
             if (auto sock = dht_->getSocket())
                 sock->stop();
         if (logger_)
-            logger_->d("[runner %p] state changed to Idle", this);
+            logger_->d("[runner %p] state changed to Idle", fmt::ptr(this));
     }
 
     if (dht_thread.joinable())
@@ -355,7 +355,7 @@ DhtRunner::join()
     {
         std::lock_guard<std::mutex> lck(storage_mtx);
         if (ongoing_ops and logger_) {
-            logger_->w("[runner %p] stopping with %zu remaining ops", this, ongoing_ops.load());
+            logger_->w("[runner %p] stopping with %zu remaining ops", fmt::ptr(this), ongoing_ops.load());
         }
         pending_ops = decltype(pending_ops)();
         pending_ops_prio = decltype(pending_ops_prio)();
@@ -454,12 +454,6 @@ DhtRunner::setLogger(const Sp<Logger>& logger) {
         dht_->setLogger(logger);
 }
 
-void
-DhtRunner::setLoggers(LogMethod error, LogMethod warn, LogMethod debug) {
-    Logger logger {std::move(error), std::move(warn), std::move(debug)};
-    setLogger(logger);
-}
-
 void
 DhtRunner::setLogFilter(const InfoHash& f) {
     std::lock_guard<std::mutex> lck(dht_mtx);
@@ -686,7 +680,7 @@ DhtRunner::loop_()
     }
 
     if (dropped && logger_)
-        logger_->e("[runner %p] Dropped %zu packets with high delay.", this, dropped);
+        logger_->e("[runner %p] Dropped %zu packets with high delay.", fmt::ptr(this), dropped);
 
     NodeStatus nstatus4 = dht_->updateStatus(AF_INET);
     NodeStatus nstatus6 = dht_->updateStatus(AF_INET6);

src/http.cpp

@@ -17,7 +17,7 @@
  */
 
 #include "http.h"
-#include "log_enable.h"
+#include "logger.h"
 #include "crypto.h"
 #include "base64.h"
 #include "compat/os_cert.h"
@@ -111,11 +111,11 @@ newTlsClientContext(const std::shared_ptr<dht::Logger>& logger)
 
     if (char* path = getenv("CA_ROOT_FILE")) {
         if (logger)
-            logger->d("Using CA file: %s", path);
+            logger->debug("Using CA file: {}", path);
         ctx->load_verify_file(path);
     } else if (char* path = getenv("CA_ROOT_PATH")) {
         if (logger)
-            logger->d("Using CA path: %s", path);
+            logger->debug("Using CA path: {}", path);
         ctx->add_verify_path(path);
     } else {
 #ifdef __ANDROID__

src/log.cpp

@@ -20,6 +20,10 @@
 #include "log.h"
 #include "dhtrunner.h"
 
+#include <fmt/format.h>
+#include <fmt/ostream.h>
+#include <fmt/printf.h>
+
 #ifndef _WIN32
 #include <syslog.h>
 #endif
@@ -30,46 +34,70 @@
 namespace dht {
 namespace log {
 
+/**
+ * Terminal colors for logging
+ */
+namespace Color {
+    enum Code {
+        FG_RED      = 31,
+        FG_GREEN    = 32,
+        FG_YELLOW   = 33,
+        FG_BLUE     = 34,
+        FG_DEFAULT  = 39,
+        BG_RED      = 41,
+        BG_GREEN    = 42,
+        BG_BLUE     = 44,
+        BG_DEFAULT  = 49
+    };
+    class Modifier {
+        const Code code;
+    public:
+        constexpr Modifier(Code pCode) : code(pCode) {}
+        friend std::ostream&
+        operator<<(std::ostream& os, const Modifier& mod) {
+            return os << "\033[" << mod.code << 'm';
+        }
+    };
+}
+
+constexpr const Color::Modifier def(Color::FG_DEFAULT);
+constexpr const Color::Modifier red(Color::FG_RED);
+constexpr const Color::Modifier yellow(Color::FG_YELLOW);
+
 /**
  * Print va_list to std::ostream (used for logging).
  */
 void
-printLog(std::ostream& s, char const *m, va_list args) {
-    // print log to buffer
-    std::array<char, 8192> buffer;
-    int ret = vsnprintf(buffer.data(), buffer.size(), m, args);
-    if (ret <= 0)
-        return;
-
-    // write timestamp
+printfLog(std::ostream& s, const std::string& message) {
     using namespace std::chrono;
     using log_precision = microseconds;
-    constexpr auto den = log_precision::period::den;
     auto num = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
-    s << "[" << std::setfill('0') << std::setw(6) << num / den << "."
-             << std::setfill('0') << std::setw(6) << num % den << "]" << " ";
-
-    // write log
-    s.write(buffer.data(), std::min((size_t) ret, buffer.size()));
-    if ((size_t) ret >= buffer.size())
-        s << "[[TRUNCATED]]";
+    constexpr auto den = log_precision::period::den;
+    fmt::print(s, "[{:06d}.{:06d}] ", num / den, num % den);
+    s << message << std::endl;
+}
+void
+printLog(std::ostream& s, fmt::string_view format, fmt::format_args args) {
+    using namespace std::chrono;
+    using log_precision = microseconds;
+    auto num = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
+    constexpr auto den = log_precision::period::den;
+    fmt::print(s, "[{:06d}.{:06d}] ", num / den, num % den);
+    fmt::vprint(s, format, args);
     s << std::endl;
 }
 
 std::shared_ptr<Logger>
 getStdLogger() {
     return std::make_shared<Logger>(
-        [](char const *m, va_list args) {
-            std::cerr << red;
-            printLog(std::cerr, m, args);
+        [](LogLevel level, std::string&& message) {
+            if (level == LogLevel::error)
+                std::cerr << red;
+            else if (level == LogLevel::warning)
+                std::cerr << yellow;
+            printfLog(std::cerr, message);
             std::cerr << def;
-        },
-        [](char const *m, va_list args) {
-            std::cout << yellow;
-            printLog(std::cout, m, args);
-            std::cout << def;
-        },
-        [](char const *m, va_list args) { printLog(std::cout, m, args); }
+        }
     );
 }
 
@@ -77,14 +105,26 @@ std::shared_ptr<Logger>
 getFileLogger(const std::string &path) {
     auto logfile = std::make_shared<std::ofstream>();
     logfile->open(path, std::ios::out);
-
     return std::make_shared<Logger>(
-        [=](char const *m, va_list args) { printLog(*logfile, m, args); },
-        [=](char const *m, va_list args) { printLog(*logfile, m, args); },
-        [=](char const *m, va_list args) { printLog(*logfile, m, args); }
+        [logfile](LogLevel /*level*/, std::string&& message) {
+            printfLog(*logfile, message);
+        }
     );
 }
 
+constexpr
+int syslogLevel(LogLevel level) {
+    switch (level) {
+    case LogLevel::error:
+        return LOG_ERR;
+    case LogLevel::warning:
+        return LOG_WARNING;
+    case LogLevel::debug:
+        return LOG_INFO;
+    }
+    return LOG_ERR;
+}
+
 std::shared_ptr<Logger>
 getSyslogLogger(const char* name) {
 #ifndef _WIN32
@@ -104,10 +144,9 @@ getSyslogLogger(const char* name) {
         opened_logfile = logfile;
     }
     return std::make_shared<Logger>(
-        [logfile](char const *m, va_list args) { vsyslog(LOG_ERR, m, args); },
-        [logfile](char const *m, va_list args) { vsyslog(LOG_WARNING, m, args); },
-        [logfile](char const *m, va_list args) { vsyslog(LOG_INFO, m, args); }
-    );
+        [logfile](LogLevel level, std::string&& message) {
+            syslog(syslogLevel(level), "%s", message.c_str());
+        });
 #else
     return std::make_shared<Logger>();
 #endif

src/network_engine.cpp

@@ -20,7 +20,7 @@
 #include "network_engine.h"
 #include "request.h"
 #include "default_types.h"
-#include "log_enable.h"
+#include "logger.h"
 #include "parsed_message.h"
 
 #include <msgpack.hpp>

src/securedht.cpp

@@ -66,7 +66,9 @@ SecureDht::SecureDht(std::unique_ptr<DhtInterface> dht, SecureDht::Config conf,
     }
 }
 
-SecureDht::~SecureDht() = default;
+SecureDht::~SecureDht(){
+    dht_.reset();
+}
 
 ValueType
 SecureDht::secureType(ValueType&& type)

src/utils.cpp

@@ -103,21 +103,26 @@ SockAddr::setAddress(const char* address)
         throw std::runtime_error(std::string("Can't parse IP address: ") + strerror(errno));
 }
 
-std::string
-print_addr(const sockaddr* sa, socklen_t slen)
+void print_addr(std::ostream& out, const sockaddr* sa, socklen_t slen)
 {
     char hbuf[NI_MAXHOST];
     char sbuf[NI_MAXSERV];
-    std::ostringstream out;
     if (sa and slen and !getnameinfo(sa, slen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
         if (sa->sa_family == AF_INET6)
-            out << "[" << hbuf << "]";
+            out << '[' << hbuf << ']';
         else
             out << hbuf;
         if (std::strcmp(sbuf, "0"))
-            out << ":" << sbuf;
+            out << ':' << sbuf;
     } else
         out << "[invalid address]";
+}
+
+std::string
+print_addr(const sockaddr* sa, socklen_t slen)
+{
+    std::ostringstream out;
+    print_addr(out, sa, slen);
     return out.str();
 }
 

tools/CMakeLists.txt

@@ -38,7 +38,7 @@ endif ()
 install (TARGETS dhtnode dhtscanner dhtchat RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 if (OPENDHT_SYSTEMD)
-    if (NOT DEFINED OPENDHT_SYSTEMD_UNIT_FILE_LOCATION)
+    if (NOT DEFINED OPENDHT_SYSTEMD_UNIT_FILE_LOCATION OR NOT OPENDHT_SYSTEMD_UNIT_FILE_LOCATION)
         execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} systemd --variable=systemdsystemunitdir
                         OUTPUT_VARIABLE SYSTEMD_UNIT_INSTALL_DIR)
         message("-- Using Systemd unit installation directory by pkg-config: " ${SYSTEMD_UNIT_INSTALL_DIR})
@@ -46,23 +46,30 @@ if (OPENDHT_SYSTEMD)
         message("-- Using Systemd unit installation directory requested: " ${OPENDHT_SYSTEMD_UNIT_FILE_LOCATION})
         set(SYSTEMD_UNIT_INSTALL_DIR ${OPENDHT_SYSTEMD_UNIT_FILE_LOCATION})
     endif()
-    string(REGEX REPLACE "[ \t\n]+" "" SYSTEMD_UNIT_INSTALL_DIR "${SYSTEMD_UNIT_INSTALL_DIR}")
-    set (systemdunitdir "${SYSTEMD_UNIT_INSTALL_DIR}")
 
     configure_file (
         systemd/dhtnode.service.in
         systemd/dhtnode.service
         @ONLY
     )
-    install (FILES ${CMAKE_CURRENT_BINARY_DIR}/systemd/dhtnode.service DESTINATION ${systemdunitdir})
-    install (FILES systemd/dhtnode.conf DESTINATION ${sysconfdir})
+    if (SYSTEMD_UNIT_INSTALL_DIR)
+        string(REGEX REPLACE "[ \t\n]+" "" SYSTEMD_UNIT_INSTALL_DIR "${SYSTEMD_UNIT_INSTALL_DIR}")
+        set (systemdunitdir "${SYSTEMD_UNIT_INSTALL_DIR}")
+        install (FILES ${CMAKE_CURRENT_BINARY_DIR}/systemd/dhtnode.service DESTINATION ${systemdunitdir})
+        install (FILES systemd/dhtnode.conf DESTINATION ${sysconfdir})
+    else()
+        message(WARNING "Systemd unit installation directory not found. The systemd unit won't be installed.")
+    endif()
+
     if (OPENDHT_PYTHON)
         configure_file (
             systemd/dhtcluster.service.in
             systemd/dhtcluster.service
             @ONLY
         )
-        install (FILES ${CMAKE_CURRENT_BINARY_DIR}/systemd/dhtcluster.service DESTINATION ${systemdunitdir})
-        install (FILES systemd/dhtcluster.conf DESTINATION ${sysconfdir})
+        if (SYSTEMD_UNIT_INSTALL_DIR)
+            install (FILES ${CMAKE_CURRENT_BINARY_DIR}/systemd/dhtcluster.service DESTINATION ${systemdunitdir})
+            install (FILES systemd/dhtcluster.conf DESTINATION ${sysconfdir})
+        endif()
     endif()
 endif ()

tools/systemd/dhtcluster.conf

@@ -1 +1 @@
-DHT_ARGS=-b bootstrap.ring.cx -p 4222 -n 16
+DHT_ARGS=-b bootstrap.jami.net -p 4222 -n 16

tools/tools_common.h

@@ -187,8 +187,8 @@ getDhtConfig(dht_params& params)
             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));
+        context.statusChangedCallback = [logger = context.logger](dht::NodeStatus status4, dht::NodeStatus status6) {
+            logger->w("Connectivity changed: IPv4: %s, IPv6: %s", dht::statusToStr(status4), dht::statusToStr(status6));
         };
     }
     return {std::move(config), std::move(context)};