ci/github: cleanup

Revert "more attempts to find msgpackc-cxx in a universal way"
This reverts commit 965fbb43c7.
2026-11-08 12:28:42 +00:00 · 2023-03-25 18:27:19 -04:00 · 2023-03-25 18:26:47 -04:00
133 changed files with 737 additions and 1144 deletions
@@ -42,7 +42,7 @@ jobs:
    - uses: actions/checkout@v3
    - name: Dependencies
      run: |
-        sudo apt install libncurses5-dev libreadline-dev nettle-dev libfmt-dev \
+        sudo apt install libncurses5-dev libreadline-dev nettle-dev \
        libgnutls28-dev libcppunit-dev libmsgpack-dev libargon2-0-dev
    - name: Configure
      run: |
@@ -57,7 +57,7 @@ jobs:

  build-macos:
    name: macOS/Clang build
-    runs-on: macos-12
+    runs-on: macos-11
    steps:
    - uses: actions/checkout@v3
    - name: Dependencies
@@ -67,9 +67,9 @@ jobs:
    - name: restinio
      run: |
        mkdir restinio && cd restinio
-        wget https://github.com/aberaud/restinio/archive/6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz
-        ls -l && tar -xzf 6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz
-        cd restinio-6fd08b65f6f15899dd0de3c801f6a5462b811c64/dev
+        wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz
+        ls -l && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz
+        cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/dev
        cmake -DCMAKE_INSTALL_PREFIX=/usr/local -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 .
@@ -18,9 +18,9 @@ jobs:
      - name: restinio
        run: |
          mkdir restinio && cd restinio \
-          && wget https://github.com/aberaud/restinio/archive/6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-          && ls -l && tar -xzf 6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-          && cd restinio-6fd08b65f6f15899dd0de3c801f6a5462b811c64/dev \
+          && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+          && ls -l && 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 . \
@@ -213,7 +213,7 @@ jobs:
        uses: docker/build-push-action@v3
        with:
          context: .
-          file: docker/DockerfileDepsAlpine
+          file: docker/DockerfileAlpineDeps
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
@@ -14,8 +14,8 @@ include(FindPkgConfig)
 include(cmake/CheckAtomic.cmake)
 include(CTest)

-set (opendht_VERSION_MAJOR 3)
-set (opendht_VERSION_MINOR 1.4)
+set (opendht_VERSION_MAJOR 2)
+set (opendht_VERSION_MINOR 5.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -23,6 +23,7 @@ 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)
@@ -47,9 +48,7 @@ set (CMAKE_CXX_STANDARD 17)
 set (CMAKE_CXX_STANDARD_REQUIRED on)

 # Dependencies
-if (NOT HAVE_CXX_ATOMICS_WITHOUT_LIB
-        # For ARM EABI (armel), little-endian MIPS (mipsel), etc.
-        OR NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+if (NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
    link_libraries (atomic)
 endif ()

@@ -60,16 +59,7 @@ if (NOT MSVC)
    find_package (PkgConfig REQUIRED)
    pkg_search_module (GnuTLS REQUIRED IMPORTED_TARGET gnutls)
    pkg_search_module (Nettle REQUIRED IMPORTED_TARGET nettle)
-    check_include_file_cxx(msgpack.hpp HAVE_MSGPACKCXX)
-    if (NOT HAVE_MSGPACKCXX)
-        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()
+    find_package (msgpack REQUIRED NAMES msgpackc-cxx msgpack msgpack-cxx)
    if (OPENDHT_TOOLS)
        find_package (Readline 6 REQUIRED)
    endif ()
@@ -89,10 +79,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")
@@ -142,7 +132,6 @@ 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
@@ -157,6 +146,11 @@ 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}")
@@ -175,8 +169,8 @@ include_directories (
 include (GNUInstallDirs)
 set (prefix ${CMAKE_INSTALL_PREFIX})
 set (exec_prefix "\${prefix}")
-set (libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
-set (includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
+set (libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+set (includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
 set (bindir "${CMAKE_INSTALL_FULL_BINDIR}")
 set (sysconfdir "${CMAKE_INSTALL_FULL_SYSCONFDIR}")
 set (top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
@@ -229,7 +223,7 @@ list (APPEND opendht_HEADERS
    include/opendht/rate_limiter.h
    include/opendht/securedht.h
    include/opendht/log.h
-    include/opendht/logger.h
+    include/opendht/log_enable.h
    include/opendht/thread_pool.h
    include/opendht/network_utils.h
    include/opendht.h
@@ -345,36 +339,32 @@ add_library (opendht
    ${obj_libs}
 )
 set_target_properties (opendht PROPERTIES OUTPUT_NAME "opendht")
-
-if (NOT HAVE_MSGPACKCXX)
-    target_link_libraries(opendht PUBLIC ${MSGPACK_TARGET})
+target_link_libraries(opendht
+    PRIVATE
+        PkgConfig::argon2
+        PkgConfig::Nettle
+        ${HTTP_PARSER_LIBRARY}
+    PUBLIC
+        ${CMAKE_THREAD_LIBS_INIT}
+        PkgConfig::GnuTLS
+        msgpackc-cxx
+        ${FMT_LIBRARY}
+)
+if (Jsoncpp_FOUND)
+    target_link_libraries(opendht PUBLIC PkgConfig::Jsoncpp)
+endif()
+if (OPENDHT_PROXY_OPENSSL)
+    target_link_libraries(opendht PUBLIC PkgConfig::OPENSSL)
 endif()
 if (APPLE)
-    target_link_libraries(opendht PRIVATE "-framework CoreFoundation" "-framework Security")
+    target_link_libraries(opendht PRIVATE SYSTEM "-framework CoreFoundation" "-framework Security")
 endif()
 if (MSVC)
    if (OPENDHT_STATIC)
        target_link_libraries(opendht PUBLIC ${Win32_STATIC_LIBRARIES} ${Win32_IMPORT_LIBRARIES})
        set_target_properties (opendht PROPERTIES OUTPUT_NAME "libopendht")
    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()
+endif ()

 if (BUILD_SHARED_LIBS)
    set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
@@ -431,7 +421,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 AND NOT MSVC)
+if (BUILD_TESTING)
    pkg_search_module(Cppunit REQUIRED IMPORTED_TARGET cppunit)
    # unit testing
    list (APPEND test_FILES
@@ -21,11 +21,6 @@ Values are distributed over the network, with redundancy.
 ## Documentation
 See the wiki: <https://github.com/savoirfairelinux/opendht/wiki>

-#### How to run a node
-
-You can help contributing to the public network by running a stable node with a public IP address.
-https://github.com/savoirfairelinux/opendht/wiki/Running-a-node-with-dhtnode
-
 #### How-to build and install

 Build instructions: <https://github.com/savoirfairelinux/opendht/wiki/Build-the-library>
@@ -96,18 +91,17 @@ for r in results:
 - msgpack-c 1.2+, used for data serialization.
 - GnuTLS 3.3+, used for cryptographic operations.
 - Nettle 2.4+, a GnuTLS dependency for crypto.
- {fmt} 9.0+, for log formatting.
 - (optional) restinio used for the REST API.
 - (optional) jsoncpp 1.7.4-3+, used for the REST API.
 - Build tested with GCC 7+ (GNU/Linux, Windows with MinGW), Clang/LLVM (GNU/Linux, Android, macOS, iOS).
- Build tested with Microsoft Visual Studio 2019, 2022
+- Build tested with Microsoft Visual Studio 2017, 2019, 2022

 ## Contact

 IRC: join us on Libera.chat at [`#opendht`](https://web.libera.chat/#opendht).

 ## License
-Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+Copyright (C) 2014-2022 Savoir-faire Linux Inc.

 OpenDHT 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.

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,7 +1,7 @@
 dnl define macros
-m4_define([opendht_major_version], 3)
-m4_define([opendht_minor_version], 1)
-m4_define([opendht_patch_version], 4)
+m4_define([opendht_major_version], 2)
+m4_define([opendht_minor_version], 5)
+m4_define([opendht_patch_version], 0)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])

@@ -34,6 +34,12 @@ 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")
@@ -165,16 +171,15 @@ 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;])
@@ -19,7 +19,7 @@
 .SH DESCRIPTION
 Runs an OpenDHT node, with a CLI (default) or as a daemon (with \fB'-d'\fP or \fB'-s'\fP).
 Commands available in the interactive shell are:
-.EX
+.EE
    h, help    Print this help message.
    q, quit    Quit the program.
    log        Start/stop printing DHT logs.
@@ -39,7 +39,6 @@ Commands available in the interactive shell are:
                          private key.
    e [key] [dest] [str]  Put string value at [key], encrypted for [dest] with
                          its public key (if found).
-.EE
 .SH OPTIONS
 .TP
 \fB\-h\fP
@@ -2,9 +2,8 @@ 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

-COPY . opendht
-
-RUN cd opendht && mkdir build && cd build \
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \
@@ -1,7 +1,27 @@
-FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-alpine:latest AS build
+FROM alpine:3.17 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
@@ -19,7 +39,7 @@ RUN cd opendht && mkdir build && cd build \
 				-DOPENDHT_SYSTEMD=On \
 	&& make -j8 && make install

-FROM alpine:3.18 AS install
+FROM alpine:3.17 AS install
 COPY --from=build /install /
 RUN apk add --no-cache \
        libstdc++ \
@@ -1,4 +1,4 @@
-FROM alpine:3.18
+FROM alpine:3.17
 LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
 LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht

@@ -13,9 +13,9 @@ RUN apk add --no-cache \

 RUN echo "*** Downloading RESTinio ***" \
    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && tar -xzf 6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && cd restinio-6fd08b65f6f15899dd0de3c801f6a5462b811c64/dev \
+    && 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 . \
@@ -2,9 +2,8 @@ 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

-COPY . opendht
-
-RUN cd opendht && mkdir build && cd build \
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \
@@ -18,9 +18,9 @@ RUN apt-get update && apt-get install -y \

 RUN echo "*** Downloading RESTinio ***" \
    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && ls -l && tar -xzf 6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && cd restinio-6fd08b65f6f15899dd0de3c801f6a5462b811c64/dev \
+    && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && ls -l && 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 . \
@@ -22,9 +22,9 @@ ENV CXX c++

 RUN echo "*** Downloading RESTinio ***" \
    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && ls -l && tar -xzf 6fd08b65f6f15899dd0de3c801f6a5462b811c64.tar.gz \
-    && cd restinio-6fd08b65f6f15899dd0de3c801f6a5462b811c64/dev \
+    && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && ls -l && 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 . \
@@ -2,9 +2,8 @@ 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

-COPY . opendht
-
-RUN cd opendht && mkdir build && cd build \
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \
@@ -2,9 +2,8 @@ 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

-COPY . opendht
-
-RUN cd opendht && mkdir build && cd build \
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
 				-DOPENDHT_C=On \
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -170,19 +170,19 @@ using ValueCallback = std::function<bool(const std::vector<std::shared_ptr<Value
 using GetCallbackSimple = std::function<bool(std::shared_ptr<Value> value)>;
 using ShutdownCallback = std::function<void()>;
 using IdentityAnnouncedCb = std::function<void(bool)>;
-using PublicAddressChangedCb = std::function<void(std::vector<SockAddr>)>;

 using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;
-using DoneCallback = std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)>;
-using DoneCallbackSimple = std::function<void(bool success)>;

 typedef bool (*GetCallbackRaw)(std::shared_ptr<Value>, void *user_data);
 typedef bool (*ValueCallbackRaw)(std::shared_ptr<Value>, bool expired, void *user_data);
+
+using DoneCallback = std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)>;
 typedef void (*DoneCallbackRaw)(bool, std::vector<std::shared_ptr<Node>>*, void *user_data);
 typedef void (*ShutdownCallbackRaw)(void *user_data);
 typedef void (*DoneCallbackSimpleRaw)(bool, void *user_data);
 typedef bool (*FilterRaw)(const Value&, void *user_data);

+using DoneCallbackSimple = std::function<void(bool success)>;

 OPENDHT_PUBLIC GetCallbackSimple bindGetCb(GetCallbackRaw raw_cb, void* user_data);
 OPENDHT_PUBLIC GetCallback bindGetCb(GetCallbackSimple cb);
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *
@@ -772,7 +772,6 @@ OPENDHT_PUBLIC Identity generateEcIdentity(const std::string& name, const Identi
 OPENDHT_PUBLIC Identity generateEcIdentity(const std::string& name = "dhtnode", const Identity& ca = {});

 OPENDHT_PUBLIC void saveIdentity(const Identity& id, const std::string& path, const std::string& privkey_password = {});
-OPENDHT_PUBLIC Identity loadIdentity(const std::string &path,const std::string &privkey_password = {});

 /**
 * Performs SHA512, SHA256 or SHA1, depending on hash_length.
@@ -793,7 +792,7 @@ OPENDHT_PUBLIC void hash(const uint8_t* data, size_t data_length, uint8_t* hash,
 * that can be transmitted in clear, and will be generated if
 * not provided (32 bytes).
 */
-OPENDHT_PUBLIC Blob stretchKey(std::string_view password, Blob& salt, size_t key_length = 512/8);
+OPENDHT_PUBLIC Blob stretchKey(const std::string& password, Blob& salt, size_t key_length = 512/8);

 /**
 * AES-GCM encryption. Key must be 128, 192 or 256 bits long (16, 24 or 32 bytes).
@@ -802,55 +801,15 @@ OPENDHT_PUBLIC Blob aesEncrypt(const uint8_t* data, size_t data_length, const Bl
 OPENDHT_PUBLIC inline Blob aesEncrypt(const Blob& data, const Blob& key) {
    return aesEncrypt(data.data(), data.size(), key);
 }
-/**
- * AES-GCM encryption with argon2 key derivation.
- * This function uses `stretchKey` to generate an AES key from the password and a random salt.
- * The result is a bundle including the salt that can be decrypted with `aesDecrypt(data, password)`.
- * If needed, the salt or encrypted data can be individually extracted from the bundle with `aesGetSalt` and `aesGetEncrypted`.
- */
-OPENDHT_PUBLIC Blob aesEncrypt(const Blob& data, std::string_view password);
+OPENDHT_PUBLIC Blob aesEncrypt(const Blob& data, const std::string& password);

 /**
 * AES-GCM decryption.
 */
 OPENDHT_PUBLIC Blob aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key);
 OPENDHT_PUBLIC inline Blob aesDecrypt(const Blob& data, const Blob& key) { return aesDecrypt(data.data(), data.size(), key); }
-OPENDHT_PUBLIC inline Blob aesDecrypt(std::string_view data, const Blob& key) { return aesDecrypt((uint8_t*)data.data(), data.size(), key); }
-
-OPENDHT_PUBLIC Blob aesDecrypt(const uint8_t* data, size_t data_length, std::string_view password);
-OPENDHT_PUBLIC inline Blob aesDecrypt(const Blob& data, std::string_view password) { return aesDecrypt(data.data(), data.size(), password); }
-OPENDHT_PUBLIC inline Blob aesDecrypt(std::string_view data, std::string_view password) { return aesDecrypt((uint8_t*)data.data(), data.size(), password); }
-
-/**
- * Get raw AES key from password and salt stored with the encrypted data.
- */
-OPENDHT_PUBLIC Blob aesGetKey(const uint8_t* data, size_t data_length, std::string_view password);
-OPENDHT_PUBLIC Blob inline aesGetKey(const Blob& data, std::string_view password) {
-    return aesGetKey(data.data(), data.size(), password);
-}
-/** Get the salt part of data password-encrypted with `aesEncrypt(data, password)` */
-OPENDHT_PUBLIC Blob aesGetSalt(const uint8_t* data, size_t data_length);
-OPENDHT_PUBLIC Blob inline aesGetSalt(const Blob& data) {
-    return aesGetSalt(data.data(), data.size());
-}
-/** Get the encrypted data part of data password-encrypted with `aesEncrypt(data, password)` */
-OPENDHT_PUBLIC std::string_view aesGetEncrypted(const uint8_t* data, size_t data_length);
-OPENDHT_PUBLIC std::string_view inline aesGetEncrypted(const Blob& data) {
-    return aesGetEncrypted(data.data(), data.size());
-}
-
-/** Build an encrypted bundle that can be decrypted with aesDecrypt(data, password).
- *  @param encryptedData: result of `aesEncrypt(data, key)` or `aesGetEncrypted`
- *  @param salt: should match the encryption key and password so that `stretchKey(password, salk) == key`.
- *  Can be obtained from an existing bundle with `aesGetSalt`.
- **/
-OPENDHT_PUBLIC Blob aesBuildEncrypted(const uint8_t* encryptedData, size_t data_length, const Blob& salt);
-OPENDHT_PUBLIC Blob inline aesBuildEncrypted(const Blob& encryptedData, const Blob& salt) {
-    return aesBuildEncrypted(encryptedData.data(), encryptedData.size(), salt);
-}
-OPENDHT_PUBLIC Blob inline aesBuildEncrypted(std::string_view encryptedData, const Blob& salt) {
-    return aesBuildEncrypted((const uint8_t*)encryptedData.data(), encryptedData.size(), salt);
-}
+OPENDHT_PUBLIC Blob aesDecrypt(const uint8_t* data, size_t data_length, const std::string& password);
+OPENDHT_PUBLIC inline Blob aesDecrypt(const Blob& data, const std::string& password) { return aesDecrypt(data.data(), data.size(), password); }

 }
 }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -67,15 +67,15 @@ 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();

    /**
     * Get the ID of the node.
     */
    inline const InfoHash& getNodeId() const override { return myid; }
-    void setOnPublicAddressChanged(PublicAddressChangedCb cb) override {
-        publicAddressChangedCb_ = std::move(cb);
-    }

    NodeStatus updateStatus(sa_family_t af) override;

@@ -265,6 +265,7 @@ public:
     */
    void connectivityChanged(sa_family_t) override;
    void connectivityChanged() override {
+        reported_addr.clear();
        connectivityChanged(AF_INET);
        connectivityChanged(AF_INET6);
    }
@@ -383,14 +384,11 @@ private:
    TypeStore types;

    using SearchMap = std::map<InfoHash, Sp<Search>>;
-    using ReportedAddr = std::pair<unsigned, SockAddr>;
-
    struct Kad {
        RoutingTable buckets {};
        SearchMap searches {};
        unsigned pending_pings {0};
        NodeStatus status;
-        std::vector<ReportedAddr> reported_addr;

        NodeStatus getStatus(time_point now) const;
        NodeStats getNodesStats(time_point now, const InfoHash& myid) const;
@@ -398,7 +396,6 @@ private:

    Kad dht4 {};
    Kad dht6 {};
-    PublicAddressChangedCb publicAddressChangedCb_ {};

    std::vector<std::pair<std::string,std::string>> bootstrap_nodes {};
    std::chrono::steady_clock::duration bootstrap_period {BOOTSTRAP_PERIOD};
@@ -426,6 +423,8 @@ private:
    Sp<Scheduler::Job> nextStorageMaintenance {};

    net::NetworkEngine network_engine;
+    using ReportedAddr = std::pair<unsigned, SockAddr>;
+    std::vector<ReportedAddr> reported_addr;

    std::string persistPath;

@@ -568,7 +567,7 @@ private:
     * @param sr  The search for which we want to announce a value.
     * @param announce  The 'announce' structure.
     */
-    void searchSendAnnounceValue(const Sp<Search>& sr, unsigned syncLevel = TARGET_NODES);
+    void searchSendAnnounceValue(const Sp<Search>& sr);

    /**
     * Main process of a Search's operations. This function will demand the
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -19,7 +19,7 @@
 #pragma once

 #include "infohash.h"
-#include "logger.h"
+#include "log_enable.h"
 #include "node_export.h"

 #include <queue>
@@ -33,8 +33,8 @@ namespace net {
 class OPENDHT_PUBLIC DhtInterface {
 public:
    DhtInterface() = default;
-    DhtInterface(const Logger& l) : logger_(std::make_shared<Logger>(l)) {}
-    DhtInterface(const std::shared_ptr<Logger>& l) : logger_(l) {}
+    DhtInterface(const Logger& l) : logger_(std::make_shared<Logger>(l)) {};
+    DhtInterface(const std::shared_ptr<Logger>& l) : logger_(l) {};
    virtual ~DhtInterface() = default;

    // [[deprecated]]
@@ -45,16 +45,15 @@ public:
    /**
     * Get the current status of the node for the given family.
     */
-    virtual NodeStatus updateStatus(sa_family_t af) { return getStatus(af); }
+    virtual NodeStatus updateStatus(sa_family_t af) { return getStatus(af); };
    virtual NodeStatus getStatus(sa_family_t af) const = 0;
    virtual NodeStatus getStatus() const = 0;

    void addOnConnectedCallback(std::function<void()> cb) {
        onConnectCallbacks_.emplace(std::move(cb));
    }
-    virtual void setOnPublicAddressChanged(PublicAddressChangedCb) {}

-    virtual net::DatagramSocket* getSocket() const { return {}; }
+    virtual net::DatagramSocket* getSocket() const { return {}; };

    /**
     * Get the ID of the DHT node.
@@ -233,6 +232,18 @@ 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;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *          Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *          Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
@@ -89,9 +89,6 @@ public:
     * Get the ID of the node.
     */
    inline const InfoHash& getNodeId() const override { return myid; }
-    void setOnPublicAddressChanged(PublicAddressChangedCb cb) override {
-        publicAddressChangedCb_ = std::move(cb);
-    }

    /**
     * Get the current status of the node for the given family.
@@ -360,7 +357,6 @@ private:
    SockAddr publicAddressV4_;
    SockAddr publicAddressV6_;
    std::atomic_bool launchConnectedCbs_ {false};
-    PublicAddressChangedCb publicAddressChangedCb_ {};

    InfoHash myid {};

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *          Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *          Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
@@ -87,7 +87,7 @@ public:
     */
    DhtProxyServer(const std::shared_ptr<DhtRunner>& dht,
        const ProxyServerConfig& config = {},
-        const std::shared_ptr<log::Logger>& logger = {});
+        const std::shared_ptr<dht::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<log::Logger> logger_;
+    std::shared_ptr<dht::Logger> logger_;

    std::shared_ptr<ServerStats> stats_;
    std::shared_ptr<NodeInfo> nodeInfo_ {};
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -25,7 +25,7 @@
 #include "value.h"
 #include "callbacks.h"
 #include "sockaddr.h"
-#include "logger.h"
+#include "log_enable.h"
 #include "network_utils.h"
 #include "node_export.h"

@@ -78,7 +78,6 @@ public:
        StatusCallback statusChangedCallback {};
        CertificateStoreQuery certificateStore {};
        IdentityAnnouncedCb identityAnnouncedCb {};
-        PublicAddressChangedCb publicAddressChangedCb {};
        Context() {}
    };

@@ -350,6 +349,7 @@ 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).
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -53,9 +53,7 @@ class tls_socket_t;
 }

 namespace dht {
-namespace log {
 struct Logger;
-}

 namespace crypto {
 struct Certificate;
@@ -90,9 +88,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<log::Logger> l = {});
+    Connection(asio::io_context& ctx, const bool ssl = true, std::shared_ptr<dht::Logger> l = {});
    Connection(asio::io_context& ctx, std::shared_ptr<dht::crypto::Certificate> server_ca,
-               const dht::crypto::Identity& identity, std::shared_ptr<log::Logger> l = {});
+               const dht::crypto::Identity& identity, std::shared_ptr<dht::Logger> l = {});
    ~Connection();

    inline unsigned int id() const { return  id_; };
@@ -150,7 +148,7 @@ private:
    asio::ip::address local_address_;

    std::unique_ptr<asio::steady_timer> timeout_timer_;
-    std::shared_ptr<log::Logger> logger_;
+    std::shared_ptr<dht::Logger> logger_;
    bool checkOcsp_ {false};
 };

@@ -174,15 +172,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<log::Logger> logger = {});
+    Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
    Resolver(asio::io_context& ctx, const std::string& host, const std::string& service,
-             const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
+             const bool ssl = false, std::shared_ptr<dht::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<log::Logger> logger = {});
+             const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
    Resolver(asio::io_context& ctx, const std::string& url, std::vector<asio::ip::tcp::endpoint> endpoints,
-            std::shared_ptr<log::Logger> logger = {});
+            std::shared_ptr<dht::Logger> logger = {});

    ~Resolver();

@@ -192,7 +190,7 @@ public:

    void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC);

-    std::shared_ptr<log::Logger> getLogger() const {
+    std::shared_ptr<Logger> getLogger() const {
        return logger_;
    }

@@ -210,7 +208,7 @@ private:
    bool completed_ {false};
    std::queue<ResolverCb> cbs_;

-    std::shared_ptr<log::Logger> logger_;
+    std::shared_ptr<dht::Logger> logger_;
 };

 class Request;
@@ -242,14 +240,14 @@ public:

    // resolves implicitly
    Request(asio::io_context& ctx, const std::string& url, const Json::Value& json, OnJsonCb jsoncb,
-            std::shared_ptr<log::Logger> logger = {});
+            std::shared_ptr<dht::Logger> logger = {});
    Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb,
-            std::shared_ptr<log::Logger> logger = {});
+            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& url, std::shared_ptr<dht::Logger> logger = {});
    Request(asio::io_context& ctx, const std::string& host, const std::string& service,
-            const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
-    Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});
+            const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
+    Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger = {});

    // user defined resolver
    Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, sa_family_t family = AF_UNSPEC);
@@ -257,7 +255,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<log::Logger> logger = {});
+            const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});

    ~Request();

@@ -284,7 +282,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<log::Logger> logger);
+    void set_logger(std::shared_ptr<dht::Logger> logger);

    /**
     * Define the HTTP header/body as per https://tools.ietf.org/html/rfc7230.
@@ -330,8 +328,6 @@ private:

    void build();

-    static std::string url_encode(std::string_view value);
-
    void init_default_headers();
    /**
     * Initialized and wraps the http_parser callbacks with our user defined callbacks.
@@ -351,7 +347,7 @@ private:

    mutable std::mutex mutex_;

-    std::shared_ptr<log::Logger> logger_;
+    std::shared_ptr<dht::Logger> logger_;

    restinio::http_request_header_t header_;
    std::map<restinio::http_field_t, std::string> headers_;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *              Nicolas Reynaud <nicolas.reynaud@savoirfairelinux.com>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -22,7 +22,6 @@
 #include "rng.h"

 #include <msgpack.hpp>
-#include <fmt/core.h>

 #ifndef _WIN32
 #include <netinet/in.h>
@@ -230,11 +229,6 @@ 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.
     */
@@ -395,10 +389,3 @@ 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);
-  }
-};
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -20,7 +20,7 @@
 #pragma once

 #include "def.h"
-#include "logger.h"
+#include "log_enable.h"

 #include <iostream>
 #include <memory>
@@ -34,6 +34,42 @@ 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();

@@ -0,0 +1,191 @@
+/*
+ *  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_ {};
+};
+
+}
@@ -1,118 +0,0 @@
-/*
- *  Copyright (C) 2014-2023 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 OPENDHT_PUBLIC 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:
-    LogMethod logger = {};
-    bool filterEnable_ {false};
-    InfoHash filter_ {};
-};
-
-}
-using Logger = log::Logger;
-}
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -27,7 +27,7 @@
 #include "utils.h"
 #include "rng.h"
 #include "rate_limiter.h"
-#include "logger.h"
+#include "log_enable.h"
 #include "network_utils.h"

 #include <vector>
@@ -501,6 +501,8 @@ private:
    static constexpr size_t MAX_PACKET_VALUE_SIZE {600};
    static constexpr size_t MAX_MESSAGE_VALUE_SIZE {56 * 1024};

+    static const std::string my_v;
+
    void process(std::unique_ptr<ParsedMessage>&&, const SockAddr& from);

    bool rateLimit(const SockAddr& addr);
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -21,7 +21,7 @@

 #include "sockaddr.h"
 #include "utils.h"
-#include "logger.h"
+#include "log_enable.h"

 #ifdef _WIN32
 #include <ws2tcpip.h>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -139,7 +139,7 @@ struct Node {
     */
    Tid getNewTid() {
        ++transaction_id;
-        return transaction_id ? transaction_id : ++transaction_id;
+        return transaction_id ? ++transaction_id : transaction_id;
    }

    std::string toString() const;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Mingrui Zhang <mingrui.zhang@savoirfairelinux.com>
 *              Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *
@@ -22,7 +22,7 @@
 #include "def.h"
 #include "sockaddr.h"
 #include "infohash.h"
-#include "logger.h"
+#include "log_enable.h"

 #include <thread>

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -149,9 +149,6 @@ public:
    void setLocalCertificateStore(CertificateStoreQuery&& query_method) {
        localQueryMethod_ = std::move(query_method);
    }
-    void setOnPublicAddressChanged(PublicAddressChangedCb cb) override {
-        dht_->setOnPublicAddressChanged(cb);
-    }

    /**
     * SecureDht to Dht proxy
@@ -381,7 +378,7 @@ const ValueType CERTIFICATE_TYPE = {
        try {
            crypto::Certificate crt(v->data);
            // TODO check certificate signature
-            return crt.getPublicKey().getId() == id || InfoHash::get(crt.getPublicKey().getLongId()) == id;
+            return crt.getPublicKey().getId() == id;
        } catch (const std::exception& e) {}
        return false;
    },
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -20,10 +20,6 @@

 #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>
@@ -52,7 +48,6 @@ 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);

@@ -294,11 +289,6 @@ 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 {};
@@ -319,7 +309,3 @@ private:
 OPENDHT_PUBLIC bool operator==(const SockAddr& a, const SockAddr& b);

 }
-
-#if FMT_VERSION >= 90000
-template <> struct fmt::formatter<dht::SockAddr> : ostream_formatter {};
-#endif
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -37,7 +37,7 @@ public:
    static ThreadPool& io();

    ThreadPool();
-    ThreadPool(unsigned minThreads, unsigned maxThreads = 0);
+    ThreadPool(size_t maxThreads);
    ~ThreadPool();

    void run(std::function<void()>&& cb);
@@ -61,7 +61,7 @@ public:
        return get(std::move(cb));
    }

-    void stop(bool wait = true);
+    void stop();
    void join();

 private:
@@ -72,12 +72,7 @@ private:
    unsigned readyThreads_ {0};
    bool running_ {true};

-    unsigned minThreads_;
    const unsigned maxThreads_;
-    std::chrono::steady_clock::duration threadExpirationDelay {std::chrono::minutes(5)};
-    double threadDelayRatio_ {2};
-
-    void threadEnded(std::thread&);
 };

 class OPENDHT_PUBLIC Executor : public std::enable_shared_from_this<Executor> {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 project('opendht', 'c', 'cpp',
-    version: '3.1.4',
+    version: '2.5.0',
    default_options: [
        'cpp_std=c++17',
        'warning_level=3'
@@ -11,7 +11,6 @@ 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'
@@ -20,7 +19,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 = [fmt, gnutls, nettle, msgpack, argon2, openssl, jsoncpp, http_parser]
+deps = [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')
@@ -78,17 +77,7 @@ if get_option('tools').enabled()
    dhtnode = executable('dhtnode', 'tools/dhtnode.cpp',
        include_directories : opendht_interface_inc,
        link_with : opendht,
-        dependencies : [readline, msgpack, fmt],
-        install : true)
-    dhtchat = executable('dhtchat', 'tools/dhtchat.cpp',
-        include_directories : opendht_interface_inc,
-        link_with : opendht,
-        dependencies : [readline, msgpack, fmt],
-        install : true)
-    dhtscanner = executable('dhtscanner', 'tools/dhtscanner.cpp',
-        include_directories : opendht_interface_inc,
-        link_with : opendht,
-        dependencies : [readline, msgpack, fmt],
+        dependencies : [readline, msgpack],
        install : true)
    if http_parser.found()
        durl = executable('durl', 'tools/durl.cpp',
@@ -5,7 +5,7 @@
 # distutils: libraries = opendht gnutls
 # cython: language_level=3
 #
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-2022 Savoir-faire Linux Inc.
 # Author(s): Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
 #            Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
@@ -42,7 +42,7 @@ cimport opendht_cpp as cpp

 import threading

-cdef inline void lookup_callback(cpp.vector[cpp.shared_ptr[cpp.IndexValue]]* values, cpp.Prefix* p, void *user_data) noexcept with gil:
+cdef inline void lookup_callback(cpp.vector[cpp.shared_ptr[cpp.IndexValue]]* values, cpp.Prefix* p, void *user_data) with gil:
    cbs = <object>user_data
    if 'lookup' in cbs and cbs['lookup']:
        vals = []
@@ -52,13 +52,13 @@ cdef inline void lookup_callback(cpp.vector[cpp.shared_ptr[cpp.IndexValue]]* val
            vals.append(v)
        cbs['lookup'](vals, p.toString())

-cdef inline void shutdown_callback(void* user_data) noexcept with gil:
+cdef inline void shutdown_callback(void* user_data) with gil:
    cbs = <object>user_data
    if 'shutdown' in cbs and cbs['shutdown']:
        cbs['shutdown']()
    ref.Py_DECREF(cbs)

-cdef inline bool get_callback(shared_ptr[cpp.Value] value, void *user_data) noexcept with gil:
+cdef inline bool get_callback(shared_ptr[cpp.Value] value, void *user_data) with gil:
    cbs = <object>user_data
    cb = cbs['get']
    f = cbs['filter'] if 'filter' in cbs else None
@@ -66,7 +66,7 @@ cdef inline bool get_callback(shared_ptr[cpp.Value] value, void *user_data) noex
    pv._value = value
    return cb(pv) if not f or f(pv) else True

-cdef inline bool value_callback(shared_ptr[cpp.Value] value, bool expired, void *user_data) noexcept with gil:
+cdef inline bool value_callback(shared_ptr[cpp.Value] value, bool expired, void *user_data) with gil:
    cbs = <object>user_data
    cb = cbs['valcb']
    f = cbs['filter'] if 'filter' in cbs else None
@@ -74,7 +74,7 @@ cdef inline bool value_callback(shared_ptr[cpp.Value] value, bool expired, void
    pv._value = value
    return cb(pv, expired) if not f or f(pv) else True

-cdef inline void done_callback(bool done, cpp.vector[shared_ptr[cpp.Node]]* nodes, void *user_data) noexcept with gil:
+cdef inline void done_callback(bool done, cpp.vector[shared_ptr[cpp.Node]]* nodes, void *user_data) with gil:
    node_ids = []
    for n in deref(nodes):
        h = NodeEntry()
@@ -86,7 +86,7 @@ cdef inline void done_callback(bool done, cpp.vector[shared_ptr[cpp.Node]]* node
        cbs['done'](done, node_ids)
    ref.Py_DECREF(cbs)

-cdef inline void done_callback_simple(bool done, void *user_data) noexcept with gil:
+cdef inline void done_callback_simple(bool done, void *user_data) with gil:
    cbs = <object>user_data
    if 'done' in cbs and cbs['done']:
        cbs['done'](done)
@@ -158,15 +158,6 @@ cdef class SockAddr(object):
        return self.toString().decode()
    def __repr__(self):
        return "<%s '%s'>" % (self.__class__.__name__, str(self))
-    @staticmethod
-    def resolve(str host, str service=None):
-        vals = []
-        result = cpp.SockAddr.resolve(host.encode(), service.encode() if service else b'')
-        for val in result:
-            a = SockAddr()
-            a._addr = val
-            vals.append(a)
-        return vals

 cdef class Node(_WithID):
    cdef shared_ptr[cpp.Node] _node
@@ -462,31 +453,11 @@ cdef class Identity(object):
            k._key = self._id.first
            return k

-def aesEncrypt(bytes data, str password) -> bytes :
-    cdef size_t d_len = len(data)
-    cdef cpp.uint8_t* d_ptr = <cpp.uint8_t*>data
-    cdef cpp.Blob indat
-    indat.assign(d_ptr, <cpp.uint8_t*>(d_ptr + d_len))
-    cdef cpp.Blob encrypted = cpp.aesEncrypt(indat, password.encode())
-    cdef char* encrypted_c_str = <char *>encrypted.data()
-    cdef Py_ssize_t length = encrypted.size()
-    return encrypted_c_str[:length]
-
-def aesDecrypt(bytes data, str password) -> bytes :
-    cdef size_t d_len = len(data)
-    cdef cpp.uint8_t* d_ptr = <cpp.uint8_t*>data
-    cdef cpp.Blob indat
-    indat.assign(d_ptr, <cpp.uint8_t*>(d_ptr + d_len))
-    cdef cpp.Blob decrypted = cpp.aesDecrypt(indat, password.encode())
-    cdef char* decrypted_c_str = <char *>decrypted.data()
-    cdef Py_ssize_t length = decrypted.size()
-    return decrypted_c_str[:length]
-
 cdef class DhtConfig(object):
    cdef cpp.DhtRunnerConfig _config
    def __init__(self):
        self._config = cpp.DhtRunnerConfig()
-        self._config.threaded = True
+        self._config.threaded = True;
    def setIdentity(self, Identity id):
        self._config.dht_config.id = id._id
    def setBootstrapMode(self, bool bootstrap):
@@ -500,19 +471,6 @@ cdef class DhtConfig(object):
    def setRateLimit(self, ssize_t max_req_per_sec, ssize_t max_peer_req_per_sec):
        self._config.dht_config.node_config.max_req_per_sec = max_req_per_sec
        self._config.dht_config.node_config.max_peer_req_per_sec = max_peer_req_per_sec
-    def setProxyInfo(self, str proxy_server, str push_node_id="", str push_token="", str push_topic="", str push_platform="", Certificate server_ca = Certificate()):
-        self._config.proxy_server = proxy_server.encode()
-        self._config.push_node_id = push_node_id.encode()
-        self._config.push_token = push_token.encode()
-        self._config.push_topic = push_topic.encode()
-        self._config.push_platform = push_platform.encode()
-        self._config.server_ca = server_ca._cert
-    def setPeerDiscovery(self, bool peer_discovery, bool peer_publish):
-        self._config.peer_discovery = peer_discovery
-        self._config.peer_publish = peer_publish
-    def setBound(self, SockAddr bind4, SockAddr bind6):
-        self._config.bind4 = bind4._addr
-        self._config.bind6 = bind6._addr

 cdef class DhtRunner(_WithID):
    cdef cpp.shared_ptr[cpp.DhtRunner] thisptr
@@ -629,8 +587,7 @@ cdef class DhtRunner(_WithID):
                while pending > 0:
                    lock.wait()
            return res
-
-    def put(self, InfoHash key, Value val, done_cb=None, permanent=False):
+    def put(self, InfoHash key, Value val, done_cb=None):
        """Publish a new value on the DHT at key.

        key     -- the DHT key where to put the value
@@ -640,7 +597,7 @@ cdef class DhtRunner(_WithID):
        if done_cb:
            cb_obj = {'done':done_cb}
            ref.Py_INCREF(cb_obj)
-            self.thisptr.get().put(key._infohash, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj), cpp.time_point.max(), permanent)
+            self.thisptr.get().put(key._infohash, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj))
        else:
            lock = threading.Condition()
            pending = 0
@@ -657,76 +614,6 @@ cdef class DhtRunner(_WithID):
                while pending > 0:
                    lock.wait()
            return ok
-
-    def putSigned(self, InfoHash key, Value val, done_cb=None, permanent=False):
-        if done_cb:
-            cb_obj = {'done':done_cb}
-            ref.Py_INCREF(cb_obj)
-            self.thisptr.get().putSigned(key._infohash, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent)
-        else:
-            lock = threading.Condition()
-            pending = 0
-            ok = False
-            def tmp_done(ok_ret, nodes):
-                nonlocal pending, ok, lock
-                with lock:
-                    ok = ok_ret
-                    pending -= 1
-                    lock.notify()
-            with lock:
-                pending += 1
-                self.putSigned(key, val, done_cb=tmp_done)
-                while pending > 0:
-                    lock.wait()
-            return ok
-
-    def putEncrypted(self, InfoHash key, InfoHash to, Value val, done_cb=None, bool permanent=False):
-        if done_cb:
-            cb_obj = {'done':done_cb}
-            ref.Py_INCREF(cb_obj)
-            self.thisptr.get().putEncrypted(key._infohash, to._infohash, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent)
-        else:
-            lock = threading.Condition()
-            pending = 0
-            ok = False
-            def tmp_done(ok_ret, nodes):
-                nonlocal pending, ok, lock
-                with lock:
-                    ok = ok_ret
-                    pending -= 1
-                    lock.notify()
-            with lock:
-                pending += 1
-                self.putEncrypted(key, to, val, done_cb=tmp_done, permanent=permanent)
-                while pending > 0:
-                    lock.wait()
-            return ok
-
-    def putEncrypted(self, InfoHash key, PublicKey to, Value val, done_cb=None, bool permanent=False):
-        if done_cb:
-            cb_obj = {'done':done_cb}
-            ref.Py_INCREF(cb_obj)
-            self.thisptr.get().putEncrypted(key._infohash, to._key, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj), permanent)
-        else:
-            lock = threading.Condition()
-            pending = 0
-            ok = False
-            def tmp_done(ok_ret, nodes):
-                nonlocal pending, ok, lock
-                with lock:
-                    ok = ok_ret
-                    pending -= 1
-                    lock.notify()
-            with lock:
-                pending += 1
-                self.putEncrypted(key, to, val, done_cb=tmp_done, permanent=permanent)
-                while pending > 0:
-                    lock.wait()
-            return ok
-
-    def cancelPut(self, InfoHash key, Value val):
-        self.thisptr.get().cancelPut(key._infohash, val._value)
-
    def listen(self, InfoHash key, value_cb):
        t = ListenToken()
        t._h = key._infohash
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-2022 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
 #
@@ -21,13 +21,12 @@ from libcpp.string cimport string
 from libcpp.vector cimport vector
 from libcpp.utility cimport pair
 from libcpp.map cimport map
-from libcpp.memory cimport shared_ptr, make_shared
 from libc.string cimport const_char, const_uchar

 ctypedef uint16_t in_port_t
 ctypedef unsigned short int sa_family_t;

-cdef extern from "<chrono>" namespace "std::chrono" nogil:
+cdef extern from "<iostream>" namespace "std::chrono" nogil:
    cdef cppclass duration[ulong]:
        duration() except +

@@ -35,6 +34,16 @@ cdef extern from "<chrono>" namespace "std::chrono" nogil:
        duration seconds(uint64_t) except +
        duration seconds()

+cdef extern from "<memory>" namespace "std" nogil:
+    cdef cppclass shared_ptr[T]:
+        shared_ptr() except +
+        shared_ptr(T*) except +
+        T* get()
+        T operator*()
+        bool operator bool() const
+        void reset(T*)
+    shared_ptr[T] make_shared[T](...) except +
+
 cdef extern from "<functional>" namespace "std" nogil:
    cdef cppclass hash[T]:
        hash() except +
@@ -50,13 +59,6 @@ cdef extern from "<future>" namespace "std" nogil:
        bool valid() const
        shared_future[T] share()

-cdef extern from "opendht/utils.h" namespace "dht":
-    cdef cppclass time_point:
-        @staticmethod
-        time_point min() const
-        @staticmethod
-        time_point max() const
-
 cdef extern from "opendht/infohash.h" namespace "dht":
    cdef cppclass InfoHash:
        InfoHash() except +
@@ -86,16 +88,12 @@ cdef extern from "opendht/sockaddr.h" namespace "dht":
        bool isLoopback() const
        bool isPrivate() const
        bool isUnspecified() const
-        @staticmethod
-        vector[SockAddr] resolve(string host, string service) except +

 ctypedef vector[uint8_t] Blob

 cdef extern from "opendht/crypto.h" namespace "dht::crypto":
    ctypedef pair[shared_ptr[PrivateKey], shared_ptr[Certificate]] Identity
    cdef Identity generateIdentity(string name, Identity ca, unsigned bits)
-    cdef Blob aesEncrypt(Blob data, string password) except +
-    cdef Blob aesDecrypt(Blob encrypted, string password) except +

    cdef cppclass PrivateKey:
        PrivateKey()
@@ -241,18 +239,6 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
        cppclass Config:
            SecureDhtConfig dht_config
            bool threaded
-            string proxy_server
-            string push_node_id
-            string push_token
-            string push_topic
-            string push_platform
-            bool peer_discovery
-            bool peer_publish
-            shared_ptr[Certificate] server_ca
-            Identity client_identity
-            SockAddr bind4
-            SockAddr bind6
-
        InfoHash getId() const
        InfoHash getNodeId() const
        void bootstrap(const_char*, const_char*)
@@ -268,11 +254,7 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
        string getRoutingTablesLog(sa_family_t af) const
        string getSearchesLog(sa_family_t af) const
        void get(InfoHash key, GetCallback get_cb, DoneCallback done_cb, nullptr_t f, Where w)
-        void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, time_point created, bool permanent)
-        void putSigned(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, bool permanent) 
-        void putEncrypted(InfoHash key, InfoHash to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
-        void putEncrypted(InfoHash key, shared_ptr[PublicKey] to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
-        void cancelPut(InfoHash key, shared_ptr[Value] val)
+        void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb)
        ListenToken listen(InfoHash key, ValueCallback get_cb)
        void cancelListen(InfoHash key, SharedListenToken token)
        vector[unsigned] getNodeMessageStats(bool i)
@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+# Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 # Author: Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
 # Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #
@@ -32,14 +32,17 @@ setup(name="opendht",
      author="Adrien Béraud, Guillaume Roguez, Simon Désaulniers",
      license="GPLv3",
      classifiers=[
-          'Development Status :: 5 - Production/Stable',
+          'Development Status :: 3 - Alpha',
          'Intended Audience :: Developers',
          'Topic :: Software Development :: Libraries :: Python Modules',
          'Topic :: System :: Distributed Computing',
          'Topic :: System :: Networking'
          'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
          'Programming Language :: Python :: 3',
-          'Programming Language :: Python :: 3.7',
+          'Programming Language :: Python :: 3.2',
+          'Programming Language :: Python :: 3.3',
+          'Programming Language :: Python :: 3.4',
+          'Programming Language :: Python :: 3.5',
      ],
      cmdclass = { 'build_ext' : build_ext },
      ext_modules = cythonize(Extension(
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+# Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
 #
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-2022 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
 #
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2015-2023 Savoir-Faire Linux Inc.
+# Copyright (C) 2015-2022 Savoir-Faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-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
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+# Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2016-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2016-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
@@ -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.jami.net:4222")
+    parser.add_argument('-b', '--bootstrap', help='bootstrap address', default="bootstrap.ring.cx:4222")
    args = parser.parse_args()
    endpoints.serverFromString(reactor, "tcp:"+str(args.http_port)).listen(server.Site(DhtServer(args.port, args.bootstrap)))
    reactor.run()
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-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
@@ -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.jami.net')
+parser.add_argument('-b', '--bootstrap', help='bootstrap address', default='bootstrap.ring.cx')
 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)
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-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
@@ -25,7 +25,8 @@ config.setRateLimit(-1, -1)
 ping_node = dht.DhtRunner()
 ping_node.run(config=config)
 #ping_node.enableLogging()
-#ping_node.bootstrap("bootstrap.jami.net", "4222")
+#ping_node.bootstrap("bootstrap.ring.cx", "4222")
+
 pong_node = dht.DhtRunner()
 pong_node.run(config=config)
 #pong_node.enableLogging()
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2023 Savoir-faire Linux Inc.
+# Copyright (c) 2015-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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -39,7 +39,6 @@ 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 \
@@ -54,7 +53,7 @@ nobase_include_HEADERS = \
        ../include/opendht/dhtrunner.h \
        ../include/opendht/default_types.h \
        ../include/opendht/log.h \
-        ../include/opendht/logger.h \
+        ../include/opendht/log_enable.h \
        ../include/opendht/network_utils.h \
        ../include/opendht/rng.h \
        ../include/opendht/thread_pool.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -18,7 +18,7 @@

 #include "os_cert.h"

-#include "logger.h"
+#include "log_enable.h"

 #ifdef _WIN32
 #include <windows.h>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -18,7 +18,7 @@

 #pragma once

-#include "logger.h"
+#include "log_enable.h"

 #include <memory>

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *
@@ -103,11 +103,13 @@ Blob aesEncrypt(const uint8_t* data, size_t data_length, const Blob& key)
    return ret;
 }

-Blob aesEncrypt(const Blob& data, std::string_view password)
+Blob aesEncrypt(const Blob& data, const std::string& password)
 {
    Blob salt;
    Blob key = stretchKey(password, salt, 256 / 8);
-    return aesBuildEncrypted(aesEncrypt(data, key), salt);
+    Blob encrypted = aesEncrypt(data, key);
+    encrypted.insert(encrypted.begin(), salt.begin(), salt.end());
+    return encrypted;
 }

 Blob aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key)
@@ -150,44 +152,16 @@ Blob aesDecrypt(const uint8_t* data, size_t data_length, const Blob& key)
    return ret;
 }

-Blob aesDecrypt(const uint8_t* data, size_t data_length, std::string_view password)
+Blob aesDecrypt(const uint8_t* data, size_t data_len, const std::string& password)
 {
-    return aesDecrypt(
-        aesGetEncrypted(data, data_length),
-        aesGetKey(data, data_length, password)
-    );
-}
-
-Blob aesGetSalt(const uint8_t* data, size_t data_length)
-{
-    if (data_length <= PASSWORD_SALT_LENGTH)
+    if (data_len <= PASSWORD_SALT_LENGTH)
        throw DecryptError("Wrong data size");
-    return Blob {data, data+PASSWORD_SALT_LENGTH};
+    Blob salt {data, data+PASSWORD_SALT_LENGTH};
+    Blob key = stretchKey(password, salt, 256/8);
+    return aesDecrypt(data+PASSWORD_SALT_LENGTH, data_len - PASSWORD_SALT_LENGTH, key);
 }

-std::string_view aesGetEncrypted(const uint8_t* data, size_t data_length)
-{
-    if (data_length <= PASSWORD_SALT_LENGTH)
-        throw DecryptError("Wrong data size");
-    return std::string_view((const char*)(data+PASSWORD_SALT_LENGTH), data_length - PASSWORD_SALT_LENGTH);
-}
-
-Blob aesBuildEncrypted(const uint8_t* data, size_t data_length, const Blob& salt)
-{
-    Blob ret;
-    ret.reserve(data_length + salt.size());
-    ret.insert(ret.end(), salt.begin(), salt.end());
-    ret.insert(ret.end(), data, data + data_length);
-    return ret;
-}
-
-Blob aesGetKey(const uint8_t* data, size_t data_length, std::string_view password)
-{
-    Blob salt = aesGetSalt(data, data_length);
-    return stretchKey(password, salt, 256/8);
-}
-
-Blob stretchKey(std::string_view password, Blob& salt, size_t key_length)
+Blob stretchKey(const std::string& password, Blob& salt, size_t key_length)
 {
    if (salt.empty()) {
        salt.resize(PASSWORD_SALT_LENGTH);
@@ -1158,26 +1132,6 @@ saveIdentity(const Identity& id, const std::string& path, const std::string& pri
    }
 }

-Identity 
-loadIdentity(const std::string &path,const std::string &privkey_password)
-{
-    std::ifstream pkStream(path + ".pem", std::ios::in | std::ios::binary);
-    std::vector<uint8_t> pkContent((std::istreambuf_iterator<char>(pkStream)),
-                                    std::istreambuf_iterator<char>());
-    auto key = std::make_shared<PrivateKey>(pkContent, privkey_password);
-    pkStream.close();
-    // Create a certificate
-    gnutls_x509_crt_t gnuCert;
-    if (gnutls_x509_crt_init(&gnuCert) != GNUTLS_E_SUCCESS)
-        throw std::runtime_error("Failed to initialize gnutls certificate struct");
-    gnutls_datum_t crtContent;
-    // Read the certificate file
-    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)};
-}
-
 void
 setValidityPeriod(gnutls_x509_crt_t cert, int64_t validity)
 {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -154,18 +154,10 @@ Dht::sendCachedPing(Bucket& b)
 std::vector<SockAddr>
 Dht::getPublicAddress(sa_family_t family)
 {
+    std::sort(reported_addr.begin(), reported_addr.end(), [](const ReportedAddr& a, const ReportedAddr& b) {
+        return a.first > b.first;
+    });
    std::vector<SockAddr> ret;
-    if (family == AF_UNSPEC) {
-        auto& d4 = dht(AF_INET).reported_addr;
-        auto& d6 = dht(AF_INET6).reported_addr;
-        ret.reserve(d4.size() + d6.size());
-        for (const auto& a : d4)
-            ret.emplace_back(a.second);
-        for (const auto& a : d6)
-            ret.emplace_back(a.second);
-        return ret;
-    }
-    auto& reported_addr = dht(family).reported_addr;
    ret.reserve(!family ? reported_addr.size() : reported_addr.size()/2);
    for (const auto& addr : reported_addr)
        if (!family || family == addr.second.getFamily())
@@ -208,8 +200,6 @@ Dht::trySearchInsert(const Sp<Node>& node)
 void
 Dht::reportedAddr(const SockAddr& addr)
 {
-    auto& reported_addr = dht(addr.getFamily()).reported_addr;
-    auto firstBefore = reported_addr.empty() ? nullptr : reported_addr.begin()->second.get();
    auto it = std::find_if(reported_addr.begin(), reported_addr.end(), [&](const ReportedAddr& a){
        return a.second == addr;
    });
@@ -218,21 +208,6 @@ Dht::reportedAddr(const SockAddr& addr)
            reported_addr.emplace_back(1, addr);
    } else
        it->first++;
-    std::sort(reported_addr.begin(), reported_addr.end(), [](const ReportedAddr& a, const ReportedAddr& b) {
-        return a.first > b.first;
-    });
-    if (publicAddressChangedCb_) {
-        auto firstAfter = reported_addr.begin()->second.get();
-        if (firstBefore != firstAfter) {
-            auto& otherDht = dht(addr.getFamily() == AF_INET ? AF_INET6 : AF_INET).reported_addr;
-            std::vector<SockAddr> v;
-            v.reserve(otherDht.empty() ? 1 : 2);
-            v.emplace_back(reported_addr.begin()->second);
-            if (not otherDht.empty())
-                v.emplace_back(otherDht.begin()->second);
-            publicAddressChangedCb_(std::move(v));
-        }
-    }
 }

 /* We just learnt about a node, not necessarily a new one.  Confirm is 1 if
@@ -462,9 +437,10 @@ Dht::searchSendGetValues(Sp<Search> sr, SearchNode* pn, bool update)
    return nullptr;
 }

-void Dht::searchSendAnnounceValue(const Sp<Search>& sr, unsigned syncLevel) {
+void Dht::searchSendAnnounceValue(const Sp<Search>& sr) {
    if (sr->announce.empty())
        return;
+    unsigned i = 0;
    std::weak_ptr<Search> ws = sr;

    auto onDone = [this,ws](const net::Request& req, net::RequestAnswer&& answer)
@@ -576,7 +552,6 @@ void Dht::searchSendAnnounceValue(const Sp<Search>& sr, unsigned syncLevel) {
    static const auto PROBE_QUERY = std::make_shared<Query>(Select {}.field(Value::Field::Id).field(Value::Field::SeqNum));

    const auto& now = scheduler.time();
-    unsigned i = 0;
    for (auto& np : sr->nodes) {
        auto& n = *np;
        if (not n.isSynced(now))
@@ -617,7 +592,7 @@ void Dht::searchSendAnnounceValue(const Sp<Search>& sr, unsigned syncLevel) {
                    std::bind(&Dht::searchNodeGetExpired, this, _1, _2, ws, PROBE_QUERY));
            n.getStatus[PROBE_QUERY] = std::move(req);
        }
-        if (not n.candidate and ++i == syncLevel)
+        if (not n.candidate and ++i == TARGET_NODES)
            break;
    }
 }
@@ -700,10 +675,6 @@ Dht::searchStep(std::weak_ptr<Search> ws)
    if (not sr or sr->expired or sr->done) return;

    const auto& now = scheduler.time();
-    auto level = sr->syncLevel(now);
-    constexpr auto MARGIN = 1;
-    bool preSynced = level > MARGIN;
-    auto syncLevel = preSynced ? level - MARGIN : 0;
    /*if (auto req_count = sr->currentlySolicitedNodeCount())
        if (logger_)
            logger_->d(sr->id, "[search %s IPv%c] step (%d requests)",
@@ -764,21 +735,6 @@ Dht::searchStep(std::weak_ptr<Search> ws)

        if (sr->callbacks.empty() && sr->announce.empty() && sr->listeners.empty())
            sr->setDone();
-    } else if (preSynced) {
-        if (not sr->listeners.empty()) {
-            auto nl = std::min(syncLevel, LISTEN_NODES);
-            unsigned i = 0;
-            for (auto& n : sr->nodes) {
-                if (not n->isSynced(now))
-                    break;
-                searchSynchedNodeListen(sr, *n);
-                if (++i == nl)
-                    break;
-            }
-        }
-
-        // Announce requests
-        searchSendAnnounceValue(sr, syncLevel);
    }

    while (sr->currentlySolicitedNodeCount() < MAX_REQUESTED_SEARCH_NODES and searchSendGetValues(sr));
@@ -1483,10 +1439,11 @@ Dht::connectivityChanged(sa_family_t af)
 {
    const auto& now = scheduler.time();
    scheduler.edit(nextNodesConfirmation, now);
-    auto& dht = this->dht(af);
-    dht.buckets.connectivityChanged(now);
-    dht.reported_addr.clear();
+    buckets(af).connectivityChanged(now);
    network_engine.connectivityChanged(af);
+    reported_addr.erase(std::remove_if(reported_addr.begin(), reported_addr.end(), [&](const ReportedAddr& addr){
+        return addr.second.getFamily() == af;
+    }), reported_addr.end());
    startBootstrap(); // will only happen if disconnected
 }

@@ -1603,20 +1560,21 @@ Dht::dumpSearch(const Search& sr, std::ostream& out) const
    const auto& now = scheduler.time();
    const auto& listen_expire = getListenExpiration();
    using namespace std::chrono;
-    fmt::print(out, "Search IPv{} {} gets: {} last step: {}{}{}{}{}\n",
-        (sr.af == AF_INET6 ? '6' : '4'),
-        sr.id,
-        sr.callbacks.size(),
-        print_time_relative(now, sr.step_time),
-        (sr.done ? " [done]"sv : ""sv),
-        (sr.expired ? " [expired]"sv : ""sv),
-        (sr.isSynced(now) ? " [synced]"sv : " [not synced]"sv),
-        (sr.isListening(now, listen_expire) ? " [listening]"sv : ""sv)
-    );
+    out << std::endl << "Search IPv" << (sr.af == AF_INET6 ? '6' : '4') << ' ' << sr.id << " gets: " << sr.callbacks.size();
+    out << ", last step: " << print_time_relative(now, sr.step_time);
+    if (sr.done)
+        out << " [done]";
+    if (sr.expired)
+        out << " [expired]";
+    bool synced = sr.isSynced(now);
+    out << (synced ? " [synced]" : " [not synced]");
+    if (synced && sr.isListening(now, listen_expire))
+        out << " [listening]";
+    out << std::endl;

-    // printing the queries
+    /*printing the queries*/
    if (sr.callbacks.size() + sr.listeners.size() > 0)
-        fmt::print(out, "Queries:\n");
+        out << "Queries:" << std::endl;
    for (const auto& cb : sr.callbacks) {
        out << *cb.second.query << std::endl;
    }
@@ -1629,39 +1587,55 @@ Dht::dumpSearch(const Search& sr, std::ostream& out) const
        out << "Announcement: " << *a.value << (announced ? " [announced]" : "") << std::endl;
    }

-    fmt::print(out, " Common bits    InfoHash                       Conn. Get   Ops  IP\n");
+    out << " Common bits    InfoHash                       Conn. Get   Ops  IP" << std::endl;
    auto last_get = sr.getLastGetTime();
    for (const auto& np : sr.nodes) {
        auto& n = *np;
-        auto listen = (not sr.listeners.empty() ? (n.listenStatus.empty() ? "    " : fmt::format("[{}] ", (n.isListening(now,listen_expire) ? 'l' : (n.pending(n.listenStatus) ? 'f' : ' ')))) : "");
-        std::string announce;
+        out << std::setfill (' ') << std::setw(3) << InfoHash::commonBits(sr.id, n.node->id) << ' ' << n.node->id;
+        out << ' ' << (findNode(n.node->id, sr.af) ? '*' : ' ');
+        out << " [";
+        if (auto pendingCount = n.node->getPendingMessageCount())
+            out << pendingCount;
+        else
+            out << ' ';
+        out << (n.node->isExpired() ? 'x' : ' ') << "]";
+
+        // Get status
+        {
+            char g_i = n.pending(n.getStatus) ? (n.candidate ? 'c' : 'f') : ' ';
+            char s_i = n.isSynced(now) ? (n.last_get_reply > last_get ? 'u' : 's') : '-';
+            out << " [" << s_i << g_i << "] ";
+        }
+
+        // Listen status
+        if (not sr.listeners.empty()) {
+            if (n.listenStatus.empty())
+                out << "    ";
+            else
+                out << "["
+                    << (n.isListening(now,listen_expire) ? 'l' : (n.pending(n.listenStatus) ? 'f' : ' ')) << "] ";
+        }
+
+        // Announce status
        if (not sr.announce.empty()) {
            if (n.acked.empty()) {
-                announce = std::string(sr.announce.size() + 3, ' ');
+                out << "   ";
+                for (size_t a=0; a < sr.announce.size(); a++)
+                    out << ' ';
            } else {
-                announce = "[";
+                out << "[";
                for (const auto& a : sr.announce) {
                    auto ack = n.acked.find(a.value->id);
                    if (ack == n.acked.end() or not ack->second.req) {
-                        announce += ' ';
+                        out << ' ';
                    } else {
-                        announce += ack->second.req->getStateChar();
+                        out << ack->second.req->getStateChar();
                    }
                }
-                announce += "] ";
+                out << "] ";
            }
        }
-
-        fmt::print(out, "{:3} {} {} [{}{}] {}{}{}\n",
-            InfoHash::commonBits(sr.id, n.node->id),
-            n.node->id,
-            (findNode(n.node->id, sr.af) ? '*' : ' '),
-            (n.pending(n.getStatus) ? (n.candidate ? 'c' : 'f') : ' '),
-            (n.isSynced(now) ? (n.last_get_reply > last_get ? 'u' : 's') : '-'),
-            listen,
-            announce,
-            n.node->getAddrStr()
-        );
+        out << n.node->getAddrStr() << std::endl;
    }
 }

@@ -1866,7 +1840,7 @@ Dht::Dht(std::unique_ptr<net::DatagramSocket>&& sock, const Config& config, cons
    expire();

    if (logger_)
-        logger_->debug("DHT node initialised with ID {:s}", myid);
+        logger_->d("DHT node initialised with ID %s", myid.toString().c_str());
 }

 bool
@@ -2258,7 +2232,7 @@ Dht::pingNode(SockAddr sa, DoneCallbackSimple&& cb)
 {
    scheduler.syncTime();
    if (logger_)
-        logger_->debug("Sending ping to {}", sa);
+        logger_->d("Sending ping to %s", sa.toString().c_str());
    auto& count = dht(sa.getFamily()).pending_pings;
    count++;
    network_engine.sendPing(std::move(sa), [&count,cb](const net::Request&, net::RequestAnswer&&) {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *          Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *          Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
@@ -491,7 +491,7 @@ void
 DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallbackSimple cb, time_point /*created*/, bool permanent)
 {
    if (logger_)
-        logger_->debug("[proxy:client] [put] [search {}] executing for {}", key, val->toString());
+        logger_->d("[proxy:client] [put] [search %s] executing for %s", key.to_c_str(), val->toString().c_str());

    try {
        auto request = buildRequest("/key/" + key.toString());
@@ -539,12 +539,12 @@ DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallbackSimple cb,
                        }
                    } else {
                        if (logger_)
-                            logger_->error("[proxy:client] [put] failed to parse value from server: {}", err);
+                            logger_->e("[proxy:client] [status] failed to parse value from  server", response.status_code);
                    }
                }
            } else {
                if (logger_)
-                    logger_->error("[proxy:client] [put] failed with code={:d}", response.status_code);
+                    logger_->e("[proxy:client] [status] failed with code=%i", response.status_code);
                if (not response.aborted and response.status_code == 0)
                    opFailed();
            }
@@ -563,8 +563,7 @@ DhtProxyClient::doPut(const InfoHash& key, Sp<Value> val, DoneCallbackSimple cb,
    }
    catch (const std::exception &e){
        if (logger_)
-            logger_->error("[proxy:client] [put {}] error: {}", key, e.what());
-        opFailed();
+            logger_->e("[proxy:client] [put %s] error: %s", key.to_c_str(), e.what());
    }
 }

@@ -722,7 +721,7 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
        }
    } else {
        if (logger_)
-            logger_->debug("[proxy:client] [info] got proxy reply for {}",
+            logger_->d("[proxy:client] [info] got proxy reply for %s",
                       family == AF_INET ? "ipv4" : "ipv6");
        try {
            myid = InfoHash(proxyInfos["node_id"].asString());
@@ -730,7 +729,6 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
            stats6_ = NodeStats(proxyInfos["ipv6"]);
            auto publicIp = parsePublicAddress(proxyInfos["public_ip"]);
            ipChanged = pubAddress && pubAddress.toString() != publicIp.toString();
-            bool pub = ipChanged || !pubAddress;
            pubAddress = publicIp;

            if (proxyInfos.isMember("local_ip")) {
@@ -741,18 +739,6 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
                }
            }

-            if (pub && publicAddressChangedCb_) {
-                std::vector<SockAddr> addresses;
-                if (publicAddressV4_)
-                    addresses.emplace_back(publicAddressV4_);
-                if (publicAddressV6_)
-                    addresses.emplace_back(publicAddressV6_);
-                std::lock_guard<std::mutex> lock(lockCallbacks_);
-                callbacks_.emplace_back([cb=publicAddressChangedCb_, addresses = std::move(addresses)](){
-                    cb(std::move(addresses));
-                });
-            }
-
            if (!ipChanged && stats4_.good_nodes + stats6_.good_nodes)
                status = NodeStatus::Connected;
            else if (!ipChanged && stats4_.dubious_nodes + stats6_.dubious_nodes)
@@ -1155,7 +1141,7 @@ DhtProxyClient::restartListeners(const asio::error_code &ec)

    std::lock_guard<std::mutex> lock(searchLock_);
    for (auto& search : searches_) {
-        const auto& key = search.first;
+        auto key = search.first;
        for (auto& put : search.second.puts) {
            doPut(key, put.second.value, [ok = put.second.ok](bool result){
                *ok = result;
@@ -1167,10 +1153,6 @@ DhtProxyClient::restartListeners(const asio::error_code &ec)
            put.second.refreshPutTimer->async_wait(std::bind(&DhtProxyClient::handleRefreshPut, this,
                                                   std::placeholders::_1, key, put.first));
        }
-        // Restart failed pending puts
-        for (auto& pput : search.second.pendingPuts) {
-            doPut(key, pput, {}, time_point::max(), true);
-        }
    }
    if (not deviceKey_.empty()) {
        if (logger_)
@@ -1211,7 +1193,7 @@ DhtProxyClient::restartListeners(const asio::error_code &ec)
 }

 void
-DhtProxyClient::pushNotificationReceived([[maybe_unused]] const std::map<std::string, std::string>& notification)
+DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string>& notification)
 {
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
    {
@@ -1310,11 +1292,13 @@ DhtProxyClient::pushNotificationReceived([[maybe_unused]] const std::map<std::st
    }
    if (launchLoop)
        loopSignal_();
+#else
+    (void) notification;
 #endif
 }

 void
-DhtProxyClient::resubscribe([[maybe_unused]] const InfoHash& key, [[maybe_unused]] const size_t token, [[maybe_unused]] Listener& listener)
+DhtProxyClient::resubscribe(const InfoHash& key, const size_t token, Listener& listener)
 {
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
    if (deviceKey_.empty())
@@ -1338,6 +1322,9 @@ DhtProxyClient::resubscribe([[maybe_unused]] const InfoHash& key, [[maybe_unused
                                                std::placeholders::_1, key, token, opstate));
    auto vcb = listener.cb;
    sendListen(header, vcb, opstate, listener, ListenMethod::RESUBSCRIBE);
+#else
+    (void) key;
+    (void) listener;
 #endif
 }

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *          Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *          Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
@@ -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() && type != PushType::UnifiedPush)
+    if (pushServer_.empty())
        return;

    unsigned reqid = 0;
@@ -1080,7 +1080,6 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
            request->set_body(Json::writeString(jsonBuilder_, std::move(json)));
        } else {
            // NOTE: see https://github.com/appleboy/gorush
-            auto isResubscribe = json.isMember("timeout");
            Json::Value notification(Json::objectValue);
            Json::Value tokens(Json::arrayValue);
            tokens[0] = token;
@@ -1096,13 +1095,12 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
                notification["expiration"] = exp;
                if (!topic.empty())
                    notification["topic"] = topic;
-                if (highPriority || isResubscribe) {
+                if (highPriority) {
                    Json::Value alert(Json::objectValue);
                    alert["title"]="hello";
                    notification["push_type"] = "alert";
                    notification["alert"] = alert;
                    notification["mutable_content"] = true;
-                    notification["priority"] = "high";
                } else {
                    notification["push_type"] = "background";
                    notification["content_available"] = true;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -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.", fmt::ptr(this));
+            context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", 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", fmt::ptr(this));
+                context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", 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", fmt::ptr(this), port);
+                            context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", 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", fmt::ptr(this), port);
+                            context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", 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", fmt::ptr(this));
+            logger_->d("[runner %p] state changed to Running", 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!", fmt::ptr(this), dropped);
+                        logger_->w("[runner %p] dropped %zu packets: queue is full!", this, dropped);
                    }
                    ret = std::move(rcv_free);
                }
@@ -186,9 +186,6 @@ DhtRunner::run(const Config& config, Context&& context)
    if (context.certificateStore) {
        dht_->setLocalCertificateStore(std::move(context.certificateStore));
    }
-    if (context.publicAddressChangedCb) {
-        dht_->setOnPublicAddressChanged(std::move(context.publicAddressChangedCb));
-    }

    if (not config.threaded)
        return;
@@ -284,7 +281,7 @@ DhtRunner::shutdown(ShutdownCallback cb, bool stop) {
        return;
    }
    if (logger_)
-        logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", fmt::ptr(this), ongoing_ops.load());
+        logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", this, ongoing_ops.load());
    ongoing_ops++;
    shutdownCallbacks_.emplace_back(std::move(cb));
    pending_ops.emplace([=](SecureDht&) mutable {
@@ -349,7 +346,7 @@ DhtRunner::join()
            if (auto sock = dht_->getSocket())
                sock->stop();
        if (logger_)
-            logger_->d("[runner %p] state changed to Idle", fmt::ptr(this));
+            logger_->d("[runner %p] state changed to Idle", this);
    }

    if (dht_thread.joinable())
@@ -358,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", fmt::ptr(this), ongoing_ops.load());
+            logger_->w("[runner %p] stopping with %zu remaining ops", this, ongoing_ops.load());
        }
        pending_ops = decltype(pending_ops)();
        pending_ops_prio = decltype(pending_ops_prio)();
@@ -457,6 +454,12 @@ 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);
@@ -683,7 +686,7 @@ DhtRunner::loop_()
    }

    if (dropped && logger_)
-        logger_->e("[runner %p] Dropped %zu packets with high delay.", fmt::ptr(this), dropped);
+        logger_->e("[runner %p] Dropped %zu packets with high delay.", this, dropped);

    NodeStatus nstatus4 = dht_->updateStatus(AF_INET);
    NodeStatus nstatus6 = dht_->updateStatus(AF_INET6);
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -17,7 +17,7 @@
 */

 #include "http.h"
-#include "logger.h"
+#include "log_enable.h"
 #include "crypto.h"
 #include "base64.h"
 #include "compat/os_cert.h"
@@ -33,10 +33,6 @@
 #include <openssl/x509.h>
 #include <openssl/x509_vfy.h>

-#include <cctype>
-#include <iomanip>
-#include <sstream>
-
 #define MAXAGE_SEC (14*24*60*60)
 #define JITTER_SEC (60)
 #define OCSP_MAX_RESPONSE_SIZE (20480)
@@ -115,11 +111,11 @@ newTlsClientContext(const std::shared_ptr<dht::Logger>& logger)

    if (char* path = getenv("CA_ROOT_FILE")) {
        if (logger)
-            logger->debug("Using CA file: {}", path);
+            logger->d("Using CA file: %s", path);
        ctx->load_verify_file(path);
    } else if (char* path = getenv("CA_ROOT_PATH")) {
        if (logger)
-            logger->debug("Using CA path: {}", path);
+            logger->d("Using CA path: %s", path);
        ctx->add_verify_path(path);
    } else {
 #ifdef __ANDROID__
@@ -1088,30 +1084,6 @@ Request::build()
    request_ = request.str();
 }

-// https://stackoverflow.com/a/17708801
-std::string
-Request::url_encode(std::string_view value)
-{
-    std::ostringstream escaped;
-    escaped.fill('0');
-    escaped << std::hex;
-
-    for (const char& c : value) {
-        // Keep alphanumeric and other accepted characters intact
-        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
-            escaped << c;
-            continue;
-        }
-
-        // Any other characters are percent-encoded
-        escaped << std::uppercase;
-        escaped << '%' << std::setw(2) << static_cast<int>(static_cast<unsigned char>(c));
-        escaped << std::nouppercase;
-    }
-
-    return escaped.str();
-}
-
 void
 Request::add_on_status_callback(OnStatusCb cb) {
    cbs_.on_status = std::move(cb);
@@ -1317,7 +1289,7 @@ Request::post()
    init_parser();

    if (logger_)
-        logger_->debug("[http:request:{}] sending {} bytes", id_, request_.size());
+        logger_->d("[http:request:%i] sending %zu bytes", id_, request_.size());

    // write the request to buffer
    std::ostream request_stream(&conn_->input());
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *              Nicolas Reynaud <nicolas.reynaud@savoirfairelinux.com>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -20,10 +20,6 @@
 #include "log.h"
 #include "dhtrunner.h"

-#include <fmt/format.h>
-#include <fmt/ostream.h>
-#include <fmt/printf.h>
-
 #ifndef _WIN32
 #include <syslog.h>
 #endif
@@ -34,70 +30,46 @@
 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
-printfLog(std::ostream& s, const std::string& message) {
+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
    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);
-    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::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]]";
    s << std::endl;
 }

 std::shared_ptr<Logger>
 getStdLogger() {
    return std::make_shared<Logger>(
-        [](LogLevel level, std::string&& message) {
-            if (level == LogLevel::error)
-                std::cerr << red;
-            else if (level == LogLevel::warning)
-                std::cerr << yellow;
-            printfLog(std::cerr, message);
+        [](char const *m, va_list args) {
+            std::cerr << red;
+            printLog(std::cerr, m, args);
            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); }
    );
 }

@@ -105,28 +77,14 @@ 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>(
-        [logfile](LogLevel /*level*/, std::string&& message) {
-            printfLog(*logfile, message);
-        }
+        [=](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); }
    );
 }

-#ifndef _WIN32
-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;
-}
-#endif
-
 std::shared_ptr<Logger>
 getSyslogLogger(const char* name) {
 #ifndef _WIN32
@@ -146,11 +104,12 @@ getSyslogLogger(const char* name) {
        opened_logfile = logfile;
    }
    return std::make_shared<Logger>(
-        [logfile](LogLevel level, std::string&& message) {
-            syslog(syslogLevel(level), "%s", message.c_str());
-        });
+        [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); }
+    );
 #else
-    return getStdLogger();
+    return std::make_shared<Logger>();
 #endif
 }

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -20,12 +20,10 @@
 #include "network_engine.h"
 #include "request.h"
 #include "default_types.h"
-#include "logger.h"
+#include "log_enable.h"
 #include "parsed_message.h"

 #include <msgpack.hpp>
-#include <chrono>
-#include <string_view>

 namespace dht {
 namespace net {
@@ -43,8 +41,7 @@ constexpr std::chrono::seconds NetworkEngine::UDP_REPLY_TIME;
 constexpr std::chrono::seconds NetworkEngine::RX_MAX_PACKET_TIME;
 constexpr std::chrono::seconds NetworkEngine::RX_TIMEOUT;

-/* OpenDHT User Agent (UA) */
-constexpr std::string_view OPENDHT_UA {"o2"};
+const std::string NetworkEngine::my_v {"RNG1"};

 static constexpr uint8_t v4prefix[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0, 0, 0, 0};

@@ -162,7 +159,7 @@ NetworkEngine::tellListenerRefreshed(const Sp<Node>& n, Tid socket_id, const Inf
        }

    pk.pack(KEY_Y); pk.pack(version >= 1 ? KEY_Q : KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -213,7 +210,7 @@ NetworkEngine::tellListenerExpired(const Sp<Node>& n, Tid socket_id, const InfoH
        }

    pk.pack(KEY_Y); pk.pack(version >= 1 ? KEY_Q : KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -378,6 +375,7 @@ NetworkEngine::isMartian(const SockAddr& addr)
        const auto& sin6 = addr.getIPv6();
        const uint8_t* address = (const uint8_t*)&sin6.sin6_addr;
        return address[0] == 0xFF ||
+              (address[0] == 0xFE && (address[1] & 0xC0) == 0x80) ||
               memcmp(address, InfoHash::zero().data(), 16) == 0 ||
               memcmp(address, v4prefix,      12) == 0;
    }
@@ -712,7 +710,7 @@ NetworkEngine::sendPing(const Sp<Node>& node, RequestCb&& on_done, RequestExpire
    pk.pack(KEY_Q); pk.pack(QUERY_PING);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_Q);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -749,7 +747,7 @@ NetworkEngine::sendPong(const SockAddr& addr, Tid tid) {

    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -778,7 +776,7 @@ NetworkEngine::sendFindNode(const Sp<Node>& n, const InfoHash& target, want_t wa
    pk.pack(KEY_Q); pk.pack(QUERY_FIND);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_Q);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -831,7 +829,7 @@ NetworkEngine::sendGetValues(const Sp<Node>& n, const InfoHash& info_hash, const
    pk.pack(KEY_Q); pk.pack(QUERY_GET);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_Q);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1014,7 +1012,7 @@ NetworkEngine::sendNodesValues(const SockAddr& addr, Tid tid, const Blob& nodes,

    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1105,7 +1103,7 @@ NetworkEngine::sendListen(const Sp<Node>& n,
    pk.pack(KEY_Q); pk.pack(QUERY_LISTEN);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_Q);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1138,7 +1136,7 @@ NetworkEngine::sendListenConfirmation(const SockAddr& addr, Tid tid) {

    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1174,7 +1172,7 @@ NetworkEngine::sendAnnounceValue(const Sp<Node>& n,
    pk.pack(KEY_Q);   pk.pack(QUERY_PUT);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y);   pk.pack(KEY_Q);
-    pk.pack(KEY_UA);  pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA);  pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1261,7 +1259,7 @@ NetworkEngine::sendUpdateValues(const Sp<Node>& n,
    pk.pack(KEY_Q);   pk.pack(QUERY_UPDATE);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y);   pk.pack(KEY_Q);
-    pk.pack(KEY_UA);  pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA);  pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1300,7 +1298,7 @@ NetworkEngine::sendRefreshValue(const Sp<Node>& n,
    pk.pack(KEY_Q); pk.pack(QUERY_REFRESH);
    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_Q);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1344,7 +1342,7 @@ NetworkEngine::sendValueAnnounced(const SockAddr& addr, Tid tid, Value::Id vid)

    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_R);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1374,7 +1372,7 @@ NetworkEngine::sendError(const SockAddr& addr,

    pk.pack(KEY_TID); pk.pack(tid);
    pk.pack(KEY_Y); pk.pack(KEY_E);
-    pk.pack(KEY_UA); pk.pack(OPENDHT_UA);
+    pk.pack(KEY_UA); pk.pack(my_v);
    if (config.network) {
        pk.pack(KEY_NETID); pk.pack(config.network);
    }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -20,8 +20,8 @@

 namespace dht {

-constexpr size_t CLEANUP_MAX_NODES {4 * 1024};
-constexpr size_t CLEANUP_FREQ {4 * 1024};
+constexpr size_t CLEANUP_MAX_NODES {1024};
+constexpr size_t CLEANUP_FREQ {1024};

 NodeCache::~NodeCache()
 {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Mingrui Zhang <mingrui.zhang@savoirfairelinux.com>
 *              Vsevolod Ivanov <vsevolod.ivanov@savoirfairelinux.com>
 *              Adrien Béraud <adrien.beraud@savoirfairelinux.com>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -485,8 +485,6 @@ struct Dht::Search {
     */
    bool isSynced(time_point now) const;

-    unsigned syncLevel(time_point now) const;
-
    /**
     * Get the time of the last "get" operation performed on this search,
     * or time_point::min() if no such operation have been performed.
@@ -854,17 +852,12 @@ Dht::Search::insertNode(const Sp<Node>& snode, time_point now, const Blob& token
            expired = false;
        }

-        while (nodes.size() - bad > SEARCH_NODES) {
-            bool removingNode = nodes.back()->node == snode;
+        while (nodes.size() - bad >  SEARCH_NODES) {
            if (not expired and nodes.back()->isBad())
                bad--;
            nodes.pop_back();
-            if (removingNode)
-                return false;
        }
    }
-    if (n == nodes.end() or not *n)
-        return false;
    if (not token.empty()) {
        (*n)->candidate = false;
        (*n)->last_get_reply = now;
@@ -902,21 +895,6 @@ Dht::Search::isSynced(time_point now) const
    return i > 0;
 }

-unsigned
-Dht::Search::syncLevel(time_point now) const
-{
-    unsigned i = 0;
-    for (const auto& n : nodes) {
-        if (n->isBad())
-            continue;
-        if (not n->isSynced(now))
-            return i;
-        if (++i == TARGET_NODES)
-            break;
-    }
-    return i;
-}
-
 time_point
 Dht::Search::getLastGetTime(const Query& q) const
 {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2023 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Authors: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *           Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
 *           Sébastien Blin <sebastien.blin@savoirfairelinux.com>
@@ -66,9 +66,7 @@ SecureDht::SecureDht(std::unique_ptr<DhtInterface> dht, SecureDht::Config conf,
    }
 }

-SecureDht::~SecureDht(){
-    dht_.reset();
-}
+SecureDht::~SecureDht() = default;

 ValueType
 SecureDht::secureType(ValueType&& type)
Author	SHA1	Message	Date
Adrien Beraud	95f3920ca8	ci/github: cleanup	2023-03-25 18:27:19 -04:00
Adrien Beraud	5f1e7952a4	Revert "more attempts to find msgpackc-cxx in a universal way" This reverts commit `965fbb43c7`.	2023-03-25 18:26:47 -04:00