unit tests: wait 1ms between puts

ci/github: add macOS build action
misc: use more string_view
2026-11-08 12:28:42 +00:00 · 2022-04-03 17:16:24 -04:00 · 2022-04-03 16:53:54 -04:00 · 2022-04-02 17:14:36 -04:00 · 2022-04-01 19:35:15 -04:00 · 2022-04-01 19:17:44 -04:00
141 changed files with 1386 additions and 1052 deletions
@@ -0,0 +1,12 @@
+{
+	"name": "C++",
+	"build": {
+		"dockerfile": "../docker/DockerfileDepsLlvm",
+	},
+	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"],
+	"settings": {},
+	"extensions": [
+		"ms-vscode.cpptools"
+	],
+	"forwardPorts": [4222],
+}
@@ -3,22 +3,18 @@ name: C/C++ CI
 on: [push]

 jobs:
-  build:
-
+  build-ubuntu:
+    name: Ubuntu/GCC build
    runs-on: ubuntu-latest
-    
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
    - name: deps
      run: |
        sudo apt install libncurses5-dev libreadline-dev nettle-dev \
        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
-        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev
+        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev libargon2-0-dev
    - name: autogen
      run: ./autogen.sh
-    - name: argon2
-      run: |
-        cd argon2 && make && sudo make install && cd ..
    - name: asio
      run: |
        wget https://github.com/aberaud/asio/archive/b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz \
@@ -32,3 +28,41 @@ jobs:
      run: make
    - name: make check
      run: make check
+
+  build-macos:
+    name: macOS/Clang build
+    runs-on: macos-11
+    steps:
+    - uses: actions/checkout@v3
+    - name: deps
+      run: |
+        brew install msgpack-cxx asio gnutls nettle readline fmt jsoncpp argon2 openssl http-parser cppunit
+    
+    - name: restinio
+      run: |
+        mkdir restinio && cd restinio
+        wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz
+        ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz
+        cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/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 .
+        make -j8 && sudo make install
+        cd ../../.. && rm -rf restinio
+
+    - name: cmake
+      run: |
+        mkdir build && cd build
+        export PATH="/opt/homebrew/opt/openssl@3/bin:$PATH"
+        export LDFLAGS="-L/usr/local/opt/openssl@3/lib"
+        export CPPFLAGS="-I/usr/local/opt/openssl@3/include"
+        export PKG_CONFIG_PATH="/usr/local/opt/openssl@3/lib/pkgconfig"
+        cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Debug \
+                 -DOPENDHT_C=On -DOPENDHT_TESTS=On -DOPENDHT_PEER_DISCOVERY=On -DOPENDHT_PYTHON=Off \
+                 -DOPENDHT_TOOLS=On -DOPENDHT_PROXY_SERVER=On -DOPENDHT_PROXY_CLIENT=On
+
+    - name: make
+      run: cd build && make
+
+    - name: make check
+      run: cd build && ./opendht_unit_tests
@@ -0,0 +1,35 @@
+name: Clang Static Analysis
+on:
+  push
+jobs:
+  clang-analyzer:
+    name: Clang Static Analysis
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: deps
+        run: |
+          sudo apt install libncurses5-dev libreadline-dev nettle-dev \
+          libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
+          autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev libargon2-0-dev libasio-dev \
+          llvm llvm-dev clang clang-tools && \
+          sudo apt remove gcc g++
+
+      - name: restinio
+        run: |
+          mkdir restinio && cd restinio \
+          && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+          && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+          && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/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 && sudo make install \
+          && cd ../../.. && rm -rf restinio
+
+      - name: cmake
+        run: |
+          mkdir build && cd build && \
+          cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug -DOPENDHT_C=On -DOPENDHT_PEER_DISCOVERY=On -DOPENDHT_PYTHON=Off -DOPENDHT_TOOLS=On -DOPENDHT_PROXY_SERVER=On -DOPENDHT_PROXY_CLIENT=On
+      - name: scan-build
+        run: cd build && scan-build --status-bugs make
@@ -19,6 +19,9 @@
 *.exe
 *.out
 *.app
+**/dhtnode
+**/dhtchat
+**/dhtscanner

 # Autotools
 /ac
@@ -73,3 +76,4 @@ doc/Doxyfile

 # build dir
 build
+.DS_Store
@@ -1,4 +0,0 @@
-[submodule "argon2"]
-	path = argon2
-	url = https://github.com/P-H-C/phc-winner-argon2
-	ignore = dirty
@@ -1,67 +0,0 @@
-dist: xenial
-sudo: required
-
-services:
-  - docker
-
-language: cpp
-
-env:
-  matrix:
-    - OPENDHT_TEST_JOB="opendht.classic"
-    - OPENDHT_TEST_JOB="opendht.llvm"
-    - OPENDHT_TEST_JOB="opendht.proxyserver"
-    - OPENDHT_TEST_JOB="opendht.proxyclient"
-    - OPENDHT_TEST_JOB="opendht.push"
-
-before_install:
-  - |
-    if [[ "$OPENDHT_TEST_JOB" == *"opendht.classic"* ]]; then
-      docker pull aberaud/opendht-deps-bionic;
-    fi
-    if [[ "$OPENDHT_TEST_JOB" == *"opendht.proxyclient"* ]] || [[ "$OPENDHT_TEST_JOB" == *"opendht.proxyserver"* ]] || [[ "$OPENDHT_TEST_JOB" == *"opendht.push"* ]]; then
-      docker pull aberaud/opendht-deps;
-    fi
-    if [[ "$OPENDHT_TEST_JOB" == *"opendht.llvm"* ]]; then
-      docker pull aberaud/opendht-deps-llvm
-    fi
-
-script:
-  - |
-    # classic build
-    if [[ "$OPENDHT_TEST_JOB" == *"opendht.classic"* ]]; then
-      docker build -t opendht -f docker/DockerfileTravis .;
-    fi
-
-  - |
-    # proxy builds
-    if [[ "$OPENDHT_TEST_JOB" != *"opendht.llvm"* ]] && [[ "$OPENDHT_TEST_JOB" != *"opendht.classic"* ]]; then
-      docker build -t opendht-proxy -f docker/DockerfileTravisProxy .;
-      options='-DOPENDHT_SANITIZE=On ';
-      if [[ "$OPENDHT_TEST_JOB" == *"opendht.proxyserver"* ]] || [[ "$OPENDHT_TEST_JOB" == *"opendht.push"* ]]; then
-        options+='-DOPENDHT_PROXY_SERVER=ON ';
-      else
-        options+='-DOPENDHT_PROXY_SERVER=OFF ';
-      fi
-      if [[ "$OPENDHT_TEST_JOB" == *"opendht.proxyclient"* ]] || [[ "$OPENDHT_TEST_JOB" == *"opendht.push"* ]]; then
-        options+='-DOPENDHT_PROXY_CLIENT=ON ';
-      else
-        options+='-DOPENDHT_PROXY_CLIENT=OFF ';
-      fi
-      if [[ "$OPENDHT_TEST_JOB" == *"opendht.push"* ]]; then
-        options+='-DOPENDHT_PUSH_NOTIFICATIONS=ON ';
-      else
-        options+='-DOPENDHT_PUSH_NOTIFICATIONS=OFF ';
-      fi
-      docker run opendht-proxy /bin/sh -c "cd /root/opendht && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=ON -DOPENDHT_LTO=ON -DOPENDHT_TESTS=ON $options .. && make -j8 && ./opendht_unit_tests && make install";
-    fi
-
-  - |
-    # llvm build
-    if [[ "$OPENDHT_TEST_JOB" == *"opendht.llvm"* ]]; then
-      docker build -f docker/DockerfileTravisLlvm .
-    fi
-
-notifications:
-  email:
-      - adrien.beraud@savoirfairelinux.com
@@ -0,0 +1,54 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "dhtnode",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/tools/dhtnode",
+            "args": ["-v", "-p", "4222"],
+            "cwd": "${workspaceFolder}/build",
+            "environment": [],
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "build",
+            "linux": {
+                "MIMode": "gdb",
+                "externalConsole": false,
+              },
+              "osx": {
+                "MIMode": "lldb",
+                "externalConsole": true,
+              },
+        },
+        {
+            "name": "tests",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/opendht_unit_tests",
+            "cwd": "${workspaceFolder}/build",
+            "environment": [],
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "build",
+                        "linux": {
+                "MIMode": "gdb",
+                "externalConsole": false,
+              },
+              "osx": {
+                "MIMode": "lldb",
+                "externalConsole": true,
+              },
+        }
+    ]
+}
@@ -0,0 +1,44 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "type": "shell",
+            "options": {
+                "cwd": "${workspaceRoot}/build"
+            },
+            "command": "make",
+            "args": ["-j4"],
+            "dependsOn": "cmake"
+        },
+        {
+            "label": "cmake",
+            "type": "shell",
+            "options": {
+                "cwd": "${workspaceRoot}/build"
+            },
+            "command": "cmake",
+            "args": [
+                "${workspaceRoot}",
+                "-DCMAKE_BUILD_TYPE=Debug",
+                "-DOPENDHT_PROXY_CLIENT=On",
+                "-DOPENDHT_PROXY_SERVER=On",
+                "-DOPENDHT_TESTS=On",
+                "-DOPENDHT_C=On"
+            ],
+            "dependsOn": "builddir"
+        },
+        {
+            "label": "builddir",
+            "type": "shell",
+            "options": {
+                "cwd": "${workspaceRoot}"
+            },
+            "command": "mkdir",
+            "args": [
+                "-p",
+                "${workspaceRoot}/build"
+            ]
+        },
+    ]
+}
@@ -1,4 +1,16 @@
-cmake_minimum_required (VERSION 3.1)
+cmake_minimum_required (VERSION 3.10)
+if(POLICY CMP0065)
+  cmake_policy(SET CMP0065 NEW)
+endif()
+if(POLICY CMP0069)
+  cmake_policy(SET CMP0069 NEW)
+endif()
+if(POLICY CMP0073)
+  cmake_policy(SET CMP0073 NEW)
+endif()
+if(POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
+endif()
 project (opendht)

 include(CMakePackageConfigHelpers)
@@ -7,7 +19,7 @@ include(FindPkgConfig)
 include(cmake/CheckAtomic.cmake)

 set (opendht_VERSION_MAJOR 2)
-set (opendht_VERSION_MINOR 2.0)
+set (opendht_VERSION_MINOR 4.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -20,15 +32,12 @@ option (OPENDHT_PYTHON "Build Python bindings" OFF)
 option (OPENDHT_TOOLS "Build DHT tools" ON)
 option (OPENDHT_SYSTEMD "Install systemd module" OFF)
 option (OPENDHT_SYSTEMD_UNIT_FILE_LOCATION "Where to install systemd unit file")
-option (OPENDHT_ARGON2 "Use included argon2 sources" OFF)
-option (OPENDHT_LTO "Build with LTO" OFF)
 option (OPENDHT_SANITIZE "Build with address sanitizer and stack protector" OFF)
 option (OPENDHT_PROXY_SERVER "Enable DHT proxy server, use Restinio and jsoncpp" OFF)
 option (OPENDHT_PUSH_NOTIFICATIONS "Enable push notifications support" OFF)
 option (OPENDHT_PROXY_SERVER_IDENTITY "Allow clients to use the node identity" OFF)
 option (OPENDHT_PROXY_CLIENT "Enable DHT proxy client, use Restinio and jsoncpp" OFF)
 option (OPENDHT_PROXY_OPENSSL "Build DHT proxy with OpenSSL" ON)
-option (OPENDHT_PROXY_HTTP_PARSER_FORK "Build DHT proxy with custom http_parser to support old API" OFF)
 CMAKE_DEPENDENT_OPTION(OPENDHT_HTTP "Build embedded http(s) client" OFF "NOT OPENDHT_PROXY_SERVER;NOT OPENDHT_PROXY_CLIENT" ON)
 option (OPENDHT_PEER_DISCOVERY "Enable multicast peer discovery" ON)
 option (OPENDHT_INDEX "Build DHT indexation feature" OFF)
@@ -46,22 +55,12 @@ if (NOT MSVC)
    find_package (Threads)
    find_package (PkgConfig REQUIRED)
    find_package (GnuTLS 3.3 REQUIRED)
-    pkg_search_module (Nettle nettle)
-    find_package (Msgpack 1.2 REQUIRED)
+    pkg_search_module (Nettle REQUIRED nettle)
+    find_package (msgpack REQUIRED)
    if (OPENDHT_TOOLS)
        find_package (Readline 6 REQUIRED)
    endif ()
-    if (NOT OPENDHT_ARGON2)
-        pkg_search_module(argon2 libargon2)
-        if (argon2_FOUND)
-            message("-- Found Argon2: " ${argon2_LIBRARY_DIRS} " (found version \"" ${argon2_VERSION} "\")")
-            link_directories (${argon2_LIBRARY_DIRS})
-        else ()
-            message("Argon2 not found, using included version.")
-            set(OPENDHT_ARGON2 ON)
-        endif()
-    endif ()
-
+    pkg_search_module(argon2 REQUIRED libargon2)
    pkg_search_module(Jsoncpp jsoncpp)
    if (Jsoncpp_FOUND)
        add_definitions(-DOPENDHT_JSONCPP)
@@ -95,9 +94,6 @@ if (NOT MSVC)
                message(SEND_ERROR "OpenSSL is required for DHT proxy as specified")
            endif()
        endif()
-        if (OPENDHT_PROXY_HTTP_PARSER_FORK)
-            add_definitions(-DOPENDHT_PROXY_HTTP_PARSER_FORK)
-        endif()
    else ()
        set(OPENDHT_PROXY_OPENSSL OFF)
    endif ()
@@ -128,7 +124,7 @@ if (OPENDHT_HTTP OR OPENDHT_PEER_DISCOVERY)
 endif()

 # Build flags
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 17)
 set (CMAKE_CXX_STANDARD_REQUIRED on)

 if (NOT MSVC)
@@ -146,7 +142,7 @@ else ()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DISABLE_MSC_WARNINGS}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 endif ()
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_NO_BOOST -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")

 if (NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
@@ -157,15 +153,6 @@ if (OPENDHT_LOG)
 else ()
    add_definitions(-DOPENDHT_LOG=false)
 endif()
-if (OPENDHT_LTO AND NOT MSVC)
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
-    if (CMAKE_COMPILER_IS_GNUCC)
-        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-linker-plugin")
-        set (CMAKE_AR        "gcc-ar")
-        set (CMAKE_NM        "gcc-nm")
-        set (CMAKE_RANLIB    "gcc-ranlib")
-    endif ()
-endif ()

 if (MSGPACK_INCLUDE_DIRS)
    include_directories (SYSTEM "${MSGPACK_INCLUDE_DIRS}")
@@ -187,6 +174,7 @@ if (Jsoncpp_INCLUDE_DIRS)
 endif ()
 link_directories (${Nettle_LIBRARY_DIRS})
 link_directories (${Jsoncpp_LIBRARY_DIRS})
+link_directories (${argon2_LIBRARY_DIRS})
 include_directories (
    ./
    include/
@@ -314,23 +302,6 @@ if (OPENDHT_HTTP)
  )
 endif ()

-if(OPENDHT_ARGON2)
-    # make sure argon2 submodule is up to date and initialized
-    message("Initializing Argon2 submodule")
-    execute_process(COMMAND git submodule update --init)
-
-    # add local argon2 files to build
-    list (APPEND opendht_SOURCES
-        argon2/src/argon2.c
-        argon2/src/core.c
-        argon2/src/blake2/blake2b.c
-        argon2/src/thread.c
-        argon2/src/ref.c
-        argon2/src/encoding.c
-    )
-    include_directories(argon2/include/)
-endif()
-
 if (MSVC)
    list (APPEND opendht_HEADERS src/compat/msvc/unistd.h)
 endif ()
@@ -343,11 +314,7 @@ if (OPENDHT_STATIC)
            ${opendht_HEADERS}
        )
        set_target_properties (opendht-static PROPERTIES OUTPUT_NAME "opendht")
-        if (OPENDHT_ARGON2)
-            target_include_directories(opendht-static SYSTEM PRIVATE argon2)
-        else ()
-            target_include_directories(opendht-static SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
-        endif ()
+        target_include_directories(opendht-static SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
        target_link_libraries(opendht-static
            PRIVATE  ${argon2_LIBRARIES}
            PUBLIC ${CMAKE_THREAD_LIBS_INIT} ${GNUTLS_LIBRARIES} ${Nettle_STATIC_LIBRARIES}
@@ -412,25 +379,20 @@ if (OPENDHT_SHARED)
    set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
    set_target_properties (opendht PROPERTIES SOVERSION ${opendht_VERSION_MAJOR} VERSION ${opendht_VERSION})
    target_compile_definitions(opendht PRIVATE OPENDHT_BUILD)
-    if (OPENDHT_ARGON2)
-        target_include_directories(opendht SYSTEM PRIVATE argon2)
-    else ()
-        target_link_libraries(opendht PRIVATE ${argon2_LIBRARIES})
-        target_include_directories(opendht SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
-    endif ()
+    target_include_directories(opendht SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
    if (APPLE)
        target_link_libraries(opendht
            PUBLIC ${CMAKE_THREAD_LIBS_INIT} ${OPENSSL_LIBRARIES}
            PRIVATE ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES}
                    ${Jsoncpp_LIBRARIES}
-                    ${FMT_LIBRARY} ${HTTP_PARSER_LIBRARY}
+                    ${FMT_LIBRARY} ${HTTP_PARSER_LIBRARY} ${argon2_LIBRARIES}
            SYSTEM "-framework CoreFoundation" "-framework Security")
    else ()
        target_link_libraries(opendht
            PUBLIC ${CMAKE_THREAD_LIBS_INIT} ${OPENSSL_LIBRARIES}
            PRIVATE ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES}
                    ${Jsoncpp_LIBRARIES}
-                    ${FMT_LIBRARY} ${HTTP_PARSER_LIBRARY})
+                    ${FMT_LIBRARY} ${HTTP_PARSER_LIBRARY} ${argon2_LIBRARIES})
    endif ()

    install (TARGETS opendht DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht)
@@ -456,6 +418,7 @@ if (OPENDHT_C)
    )
    install (TARGETS opendht-c DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht-c)
    install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendht-c.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+    install (FILES c/opendht_c.h DESTINATION ${CMAKE_INSTALL_PREFIX}/include/opendht)
 endif ()

 if (OPENDHT_TOOLS)
@@ -4,7 +4,7 @@
    <a id="user-content-opendht-" class="anchor" href="/savoirfairelinux/opendht/blob/master/README.md#opendht-" aria-hidden="true"></a>OpenDHT
 </h1>

-A lightweight C++14 Distributed Hash Table implementation.
+A lightweight C++17 Distributed Hash Table implementation.

 OpenDHT provides an easy to use distributed in-memory data store.
 Every node in the network can read and write values to the store.
@@ -14,7 +14,7 @@ Values are distributed over the network, with redundancy.
 * High resilience to network disruption
 * Public key cryptography layer providing optional data signature and encryption (using GnuTLS)
 * IPv4 and IPv6 support
- * Clean and powerful **C++14** map API
+ * Clean and powerful **C++17** map API
 * Bindings for **C, Rust & Python 3**
 * REST API with optional HTTP client+server with push notification support

@@ -27,7 +27,7 @@ Build instructions: <https://github.com/savoirfairelinux/opendht/wiki/Build-the-

 #### How-to build a simple client app
 ```bash
-g++ main.cpp -std=c++14 -lopendht
+g++ main.cpp -std=c++17 -lopendht
 ```

 ## Examples
@@ -98,15 +98,15 @@ for r in results:
 - Nettle 2.4+, a GnuTLS dependency for crypto.
 - (optional) restinio used for the REST API.
 - (optional) jsoncpp 1.7.4-3+, used for the REST API.
- Build tested with GCC 5.2+ (GNU/Linux, Windows with MinGW), Clang/LLVM (GNU/Linux, Android, macOS, iOS).
- Build tested with Microsoft Visual Studio 2015, 2017, 2019
+- Build tested with GCC 7+ (GNU/Linux, Windows with MinGW), Clang/LLVM (GNU/Linux, Android, macOS, iOS).
+- Build tested with Microsoft Visual Studio 2017, 2019, 2022

 ## Contact

-IRC: join us on Freenode at [`#opendht`](https://webchat.freenode.net/?channels=%23opendht).
+IRC: join us on Libera.chat at [`#opendht`](https://web.libera.chat/#opendht).

 ## License
-Copyright (C) 2014-2020 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,2 +1 @@
-git submodule update --init
 autoreconf --install --verbose -Wall
@@ -1,3 +1,21 @@
+/*
+ *  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/>.
+ */
+
 #include "opendht_c.h"
 #include "opendht.h"

@@ -10,6 +28,8 @@ using CertSp = std::shared_ptr<dht::crypto::Certificate>;
 extern "C" {
 #endif

+#include <errno.h>
+
 // dht::InfoHash

 inline dht_infohash dht_infohash_to_c(const dht::InfoHash& h) {
@@ -97,10 +117,20 @@ const char* dht_value_get_user_type(const dht_value* data) {
    return vsp->user_type.c_str();
 }

+void dht_value_set_user_type(dht_value* data, const char* user_type) {
+    (*reinterpret_cast<ValueSp*>(data))->user_type = user_type;
+}
+
 dht_value* dht_value_new(const uint8_t* data, size_t size) {
    return reinterpret_cast<dht_value*>(new ValueSp(std::make_shared<dht::Value>(data, size)));
 }

+dht_value* dht_value_new_from_string(const char* str) {
+    ValueSp value = std::make_shared<dht::Value>((const uint8_t*)str, strlen(str));
+    value->user_type = "text/plain";
+    return reinterpret_cast<dht_value*>(new ValueSp(std::move(value)));
+}
+
 dht_value* dht_value_ref(const dht_value* v) {
    return reinterpret_cast<dht_value*>(new ValueSp(*reinterpret_cast<const ValueSp*>(v)));
 }
@@ -144,9 +174,13 @@ bool dht_publickey_check_signature(const dht_publickey* pk, const char* data, si

 dht_blob* dht_publickey_encrypt(const dht_publickey* pk, const char* data, size_t data_size) {
    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
-    auto rdata = new dht::Blob;
-    *rdata = pkey->encrypt((const uint8_t*)data, data_size);
-    return (dht_blob*)rdata;
+    try {
+        auto rdata = std::make_unique<dht::Blob>();
+        *rdata = pkey->encrypt((const uint8_t*)data, data_size);
+        return (dht_blob*)rdata.release();
+    } catch (...) {
+        return nullptr;
+    }
 }

 // dht::crypto::PrivateKey
@@ -173,7 +207,18 @@ int dht_privatekey_export(const dht_privatekey* k, char* out, size_t* out_size,

 dht_publickey* dht_privatekey_get_publickey(const dht_privatekey* k) {
    const auto& key = *reinterpret_cast<const PrivkeySp*>(k);
-    return reinterpret_cast<dht_publickey*>(new PubkeySp(std::make_shared<dht::crypto::PublicKey>(key->getPublicKey())));
+    return reinterpret_cast<dht_publickey*>(new PubkeySp(key->getSharedPublicKey()));
+}
+
+dht_blob* dht_privatekey_decrypt(const dht_privatekey* k, const char* data, size_t data_size) {
+    const auto& key = *reinterpret_cast<const PrivkeySp*>(k);
+    try {
+        auto rdata = std::make_unique<dht::Blob>();
+        *rdata = key->decrypt((const uint8_t*)data, data_size);
+        return (dht_blob*)rdata.release();
+    } catch (...) {
+        return nullptr;
+    }
 }

 void dht_privatekey_delete(dht_privatekey* pk) {
@@ -247,7 +292,7 @@ void dht_runner_config_default(dht_runner_config* config) {
 }

 // dht::DhtRunner
-dht_runner* dht_runner_new() {
+dht_runner* dht_runner_new(void) {
    return reinterpret_cast<dht_runner*>(new dht::DhtRunner);
 }

@@ -255,39 +300,55 @@ void dht_runner_delete(dht_runner* runner) {
    delete reinterpret_cast<dht::DhtRunner*>(runner);
 }

-void dht_runner_run(dht_runner* r, in_port_t port) {
+int dht_runner_run(dht_runner* r, in_port_t port) {
    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
-    runner->run(port, {}, true);
+    try {
+        runner->run(port, {}, true);
+    } catch(...) {
+        return ENOTCONN;
+    }
+    return 0;
 }

-void dht_runner_run_config(dht_runner* r, in_port_t port, const dht_runner_config* conf) {
+int dht_runner_run_config(dht_runner* r, in_port_t port, const dht_runner_config* conf) {
    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
-    dht::DhtRunner::Config config;
-    config.dht_config.node_config.is_bootstrap = conf->dht_config.node_config.is_bootstrap;
-    config.dht_config.node_config.maintain_storage = conf->dht_config.node_config.maintain_storage;
-    config.dht_config.node_config.node_id = *reinterpret_cast<const dht::InfoHash*>(&conf->dht_config.node_config.node_id);
-    config.dht_config.node_config.network = conf->dht_config.node_config.network;
-    config.dht_config.node_config.persist_path = conf->dht_config.node_config.persist_path
-        ? std::string(conf->dht_config.node_config.persist_path) : std::string{};
+    try {
+        dht::DhtRunner::Config config;
+        config.dht_config.node_config.is_bootstrap = conf->dht_config.node_config.is_bootstrap;
+        config.dht_config.node_config.maintain_storage = conf->dht_config.node_config.maintain_storage;
+        config.dht_config.node_config.node_id = *reinterpret_cast<const dht::InfoHash*>(&conf->dht_config.node_config.node_id);
+        config.dht_config.node_config.network = conf->dht_config.node_config.network;
+        config.dht_config.node_config.persist_path = conf->dht_config.node_config.persist_path
+            ? std::string(conf->dht_config.node_config.persist_path) : std::string{};

-    if (conf->dht_config.id.privatekey)
-        config.dht_config.id.first = *reinterpret_cast<const PrivkeySp*>(conf->dht_config.id.privatekey);
+        if (conf->dht_config.id.privatekey)
+            config.dht_config.id.first = *reinterpret_cast<const PrivkeySp*>(conf->dht_config.id.privatekey);

-    if (conf->dht_config.id.certificate)
-        config.dht_config.id.second = *reinterpret_cast<const CertSp*>(conf->dht_config.id.certificate);
+        if (conf->dht_config.id.certificate)
+            config.dht_config.id.second = *reinterpret_cast<const CertSp*>(conf->dht_config.id.certificate);

-    config.threaded = conf->threaded;
-    config.proxy_server = conf->proxy_server ? std::string(conf->proxy_server) : std::string{};
-    config.push_node_id = conf->push_node_id ? std::string(conf->push_node_id) : std::string{};
-    config.push_token = conf->push_token ? std::string(conf->push_token) : std::string{};
-    config.peer_discovery = conf->peer_discovery;
-    config.peer_publish = conf->peer_publish;
-    runner->run(port, config);
+        config.threaded = conf->threaded;
+        config.proxy_server = conf->proxy_server ? std::string(conf->proxy_server) : std::string{};
+        config.push_node_id = conf->push_node_id ? std::string(conf->push_node_id) : std::string{};
+        config.push_token = conf->push_token ? std::string(conf->push_token) : std::string{};
+        config.peer_discovery = conf->peer_discovery;
+        config.peer_publish = conf->peer_publish;
+        runner->run(port, config);
+    } catch(...) {
+        return ENOTCONN;
+    }
+    return 0;
 }

-void dht_runner_ping(dht_runner* r, struct sockaddr* addr, socklen_t addr_len) {
+void dht_runner_ping(dht_runner* r, struct sockaddr* addr, socklen_t addr_len, dht_done_cb done_cb, void* cb_user_data) {
    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
-    runner->bootstrap(dht::SockAddr(addr, addr_len));
+    if (done_cb) {
+        runner->bootstrap(dht::SockAddr(addr, addr_len), [done_cb, cb_user_data](bool ok){
+            done_cb(ok, cb_user_data);
+        });
+    } else {
+        runner->bootstrap(dht::SockAddr(addr, addr_len));
+    }
 }

 void dht_runner_bootstrap(dht_runner* r, const char* host, const char* service) {
@@ -326,8 +387,11 @@ dht_op_token* dht_runner_listen(dht_runner* r, const dht_infohash* h, dht_value_
    auto runner = reinterpret_cast<dht::DhtRunner*>(r);
    auto hash = reinterpret_cast<const dht::InfoHash*>(h);
    auto fret = new std::future<size_t>;
-    auto guard = done_cb ? std::make_shared<ScopeGuardCb>(done_cb, cb_user_data) : std::shared_ptr<ScopeGuardCb>{};
-    *fret = runner->listen(*hash, [cb,cb_user_data, guard](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
+    *fret = runner->listen(*hash, [
+        cb,
+        cb_user_data,
+        guard = done_cb ? std::make_shared<ScopeGuardCb>(done_cb, cb_user_data) : std::shared_ptr<ScopeGuardCb>{}
+    ](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
        for (const auto& value : values) {
            if (not cb(reinterpret_cast<const dht_value*>(&value), expired, cb_user_data))
                return false;
@@ -393,6 +457,17 @@ void dht_runner_shutdown(dht_runner* r, dht_shutdown_cb done_cb, void* cb_user_d
    });
 }

+bool dht_runner_is_running(const dht_runner* r) {
+    if (not r) return false;
+    auto runner = reinterpret_cast<const dht::DhtRunner*>(r);
+    return runner->isRunning();
+}
+
+in_port_t dht_runner_get_bound_port(const dht_runner* r, sa_family_t af) {
+    auto runner = reinterpret_cast<const dht::DhtRunner*>(r);
+    return runner->getBoundPort(af);
+}
+
 dht_infohash dht_runner_get_node_id(const dht_runner* r) {
    auto runner = reinterpret_cast<const dht::DhtRunner*>(r);
    dht_infohash ret;
@@ -414,9 +489,9 @@ struct sockaddr** dht_runner_get_public_address(const dht_runner* r) {
        return nullptr;
    auto ret = (struct sockaddr**)malloc(sizeof(struct sockaddr*) * (addrs.size() + 1));
    for (size_t i=0; i<addrs.size(); i++) {
-        if (auto len = addrs[i].getLength()) {
-            ret[i] = (struct sockaddr*)malloc(len);
-            memcpy((struct sockaddr*)ret[i], addrs[i].get(), len);
+        if (const auto& addr = addrs[i]) {
+            ret[i] = (struct sockaddr*)malloc(addr.getLength());
+            memcpy((struct sockaddr*)ret[i], addr.get(), addr.getLength());
        } else {
            ret[i] = nullptr;
        }
@@ -1,3 +1,21 @@
+/*
+ *  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 __cplusplus
@@ -58,6 +76,7 @@ OPENDHT_C_PUBLIC dht_privatekey* dht_privatekey_generate(unsigned key_length_bit
 OPENDHT_C_PUBLIC dht_privatekey* dht_privatekey_import(const uint8_t* dat, size_t dat_size, const char* password);
 OPENDHT_C_PUBLIC int dht_privatekey_export(const dht_privatekey*, char* out, size_t* out_size, const char* password);
 OPENDHT_C_PUBLIC dht_publickey* dht_privatekey_get_publickey(const dht_privatekey*);
+OPENDHT_C_PUBLIC dht_blob* dht_privatekey_decrypt(const dht_privatekey*, const char* data, size_t data_size);
 OPENDHT_C_PUBLIC void dht_privatekey_delete(dht_privatekey*);

 // dht::crypto::Certificate
@@ -82,6 +101,7 @@ struct OPENDHT_C_PUBLIC dht_value;
 typedef struct dht_value dht_value;
 typedef uint64_t dht_value_id;
 OPENDHT_C_PUBLIC dht_value* dht_value_new(const uint8_t* data, size_t size);
+OPENDHT_C_PUBLIC dht_value* dht_value_new_from_string(const char* str);
 OPENDHT_C_PUBLIC dht_value* dht_value_ref(const dht_value*);
 OPENDHT_C_PUBLIC void dht_value_unref(dht_value*);
 OPENDHT_C_PUBLIC dht_data_view dht_value_get_data(const dht_value* data);
@@ -89,6 +109,7 @@ OPENDHT_C_PUBLIC dht_value_id dht_value_get_id(const dht_value* data);
 OPENDHT_C_PUBLIC dht_publickey* dht_value_get_owner(const dht_value* data);
 OPENDHT_C_PUBLIC dht_infohash dht_value_get_recipient(const dht_value* data);
 OPENDHT_C_PUBLIC const char* dht_value_get_user_type(const dht_value* data);
+OPENDHT_C_PUBLIC void dht_value_set_user_type(dht_value* data, const char* user_type);

 // callbacks
 typedef bool (*dht_get_cb)(const dht_value* value, void* user_data);
@@ -133,11 +154,13 @@ OPENDHT_C_PUBLIC void dht_runner_config_default(dht_runner_config* config);
 // dht::DhtRunner
 struct OPENDHT_C_PUBLIC dht_runner;
 typedef struct dht_runner dht_runner;
-OPENDHT_C_PUBLIC dht_runner* dht_runner_new();
+OPENDHT_C_PUBLIC dht_runner* dht_runner_new(void);
 OPENDHT_C_PUBLIC void dht_runner_delete(dht_runner* runner);
-OPENDHT_C_PUBLIC void dht_runner_run(dht_runner* runner, in_port_t port);
-OPENDHT_C_PUBLIC void dht_runner_run_config(dht_runner* runner, in_port_t port, const dht_runner_config* config);
-OPENDHT_C_PUBLIC void dht_runner_ping(dht_runner* runner, struct sockaddr* addr, socklen_t addr_len);
+/* Returns 0 on success, standard error code on failure */
+OPENDHT_C_PUBLIC int dht_runner_run(dht_runner* runner, in_port_t port);
+/* Returns 0 on success, standard error code on failure */
+OPENDHT_C_PUBLIC int dht_runner_run_config(dht_runner* runner, in_port_t port, const dht_runner_config* config);
+OPENDHT_C_PUBLIC void dht_runner_ping(dht_runner* runner, struct sockaddr* addr, socklen_t addr_len, dht_done_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC void dht_runner_bootstrap(dht_runner* runner, const char* host, const char* service);
 OPENDHT_C_PUBLIC void dht_runner_get(dht_runner* runner, const dht_infohash* hash, dht_get_cb cb, dht_done_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC dht_op_token* dht_runner_listen(dht_runner* runner, const dht_infohash* hash, dht_value_cb cb, dht_shutdown_cb done_cb, void* cb_user_data);
@@ -149,6 +172,9 @@ OPENDHT_C_PUBLIC void dht_runner_cancel_put(dht_runner* runner, const dht_infoha
 OPENDHT_C_PUBLIC void dht_runner_shutdown(dht_runner* runner, dht_shutdown_cb done_cb, void* cb_user_data);
 OPENDHT_C_PUBLIC dht_infohash dht_runner_get_node_id(const dht_runner* runner);
 OPENDHT_C_PUBLIC dht_infohash dht_runner_get_id(const dht_runner* runner);
+OPENDHT_C_PUBLIC bool dht_runner_is_running(const dht_runner* runner);
+OPENDHT_C_PUBLIC in_port_t dht_runner_get_bound_port(const dht_runner* runner, sa_family_t af);
+/** Returns null-terminated array that must be freed after use as well as each element */
 OPENDHT_C_PUBLIC struct sockaddr** dht_runner_get_public_address(const dht_runner* runner);

 #ifdef __cplusplus
@@ -1,95 +1,100 @@
-# University of Illinois/NCSA
-# Open Source License
-#
-# Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign.
-# All rights reserved.
-#
-# Developed by:
-#
-#     LLVM Team
-#
-#     University of Illinois at Urbana-Champaign
-#
-#     http://llvm.org
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of
-# this software and associated documentation files (the "Software"), to deal with
-# the Software without restriction, including without limitation the rights to
-# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-# of the Software, and to permit persons to whom the Software is furnished to do
-# so, subject to the following conditions:
-#
-#     * Redistributions of source code must retain the above copyright notice,
-#       this list of conditions and the following disclaimers.
-#
-#     * Redistributions in binary form must reproduce the above copyright notice,
-#       this list of conditions and the following disclaimers in the
-#       documentation and/or other materials provided with the distribution.
-#
-#     * Neither the names of the LLVM Team, University of Illinois at
-#       Urbana-Champaign, nor the names of its contributors may be used to
-#       endorse or promote products derived from this Software without specific
-#       prior written permission.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-# SOFTWARE.
+# atomic builtins are required for threading support.

-include(CheckCXXSourceCompiles)
-include(CheckLibraryExists)
+INCLUDE(CheckCXXSourceCompiles)
+INCLUDE(CheckLibraryExists)

 # Sometimes linking against libatomic is required for atomic ops, if
 # the platform doesn't support lock-free atomics.

 function(check_working_cxx_atomics varname)
  set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-  get_directory_property(compile_options COMPILE_OPTIONS)
-  set(CMAKE_REQUIRED_FLAGS ${compile_options})
+  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11")
  CHECK_CXX_SOURCE_COMPILES("
 #include <atomic>
-#include <cstdint>
-std::atomic<int64_t> v1;
-std::atomic<int64_t> v2;
-int main(int, char**) {
-  return v1 + v2;
-}" ${varname})
+std::atomic<int> x;
+std::atomic<short> y;
+std::atomic<char> z;
+int main() {
+  ++z;
+  ++y;
+  return ++x;
+}
+" ${varname})
  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
 endfunction(check_working_cxx_atomics)

+function(check_working_cxx_atomics64 varname)
+  set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+  set(CMAKE_REQUIRED_FLAGS "-std=c++11 ${CMAKE_REQUIRED_FLAGS}")
+  CHECK_CXX_SOURCE_COMPILES("
+#include <atomic>
+#include <cstdint>
+std::atomic<uint64_t> x (0);
+int main() {
+  uint64_t i = x.load(std::memory_order_relaxed);
+  return 0;
+}
+" ${varname})
+  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction(check_working_cxx_atomics64)

-if(NOT DEFINED PROXYGEN_COMPILER_IS_GCC_COMPATIBLE)
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(PROXYGEN_COMPILER_IS_GCC_COMPATIBLE ON)
-  elseif(MSVC)
-    set(PROXYGEN_COMPILER_IS_GCC_COMPATIBLE OFF)
-  elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(PROXYGEN_COMPILER_IS_GCC_COMPATIBLE ON)
-  elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
-    set(PROXYGEN_COMPILER_IS_GCC_COMPATIBLE ON)
-  endif()
-endif()

 # This isn't necessary on MSVC, so avoid command-line switch annoyance
 # by only running on GCC-like hosts.
-if(PROXYGEN_COMPILER_IS_GCC_COMPATIBLE)
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
  # First check if atomics work without the library.
  check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
  # If not, check if the library exists, and atomics work with it.
  if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
-    check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
-    if(HAVE_LIBATOMIC)
-      list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
-      check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
-      if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
-	message(FATAL_ERROR "Host compiler must support std::atomic!")
-      endif()
-      list(APPEND CMAKE_CXX_STANDARD_LIBRARIES -latomic)
-    else()
-      message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+    check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
+    if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
+      message(FATAL_ERROR "Host compiler must support std::atomic!")
    endif()
  endif()
 endif()
+
+# Check for 64 bit atomic operations.
+if(MSVC)
+  set(HAVE_CXX_ATOMICS64_WITHOUT_LIB True)
+else()
+  check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+endif()
+
+# If not, check if the library exists, and atomics work with it.
+if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+  list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+  check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
+  if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
+    message(FATAL_ERROR "Host compiler must support 64-bit std::atomic!")
+  endif()
+endif()
+
+## TODO: This define is only used for the legacy atomic operations in
+## llvm's Atomic.h, which should be replaced.  Other code simply
+## assumes C++11 <atomic> works.
+CHECK_CXX_SOURCE_COMPILES("
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+int main() {
+#ifdef _MSC_VER
+        volatile LONG val = 1;
+        MemoryBarrier();
+        InterlockedCompareExchange(&val, 0, 1);
+        InterlockedIncrement(&val);
+        InterlockedDecrement(&val);
+#else
+        volatile unsigned long val = 1;
+        __sync_synchronize();
+        __sync_val_compare_and_swap(&val, 1, 0);
+        __sync_add_and_fetch(&val, 1);
+        __sync_sub_and_fetch(&val, 1);
+#endif
+        return 0;
+      }
+" LLVM_HAS_ATOMICS)
+
+if( NOT LLVM_HAS_ATOMICS )
+  message(STATUS "Warning: LLVM will be built thread-unsafe because atomic builtins are missing")
+endif()
@@ -1,64 +0,0 @@
-# - Try to find msgpack
-# Once done this will define
-#  MSGPACK_FOUND - System has msgpack
-#  MSGPACK_INCLUDE_DIRS - The msgpack include directories
-#  MSGPACK_LIBRARIES - The libraries needed to use msgpack
-
-if(NOT MSGPACK_USE_BUNDLED)
-  find_package(PkgConfig)
-  if (PKG_CONFIG_FOUND)
-    pkg_search_module(PC_MSGPACK QUIET
-      msgpackc>=${Msgpack_FIND_VERSION}
-      msgpack>=${Msgpack_FIND_VERSION})
-  endif()
-else()
-  set(PC_MSGPACK_INCLUDEDIR)
-  set(PC_MSGPACK_INCLUDE_DIRS)
-  set(PC_MSGPACK_LIBDIR)
-  set(PC_MSGPACK_LIBRARY_DIRS)
-  set(LIMIT_SEARCH NO_DEFAULT_PATH)
-endif()
-
-set(MSGPACK_DEFINITIONS ${PC_MSGPACK_CFLAGS_OTHER})
-
-find_path(MSGPACK_INCLUDE_DIR msgpack/version_master.h
-  HINTS ${PC_MSGPACK_INCLUDEDIR} ${PC_MSGPACK_INCLUDE_DIRS}
-  ${LIMIT_SEARCH})
-
-if(MSGPACK_INCLUDE_DIR)
-  file(READ ${MSGPACK_INCLUDE_DIR}/msgpack/version_master.h msgpack_version_h)
-  string(REGEX REPLACE ".*MSGPACK_VERSION_MAJOR +([0-9]+).*" "\\1" MSGPACK_VERSION_MAJOR "${msgpack_version_h}")
-  string(REGEX REPLACE ".*MSGPACK_VERSION_MINOR +([0-9]+).*" "\\1" MSGPACK_VERSION_MINOR "${msgpack_version_h}")
-  string(REGEX REPLACE ".*MSGPACK_VERSION_REVISION +([0-9]+).*" "\\1" MSGPACK_VERSION_REVISION "${msgpack_version_h}")
-  set(MSGPACK_VERSION_STRING "${MSGPACK_VERSION_MAJOR}.${MSGPACK_VERSION_MINOR}.${MSGPACK_VERSION_REVISION}")
-else()
-  set(MSGPACK_VERSION_STRING)
-endif()
-
-# If we're asked to use static linkage, add libmsgpack{,c}.a as a preferred library name.
-if(MSGPACK_USE_STATIC)
-  list(APPEND MSGPACK_NAMES
-    "${CMAKE_STATIC_LIBRARY_PREFIX}msgpackc${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    "${CMAKE_STATIC_LIBRARY_PREFIX}msgpack${CMAKE_STATIC_LIBRARY_SUFFIX}")
-endif()
-
-list(APPEND MSGPACK_NAMES msgpackc msgpack)
-
-find_library(MSGPACK_LIBRARY NAMES ${MSGPACK_NAMES}
-  # Check each directory for all names to avoid using headers/libraries from
-  # different places.
-  NAMES_PER_DIR
-  HINTS ${PC_MSGPACK_LIBDIR} ${PC_MSGPACK_LIBRARY_DIRS}
-  ${LIMIT_SEARCH})
-
-mark_as_advanced(MSGPACK_INCLUDE_DIR MSGPACK_LIBRARY)
-
-set(MSGPACK_LIBRARIES ${MSGPACK_LIBRARY})
-set(MSGPACK_INCLUDE_DIRS ${MSGPACK_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set MSGPACK_FOUND to TRUE
-# if all listed variables are TRUE
-find_package_handle_standard_args(Msgpack
-  REQUIRED_VARS MSGPACK_LIBRARY MSGPACK_INCLUDE_DIR
-  VERSION_VAR MSGPACK_VERSION_STRING)
@@ -1,6 +1,6 @@
 dnl define macros
 m4_define([opendht_major_version], 2)
-m4_define([opendht_minor_version], 2)
+m4_define([opendht_minor_version], 4)
 m4_define([opendht_patch_version], 0)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])
@@ -102,7 +102,7 @@ AS_IF([test "x$SYS" = "xandroid"],
 LT_INIT()
 LT_LANG(C++)

-AX_CXX_COMPILE_STDCXX(14,[noext],[mandatory])
+AX_CXX_COMPILE_STDCXX(17,[noext],[mandatory])

 PKG_PROG_PKG_CONFIG()

@@ -132,6 +132,8 @@ AM_CONDITIONAL(PROXY_CLIENT_OR_SERVER, test x$proxy_client == xyes || test x$pro
 PKG_CHECK_MODULES([Nettle], [nettle >= 2.4])
 PKG_CHECK_MODULES([GnuTLS], [gnutls >= 3.3])
 PKG_CHECK_MODULES([MsgPack], [msgpack >= 1.2])
+PKG_CHECK_MODULES([Argon2], [libargon2])
+AC_SUBST(argon2_lib, [", libargon2"])

 AC_ARG_WITH([jsoncpp], AS_HELP_STRING([--without-jsoncpp], [Build without JsonCpp support]))
 AS_IF([test "x$with_jsoncpp" != "xno"],
@@ -157,14 +159,6 @@ AS_IF([test "x$have_openssl" = "xyes"], [
    AC_MSG_NOTICE([Not using OpenSSL])
 ])

-AC_ARG_WITH([http_parser_fork], AS_HELP_STRING([--with-http-parser-fork], [Build with http_parser fork to support old API]))
-AS_IF([test "x$with_http_parser_fork" = "xyes"],[
-    AC_MSG_NOTICE([Using http_parser fork])
-    AC_DEFINE([OPENDHT_PROXY_HTTP_PARSER_FORK], [], [Define if using http parser fork])
-], [
-    AC_MSG_NOTICE([Not using http_parser fork])
-])
-
 AM_COND_IF([PROXY_CLIENT_OR_SERVER], [
    AC_CHECK_HEADERS([asio.hpp], exit,, AC_MSG_ERROR([Missing Asio headers files]))
    CXXFLAGS="${CXXFLAGS} -DASIO_STANDALONE"
@@ -181,28 +175,7 @@ AM_COND_IF([PROXY_CLIENT_OR_SERVER], [
    AS_IF([test "x$http_parser_headers" != "xyes"], AC_MSG_ERROR([Missing HttpParser headers files]))
 ])

-CXXFLAGS="${CXXFLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT"
-
-dnl Check for Argon2
-AC_ARG_WITH([argon2], AS_HELP_STRING([--without-argon2], [Use included Argon2]))
-AS_IF([test "x$with_argon2" != "xno"],
-			[PKG_CHECK_MODULES([Argon2], [libargon2], [have_argon2=yes], [have_argon2=no])],
-			[have_argon2=no])
-AS_IF([test "x$have_argon2" = "xyes"], [
-  AC_MSG_NOTICE([Using system Argon2])
-  AC_SUBST(argon2_lib, [", libargon2"])
-], [
-		AS_IF([test "x$with_argon2" = "xyes"], [
-				AC_MSG_ERROR([Argon2 requested but not found])
-		],[
-				AC_MSG_NOTICE([Using included Argon2])
-				AC_SUBST(Argon2_CFLAGS, "-I\${top_srcdir}/argon2/src -I\${top_srcdir}/argon2/include")
-				AC_SUBST(Argon2_LIBS, "libargon2.la")
-				AC_SUBST(Argon2_LDFLAGS, "-L\${abs_top_srcdir}/argon2/src/.libs")
-		])
-])
-
-AM_CONDITIONAL([WITH_INCLUDED_ARGON2], [test "x$have_argon2" = "xno"])
+CXXFLAGS="${CXXFLAGS} -DMSGPACK_NO_BOOST -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT"

 AC_ARG_ENABLE([tools], AS_HELP_STRING([--disable-tools],[Disable tools (CLI DHT node)]),,build_tools=yes)
 AM_CONDITIONAL(ENABLE_TOOLS, test x$build_tools == xyes)
@@ -1,6 +1,16 @@
-FROM aberaud/opendht-deps
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+FROM ghcr.io/savoirfairelinux/opendht/opendht-deps:latest
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
+
 RUN git clone https://github.com/savoirfairelinux/opendht.git \
 	&& cd opendht && mkdir build && cd build \
-	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_LTO=On -DOPENDHT_PROXY_SERVER=On -DOPENDHT_PROXY_CLIENT=On && make -j8 && make install \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
+				-DOPENDHT_C=On \
+				-DOPENDHT_PEER_DISCOVERY=On \
+				-DOPENDHT_PYTHON=On \
+				-DOPENDHT_TOOLS=On \
+				-DOPENDHT_PROXY_SERVER=On \
+				-DOPENDHT_PROXY_CLIENT=On \
+	&& make -j8 && make install \
 	&& cd ../.. && rm -rf opendht
@@ -1,13 +1,16 @@
-FROM docker.pkg.github.com/savoirfairelinux/opendht/opendht-deps-bionic:2.1.3
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-bionic:latest
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht

 RUN git clone https://github.com/savoirfairelinux/opendht.git \
 	&& cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
-		-DOPENDHT_PROXY_CLIENT=On \
-		-DOPENDHT_PROXY_SERVER=On \
-		-DOPENDHT_C=On \
-		-DOPENDHT_PYTHON=On \
-		-DOPENDHT_LTO=On \
-		&& make -j8 && make install \
+				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
+				-DOPENDHT_C=On \
+				-DOPENDHT_PEER_DISCOVERY=On \
+				-DOPENDHT_PYTHON=On \
+				-DOPENDHT_TOOLS=On \
+				-DOPENDHT_PROXY_SERVER=On \
+				-DOPENDHT_PROXY_CLIENT=On \
+	&& make -j8 && make install \
 	&& cd ../.. && rm -rf opendht
@@ -1,5 +1,6 @@
 FROM ubuntu:20.04
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht

 RUN apt-get update && apt-get install -y \
        dialog apt-utils \
@@ -13,13 +14,13 @@ RUN apt-get update && apt-get install -y \
        libncurses5-dev libreadline-dev nettle-dev libcppunit-dev \
        libgnutls28-dev libuv1-dev libjsoncpp-dev libargon2-dev \
        libssl-dev libfmt-dev libhttp-parser-dev libasio-dev libmsgpack-dev \
-    && apt-get clean
+    && apt-get clean && rm -rf /var/lib/apt/lists/* /var/cache/apt/*

 RUN echo "*** Downloading RESTinio ***" \
    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/2224ffedef52cb2b74645d63d871d61dbd0f165e.tar.gz \
-    && ls -l && tar -xzf 2224ffedef52cb2b74645d63d871d61dbd0f165e.tar.gz \
-    && cd restinio-2224ffedef52cb2b74645d63d871d61dbd0f165e/dev \
+    && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+    && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+    && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/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 . \
@@ -1,14 +1,16 @@
 FROM ubuntu:18.04
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht

 RUN echo "APT::Acquire::Retries \"3\";" > /etc/apt/apt.conf.d/80-retries
 RUN apt-get update && apt-get install -y \
        apt-transport-https build-essential pkg-config git wget libncurses5-dev libreadline-dev nettle-dev \
        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
-        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev libssl-dev \
-    && apt-get clean
+        libargon2-0-dev \
+        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev libssl-dev python3-pip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/* /var/cache/apt/*

-RUN apt-get update && apt-get install -y python3-pip && pip3 install --upgrade cmake
+RUN pip3 install --upgrade cmake

 # libasio-dev (1.10) is too old
 RUN echo "** Building a recent version of asio ***" \
@@ -1,26 +1,29 @@
 FROM ubuntu:20.04
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
+
 RUN apt-get update && apt-get install -y \
        dialog apt-utils \
    && apt-get clean \
    && echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections

 RUN apt-get update \
-    && apt-get install -y llvm llvm-dev clang make cmake pkg-config git wget libncurses5-dev libreadline-dev \
+    && apt-get install -y llvm llvm-dev lldb clang gdb make cmake pkg-config git wget libncurses5-dev libreadline-dev \
       nettle-dev libgnutls28-dev libuv1-dev libmsgpack-dev libjsoncpp-dev cython3 python3-dev \
       python3-setuptools libcppunit-dev python3-pip \
       autotools-dev autoconf libssl-dev libargon2-dev \
       libfmt-dev libhttp-parser-dev libasio-dev \
-    && apt-get remove -y gcc g++ && apt-get autoremove -y && apt-get clean
+    && apt-get remove -y gcc g++ && apt-get autoremove -y \
+    && apt-get clean && rm -rf /var/lib/apt/lists/* /var/cache/apt/*

 ENV CC cc
 ENV CXX c++

 RUN echo "*** Downloading RESTinio ***" \
    && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/2224ffedef52cb2b74645d63d871d61dbd0f165e.tar.gz \
-    && ls -l && tar -xzf 2224ffedef52cb2b74645d63d871d61dbd0f165e.tar.gz \
-    && cd restinio-2224ffedef52cb2b74645d63d871d61dbd0f165e/dev \
+    && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+    && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
+    && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/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 . \
@@ -1,6 +1,16 @@
-FROM aberaud/opendht-deps-llvm
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-llvm:latest
+LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
+LABEL org.opencontainers.image.source https://github.com/savoirfairelinux/opendht
+
 RUN git clone https://github.com/savoirfairelinux/opendht.git \
 	&& cd opendht && mkdir build && cd build \
-	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_LTO=On -DOPENDHT_PROXY_SERVER=On -DOPENDHT_PROXY_CLIENT=On && make -j8 && make install \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
+				-DOPENDHT_C=On \
+				-DOPENDHT_PEER_DISCOVERY=On \
+				-DOPENDHT_PYTHON=On \
+				-DOPENDHT_TOOLS=On \
+				-DOPENDHT_PROXY_SERVER=On \
+				-DOPENDHT_PROXY_CLIENT=On \
+	&& make -j8 && make install \
 	&& cd ../.. && rm -rf opendht
@@ -1,9 +0,0 @@
-FROM aberaud/opendht-deps-bionic
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
-
-RUN apt-get update && apt-get install -y python3-pip && pip3 install --upgrade cmake
-
-COPY . /root/opendht
-RUN cd /root/opendht && mkdir build && cd build \
-	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_C=On -DOPENDHT_LTO=On -DOPENDHT_TESTS=ON ..  \
-	&& make -j8 && ./opendht_unit_tests && make install
@@ -1,7 +0,0 @@
-FROM aberaud/opendht-deps-llvm
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
-
-COPY . /root/opendht
-RUN cd /root/opendht && mkdir build && cd build \
-	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_C=On -DOPENDHT_TESTS=ON .. \
-	&& make -j8 && ./opendht_unit_tests && make install
@@ -1,4 +0,0 @@
-FROM aberaud/opendht-deps
-MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
-
-COPY . /root/opendht
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
 *
@@ -164,7 +164,9 @@ struct OPENDHT_PUBLIC PrivateKey
    ~PrivateKey();
    explicit operator bool() const { return key; }

-    PublicKey getPublicKey() const;
+    const PublicKey& getPublicKey() const;
+    const std::shared_ptr<PublicKey>& getSharedPublicKey() const;
+
    int serialize(uint8_t* out, size_t* out_len, const std::string& password = {}) const;
    Blob serialize(const std::string& password = {}) const;

@@ -199,7 +201,7 @@ private:
    PrivateKey& operator=(const PrivateKey&) = delete;
    Blob decryptBloc(const uint8_t* src, size_t src_size) const;

-    //friend dht::crypto::Identity dht::crypto::generateIdentity(const std::string&, dht::crypto::Identity, unsigned key_length);
+    mutable std::shared_ptr<PublicKey> publicKey_ {};
 };

 class OPENDHT_PUBLIC RevocationList
@@ -539,8 +541,8 @@ struct OPENDHT_PUBLIC Certificate {
    void addRevocationList(RevocationList&&);
    void addRevocationList(std::shared_ptr<RevocationList>);

-    static Certificate generate(const PrivateKey& key, const std::string& name = "dhtnode", const Identity& ca = {}, bool is_ca = false);
-    static Certificate generate(const CertificateRequest& request, const Identity& ca);
+    static Certificate generate(const PrivateKey& key, const std::string& name = "dhtnode", const Identity& ca = {}, bool is_ca = false, int64_t validity = 0);
+    static Certificate generate(const CertificateRequest& request, const Identity& ca, int64_t validity = 0);

    gnutls_x509_crt_t getCopy() const {
        if (not cert)
@@ -590,12 +592,20 @@ struct OPENDHT_PUBLIC Certificate {
     */
    std::pair<std::string, Blob> generateOcspRequest(gnutls_x509_crt_t& issuer);

+    /**
+     * Change certificate's expiration
+     */
+    void setValidity(const Identity& ca, int64_t validity);
+    void setValidity(const PrivateKey& key, int64_t validity);
+
    gnutls_x509_crt_t cert {nullptr};
    std::shared_ptr<Certificate> issuer {};
    std::shared_ptr<OcspResponse> ocspResponse;
 private:
    Certificate(const Certificate&) = delete;
    Certificate& operator=(const Certificate&) = delete;
+    mutable InfoHash cachedId_ {};
+    mutable PkId cachedLongId_ {};

    struct crlNumberCmp {
        bool operator() (const std::shared_ptr<RevocationList>& lhs, const std::shared_ptr<RevocationList>& rhs) const {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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
@@ -66,8 +66,10 @@ private:

 public:
    virtual void unpackValue(const Value& v) override {
-        if (v.owner)
+        if (v.owner) {
+            owner = v.owner;
            from = v.owner->getId();
+        }
        BaseClass::unpackValue(v);
    }

@@ -75,6 +77,7 @@ public:
        return [](const Value& v){ return v.isSigned(); };
    }

+    Sp<crypto::PublicKey> owner;
    dht::InfoHash from;
 };

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -114,7 +114,7 @@ public:

    void addBootstrap(const std::string& host, const std::string& service) override {
        bootstrap_nodes.emplace_back(host, service);
-        onDisconnected();
+        startBootstrap();
    }

    void clearBootstrap() override {
@@ -356,6 +356,8 @@ private:

    static constexpr duration REANNOUNCE_MARGIN {std::chrono::seconds(10)};

+    static constexpr std::chrono::seconds BOOTSTRAP_PERIOD {10};
+
    static constexpr size_t TOKEN_SIZE {32};

    // internal structures
@@ -393,7 +395,7 @@ private:
    Kad dht6 {};

    std::vector<std::pair<std::string,std::string>> bootstrap_nodes {};
-    std::chrono::steady_clock::duration bootstrap_period {std::chrono::seconds(10)};
+    std::chrono::steady_clock::duration bootstrap_period {BOOTSTRAP_PERIOD};
    Sp<Scheduler::Job> bootstrapJob {};

    std::map<InfoHash, Storage> store;
@@ -480,6 +482,9 @@ private:
    void sendCachedPing(Bucket& b);
    bool bucketMaintenance(RoutingTable&);
    void dumpBucket(const Bucket& b, std::ostream& out) const;
+    void bootstrap();
+    void startBootstrap();
+    void stopBootstrap();

    // Nodes
    void onNewNode(const Sp<Node>& node, int confirm);
@@ -487,7 +492,6 @@ private:
    bool trySearchInsert(const Sp<Node>& node);

    // Searches
-
    inline SearchMap& searches(sa_family_t af) { return dht(af).searches; }
    inline const SearchMap& searches(sa_family_t af) const { return dht(af).searches; }

@@ -569,7 +573,8 @@ private:
     *
     * @param sr  The search to execute its operations.
     */
-    void searchStep(Sp<Search>);
+    void searchStep(std::weak_ptr<Search> ws);
+
    void searchSynchedNodeListen(const Sp<Search>&, SearchNode&);

    void dumpSearch(const Search& sr, std::ostream& out) const;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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>
@@ -337,6 +337,7 @@ private:
    NodeStats stats6_ {};
    SockAddr publicAddressV4_;
    SockAddr publicAddressV6_;
+    std::atomic_bool launchConnectedCbs_ {false};

    InfoHash myid {};

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -257,12 +257,23 @@ public:
    }
    void putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb={}, bool permanent = false);

+    void putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, std::shared_ptr<Value> value, DoneCallback cb={}, bool permanent = false);
+    void putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, std::shared_ptr<Value> value, DoneCallbackSimple cb, bool permanent = false) {
+        putEncrypted(hash, to, value, bindDoneCb(cb), permanent);
+    }
+
+    void putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, Value&& value, DoneCallback cb={}, bool permanent = false);
+    void putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, Value&& value, DoneCallbackSimple cb, bool permanent = false) {
+        putEncrypted(hash, to, std::forward<Value>(value), bindDoneCb(cb), permanent);
+    }
+
+
    /**
     * Insert known nodes to the routing table, without necessarly ping them.
     * Usefull to restart a node and get things running fast without putting load on the network.
     */
-    void bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple&& cb={});
-    void bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb={});
+    void bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple cb={});
+    void bootstrap(const SockAddr& addr, DoneCallbackSimple cb={});

    /**
     * Insert known nodes to the routing table, without necessarly ping them.
@@ -303,6 +314,7 @@ public:
     * Get the public key fingerprint if an identity is used with this node, 0 otherwise.
     */
    InfoHash getId() const;
+    std::shared_ptr<crypto::PublicKey> getPublicKey() const;

    /**
     * Get the ID of the DHT node.
@@ -444,8 +456,6 @@ public:
    void forwardAllMessages(bool forward);

 private:
-    static constexpr std::chrono::seconds BOOTSTRAP_PERIOD {10};
-
    enum class State {
        Idle,
        Running,
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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
@@ -375,15 +375,3 @@ private:
 } // namespace http
 } // namespace dht

-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-namespace restinio
-{
-/* Custom HTTP-methods for RESTinio > 0.5.0.
- * https://github.com/Stiffstream/restinio/issues/26
- */
-constexpr const restinio::http_method_id_t method_listen {HTTP_LISTEN, "LISTEN"};
-constexpr const restinio::http_method_id_t method_stats {HTTP_STATS, "STATS"};
-constexpr const restinio::http_method_id_t method_sign {HTTP_SIGN, "SIGN"};
-constexpr const restinio::http_method_id_t method_encrypt {HTTP_ENCRYPT, "ENCRYPT"};
-} // namespace restinio
-#endif
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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
@@ -40,10 +40,12 @@ typedef uint16_t in_port_t;
 #include <iomanip>
 #include <array>
 #include <vector>
+#include <string_view>
 #include <algorithm>
 #include <stdexcept>
 #include <sstream>
 #include <cstring>
+#include <cstddef>

 namespace dht {

@@ -65,10 +67,10 @@ public:
    typedef typename T::iterator iterator;
    typedef typename T::const_iterator const_iterator;

-    Hash () noexcept {
+    Hash() noexcept {
        data_.fill(0);
    }
-    Hash (const uint8_t* h, size_t data_len) {
+    Hash(const uint8_t* h, size_t data_len) {
        if (data_len < N)
            data_.fill(0);
        else
@@ -79,7 +81,12 @@ public:
     * hex must be at least 2.HASH_LEN characters long.
     * If too long, only the first 2.HASH_LEN characters are read.
     */
-    explicit Hash(const std::string& hex);
+    explicit Hash(std::string_view hex) {
+        if (hex.size() < 2*N)
+            data_.fill(0);
+        else
+            fromString(hex.data());
+    }

    Hash(const msgpack::object& o) {
        msgpack_unpack(o);
@@ -219,7 +226,7 @@ public:
        return v;
    }

-    static inline Hash get(const std::string& data) {
+    static inline Hash get(std::string_view data) {
        return get((const uint8_t*)data.data(), data.size());
    }

@@ -291,14 +298,6 @@ std::istream& operator>> (std::istream& s, Hash<N>& h)
    return s;
 }

-template <size_t N>
-Hash<N>::Hash(const std::string& hex) {
-    if (hex.size() < 2*N)
-        data_.fill(0);
-    else
-        fromString(hex.c_str());
-}
-
 template <size_t N>
 void
 Hash<N>::fromString(const char* in) {
@@ -342,7 +341,7 @@ Hash<N>::getRandom(Rd& rdev)
    return h;
 }

-struct HexMap : public std::array<std::array<char, 2>, 256> {
+struct alignas(std::max_align_t) HexMap : public std::array<std::array<char, 2>, 256> {
    HexMap() {
        for (size_t i=0; i<size(); i++) {
            auto& e = (*this)[i];
@@ -376,7 +375,7 @@ template <size_t N>
 const char*
 Hash<N>::to_c_str() const
 {
-    thread_local std::array<char, N*2+1> buf;
+    alignas(std::max_align_t) thread_local std::array<char, N*2+1> buf;
    for (size_t i=0; i<N; i++) {
        auto b = buf.data()+i*2;
        const auto& m = hex_map[data_[i]];
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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>
 *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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-2020 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-2020 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-2020 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>
 *
@@ -36,8 +36,9 @@ namespace dht {
 class Scheduler {
 public:
    struct Job {
-        Job(std::function<void()>&& f) : do_(std::move(f)) {}
+        Job(std::function<void()>&& f, time_point t) : do_(std::move(f)), t_(t) {}
        std::function<void()> do_;
+        const time_point t_;
        void cancel() { do_ = {}; }
    };

@@ -50,17 +51,12 @@ public:
     * @return pointer to the newly scheduled job.
     */
    Sp<Scheduler::Job> add(time_point t, std::function<void()>&& job_func) {
-        auto job = std::make_shared<Job>(std::move(job_func));
+        auto job = std::make_shared<Job>(std::move(job_func), t);
        if (t != time_point::max())
            timers.emplace(std::move(t), job);
        return job;
    }

-    void add(const Sp<Scheduler::Job>& job, time_point t) {
-        if (t != time_point::max())
-            timers.emplace(std::move(t), job);
-    }
-
    /**
     * Reschedules a job.
     *
@@ -68,16 +64,29 @@ public:
     * @param t  The time at which the job shall be rescheduled.
     */
    void edit(Sp<Scheduler::Job>& job, time_point t) {
-        if (not job) {
+        if (not job)
            return;
-        }
        // std::function move doesn't garantee to leave the object empty.
        // Force clearing old value.
        auto task = std::move(job->do_);
-        job->do_ = {};
+        cancel(job);
        job = add(t, std::move(task));
    }

+    bool cancel(Sp<Scheduler::Job>& job) {
+        if (job) {
+            job->cancel();
+            for (auto r = timers.equal_range(job->t_); r.first != r.second; ++r.first) {
+                if (r.first->second == job) {
+                    timers.erase(r.first);
+                    job.reset();
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
    /**
     * Runs the jobs to do up to now.
     *
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -61,6 +61,9 @@ public:
    PkId getLongId() const {
        return key_ ? key_->getPublicKey().getLongId() : PkId();
    }
+    Sp<crypto::PublicKey> getPublicKey() const {
+        return key_ ? key_->getSharedPublicKey() : Sp<crypto::PublicKey>{};
+    }

    ValueType secureType(ValueType&& type);

@@ -115,6 +118,10 @@ public:
    void putEncrypted(const InfoHash& hash, const InfoHash& to, Value&& v, DoneCallback callback, bool permanent = false) {
        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
    }
+    void putEncrypted(const InfoHash& hash, const crypto::PublicKey& to, Sp<Value> val, DoneCallback callback, bool permanent = false);
+    void putEncrypted(const InfoHash& hash, const crypto::PublicKey& to, Value&& v, DoneCallback callback, bool permanent = false) {
+        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
+    }

    /**
     * Take ownership of the value and sign it using our private key.
@@ -126,13 +133,13 @@ public:
    Value decrypt(const Value& v);

    void findCertificate(const InfoHash& node, const std::function<void(const Sp<crypto::Certificate>)>& cb);
-    void findPublicKey(const InfoHash& node, const std::function<void(const Sp<const crypto::PublicKey>)>& cb);
+    void findPublicKey(const InfoHash& node, const std::function<void(const Sp<crypto::PublicKey>)>& cb);

-    const Sp<crypto::Certificate> registerCertificate(const InfoHash& node, const Blob& cert);
+    Sp<crypto::Certificate> registerCertificate(const InfoHash& node, const Blob& cert);
    void registerCertificate(Sp<crypto::Certificate>& cert);

-    const Sp<crypto::Certificate> getCertificate(const InfoHash& node) const;
-    const Sp<const crypto::PublicKey> getPublicKey(const InfoHash& node) const;
+    Sp<crypto::Certificate> getCertificate(const InfoHash& node) const;
+    Sp<crypto::PublicKey> getPublicKey(const InfoHash& node) const;

    /**
     * Allows to set a custom callback called by the library to find a locally-stored certificate.
@@ -354,7 +361,7 @@ private:

    // our certificate cache
    std::map<InfoHash, Sp<crypto::Certificate>> nodesCertificates_ {};
-    std::map<InfoHash, Sp<const crypto::PublicKey>> nodesPubKeys_ {};
+    std::map<InfoHash, Sp<crypto::PublicKey>> nodesPubKeys_ {};

    std::atomic_bool forward_all_ {false};
    bool enableCache_ {false};
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -27,6 +27,8 @@
 #include <future>
 #include <functional>

+#include <ciso646> // fix windows compiler bug
+
 namespace dht {

 class OPENDHT_PUBLIC ThreadPool {
@@ -63,15 +65,14 @@ public:
    void join();

 private:
-    struct ThreadState;
-    std::queue<std::function<void()>> tasks_ {};
-    std::vector<std::unique_ptr<ThreadState>> threads_;
-    unsigned readyThreads_ {0};
    std::mutex lock_ {};
    std::condition_variable cv_ {};
+    std::queue<std::function<void()>> tasks_ {};
+    std::vector<std::unique_ptr<std::thread>> threads_;
+    unsigned readyThreads_ {0};
+    bool running_ {true};

    const unsigned maxThreads_;
-    bool running_ {true};
 };

 class OPENDHT_PUBLIC Executor : public std::enable_shared_from_this<Executor> {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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
@@ -178,8 +178,8 @@ msgpack::object* findMapValue(const msgpack::object& map, const char* key, size_
 inline msgpack::object* findMapValue(const msgpack::object& map, const char* key) {
    return findMapValue(map, key, strlen(key));
 }
-inline msgpack::object* findMapValue(const msgpack::object& map, const std::string& key) {
-    return findMapValue(map, key.c_str(), key.size());
+inline msgpack::object* findMapValue(const msgpack::object& map, std::string_view key) {
+    return findMapValue(map, key.data(), key.size());
 }

 } // namespace dht
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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,6 +27,7 @@
 #include <msgpack.hpp>

 #include <string>
+#include <string_view>
 #include <sstream>
 #include <bitset>
 #include <vector>
@@ -42,8 +43,9 @@
 #endif

 namespace dht {
+using namespace std::literals;

-static const std::string VALUE_KEY_ID("id");
+static constexpr auto VALUE_KEY_ID("id");
 static const std::string VALUE_KEY_DAT("dat");
 static const std::string VALUE_KEY_PRIO("p");
 static const std::string VALUE_KEY_SIGNATURE("sig");
@@ -117,7 +119,7 @@ struct OPENDHT_PUBLIC ValueType {

    Id id {0};
    std::string name {};
-    duration expiration {60 * 10};
+    duration expiration {std::chrono::minutes(10)};
    StorePolicy storePolicy {DEFAULT_STORE_POLICY};
    EditPolicy editPolicy {DEFAULT_EDIT_POLICY};
 };
@@ -269,8 +271,8 @@ struct OPENDHT_PUBLIC Value
        };
    }

-    static Filter UserTypeFilter(const std::string& ut) {
-        return [ut](const Value& v) {
+    static Filter UserTypeFilter(std::string ut) {
+        return [ut = std::move(ut)](const Value& v) {
            return v.user_type == ut;
        };
    }
@@ -356,7 +358,7 @@ struct OPENDHT_PUBLIC Value
    void sign(const crypto::PrivateKey& key) {
        if (isEncrypted())
            throw DhtException("Can't sign encrypted data.");
-        owner = std::make_shared<const crypto::PublicKey>(key.getPublicKey());
+        owner = key.getSharedPublicKey();
        signature = key.sign(getToSign());
    }

@@ -368,8 +370,8 @@ struct OPENDHT_PUBLIC Value
        return isSigned() and owner->checkSignature(getToSign(), signature);
    }

-    std::shared_ptr<const crypto::PublicKey> getOwner() const {
-        return std::static_pointer_cast<const crypto::PublicKey>(owner);
+    std::shared_ptr<crypto::PublicKey> getOwner() const {
+        return std::static_pointer_cast<crypto::PublicKey>(owner);
    }

    /**
@@ -594,7 +596,7 @@ struct OPENDHT_PUBLIC Value
    /**
     * Public key of the signer.
     */
-    std::shared_ptr<const crypto::PublicKey> owner {};
+    std::shared_ptr<crypto::PublicKey> owner {};

    /**
     * Hash of the recipient (optional).
@@ -659,7 +661,7 @@ struct OPENDHT_PUBLIC FieldValue
    FieldValue() {}
    FieldValue(Value::Field f, uint64_t int_value) : field(f), intValue(int_value) {}
    FieldValue(Value::Field f, InfoHash hash_value) : field(f), hashValue(hash_value) {}
-    FieldValue(Value::Field f, Blob blob_value) : field(f), blobValue(blob_value) {}
+    FieldValue(Value::Field f, Blob blob_value) : field(f), blobValue(std::move(blob_value)) {}

    bool operator==(const FieldValue& fd) const;

@@ -672,9 +674,9 @@ struct OPENDHT_PUBLIC FieldValue
    template <typename Packer>
    void msgpack_pack(Packer& p) const {
        p.pack_map(2);
-        p.pack(std::string("f")); p.pack(static_cast<uint8_t>(field));
+        p.pack("f"sv); p.pack(static_cast<uint8_t>(field));

-        p.pack(std::string("v"));
+        p.pack("v"sv);
        switch (field) {
            case Value::Field::Id:
            case Value::Field::ValueType:
@@ -696,12 +698,12 @@ struct OPENDHT_PUBLIC FieldValue
        hashValue = {};
        blobValue.clear();

-        if (auto f = findMapValue(msg, "f"))
+        if (auto f = findMapValue(msg, "f"sv))
            field = (Value::Field)f->as<unsigned>();
        else
            throw msgpack::type_error();

-        auto v = findMapValue(msg, "v");
+        auto v = findMapValue(msg, "v"sv);
        if (not v)
            throw msgpack::type_error();
        else
@@ -741,7 +743,7 @@ private:
 struct OPENDHT_PUBLIC Select
 {
    Select() { }
-    Select(const std::string& q_str);
+    Select(std::string_view q_str);

    bool isSatisfiedBy(const Select& os) const;

@@ -796,7 +798,7 @@ private:
 struct OPENDHT_PUBLIC Where
 {
    Where() { }
-    Where(const std::string& q_str);
+    Where(std::string_view q_str);

    bool isSatisfiedBy(const Where& where) const;

@@ -863,7 +865,7 @@ struct OPENDHT_PUBLIC Where
     *
     * @return the resulting Where instance.
     */
-    Where& userType(std::string user_type) {
+    Where& userType(std::string_view user_type) {
        FieldValue fv {Value::Field::UserType, Blob {user_type.begin(), user_type.end()}};
        if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
            filters_.emplace_back(std::move(fv));
@@ -936,11 +938,11 @@ struct OPENDHT_PUBLIC Query
     *  - $string$: a simple string WITHOUT SPACES.
     *  - $integer$: a simple integer.
     */
-    Query(std::string q_str) {
+    Query(std::string_view q_str) {
        auto pos_W = q_str.find("WHERE");
        auto pos_w = q_str.find("where");
-        auto pos = std::min(pos_W != std::string::npos ? pos_W : q_str.size(),
-                            pos_w != std::string::npos ? pos_w : q_str.size());
+        auto pos = std::min(pos_W != std::string_view::npos ? pos_W : q_str.size(),
+                            pos_w != std::string_view::npos ? pos_w : q_str.size());
        select = q_str.substr(0, pos);
        where = q_str.substr(pos, q_str.size()-pos);
    }
@@ -10,13 +10,13 @@
 #
 #   Check for baseline language coverage in the compiler for the specified
 #   version of the C++ standard.  If necessary, add switches to CXX and
-#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
-#   or '14' (for the C++14 standard).
+#   CXXCPP to enable support.  VERSION may be '11', '14', '17', or '20' for
+#   the respective C++ standard version.
 #
 #   The second argument, if specified, indicates whether you insist on an
 #   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
 #   -std=c++11).  If neither is specified, you get whatever works, with
-#   preference for an extended mode.
+#   preference for no added switch, and then for an extended mode.
 #
 #   The third argument, if specified 'mandatory' or if left unspecified,
 #   indicates that baseline support for the specified C++ standard is
@@ -35,13 +35,15 @@
 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
 #   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
 #   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
+#   Copyright (c) 2020 Jason Merrill <jason@redhat.com>
+#   Copyright (c) 2021 Jörn Heusipp <osmanx@problemloesungsmaschine.de>
 #
 #   Copying and distribution of this file, with or without modification, are
 #   permitted in any medium without royalty provided the copyright notice
 #   and this notice are preserved.  This file is offered as-is, without any
 #   warranty.

-#serial 11
+#serial 14

 dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
 dnl  (serial version number 13).
@@ -50,6 +52,7 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
+        [$1], [20], [ax_cxx_compile_alternatives="20"],
        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
  m4_if([$2], [], [],
        [$2], [ext], [],
@@ -62,6 +65,16 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
  AC_LANG_PUSH([C++])dnl
  ac_success=no

+  m4_if([$2], [], [dnl
+    AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+		   ax_cv_cxx_compile_cxx$1,
+      [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+        [ax_cv_cxx_compile_cxx$1=yes],
+        [ax_cv_cxx_compile_cxx$1=no])])
+    if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+      ac_success=yes
+    fi])
+
  m4_if([$2], [noext], [], [dnl
  if test x$ac_success = xno; then
    for alternative in ${ax_cxx_compile_alternatives}; do
@@ -140,7 +153,6 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 )

-
 dnl  Test body for checking C++14 support

 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
@@ -148,12 +160,24 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 )

+dnl  Test body for checking C++17 support
+
 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
 )

+dnl  Test body for checking C++20 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_20
+)
+
+
 dnl  Tests for new features in C++11

 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
@@ -949,3 +973,33 @@ namespace cxx17
 #endif  // __cplusplus < 201703L

 ]])
+
+
+dnl  Tests for new features in C++20
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_20], [[
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 202002L
+
+#error "This is not a C++20 compiler"
+
+#else
+
+#include <version>
+
+namespace cxx20
+{
+
+// As C++20 supports feature test macros in the standard, there is no
+// immediate need to actually test for feature availability on the
+// Autoconf side.
+
+}  // namespace cxx20
+
+#endif  // __cplusplus < 202002L
+
+]])
@@ -1,11 +1,11 @@
 # distutils: language = c++
-# distutils: extra_compile_args = -std=c++14
+# distutils: extra_compile_args = -std=c++17
 # distutils: include_dirs = ../../include
 # distutils: library_dirs = ../../src
 # distutils: libraries = opendht gnutls
 # cython: language_level=3
 #
-# Copyright (c) 2015-2019 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>
@@ -329,11 +329,11 @@ cdef class PrivateKey(_WithID):
    cdef shared_ptr[cpp.PrivateKey] _key
    def getId(self):
        h = InfoHash()
-        h._infohash = self._key.get().getPublicKey().getId()
+        h._infohash = self._key.get().getSharedPublicKey().get().getId()
        return h
    def getPublicKey(self):
        pk = PublicKey()
-        pk._key = self._key.get().getPublicKey()
+        pk._key = self._key.get().getSharedPublicKey()
        return pk
    def decrypt(self, bytes dat):
        cdef size_t d_len = len(dat)
@@ -358,17 +358,17 @@ cdef class PrivateKey(_WithID):
        return k

 cdef class PublicKey(_WithID):
-    cdef cpp.PublicKey _key
+    cdef cpp.shared_ptr[cpp.PublicKey] _key
    def getId(self):
        h = InfoHash()
-        h._infohash = self._key.getId()
+        h._infohash = self._key.get().getId()
        return h
    def encrypt(self, bytes dat):
        cdef size_t d_len = len(dat)
        cdef cpp.uint8_t* d_ptr = <cpp.uint8_t*>dat
        cdef cpp.Blob indat
        indat.assign(d_ptr, <cpp.uint8_t*>(d_ptr + d_len))
-        cdef cpp.Blob encrypted = self._key.encrypt(indat)
+        cdef cpp.Blob encrypted = self._key.get().encrypt(indat)
        cdef char* encrypted_c_str = <char *>encrypted.data()
        cdef Py_ssize_t length = encrypted.size()
        return encrypted_c_str[:length]
@@ -440,7 +440,7 @@ cdef class Identity(object):
    property publickey:
        def __get__(self):
            k = PublicKey()
-            k._key = self._id.first.get().getPublicKey()
+            k._key = self._id.first.get().getSharedPublicKey()
            return k
    property certificate:
        def __get__(self):
@@ -1,4 +1,4 @@
-# Copyright (c) 2015-2019 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>
 #
@@ -97,7 +97,7 @@ cdef extern from "opendht/crypto.h" namespace "dht::crypto":

    cdef cppclass PrivateKey:
        PrivateKey()
-        PublicKey getPublicKey() const
+        shared_ptr[PublicKey] getSharedPublicKey() const
        Blob decrypt(Blob data) const
        @staticmethod
        PrivateKey generate()
@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2020 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>
 #
@@ -50,8 +50,8 @@ setup(name="opendht",
          ["@CURRENT_SOURCE_DIR@/opendht.pyx"],
          include_dirs = ['@PROJECT_SOURCE_DIR@/include'],
          language="c++",
-          extra_compile_args=["-std=c++14"],
-          extra_link_args=["-std=c++14"],
+          extra_compile_args=["-std=c++17"],
+          extra_link_args=["-std=c++17"],
          libraries=["opendht"],
          library_dirs = ['@CURRENT_BINARY_DIR@', '@PROJECT_BINARY_DIR@']
      ))
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (C) 2014-2020 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-2019 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-2019 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-2019 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-2020 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-2019 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
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2019 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 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2019 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 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2019 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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
@@ -2,7 +2,7 @@ lib_LTLIBRARIES = libopendht.la

 libopendht_la_CPPFLAGS = @CPPFLAGS@ -I$(top_srcdir)/include/opendht @Argon2_CFLAGS@ @JsonCpp_CFLAGS@ @MsgPack_CFLAGS@ @OpenSSL_CFLAGS@ @Fmt_CFLAGS@
 libopendht_la_LIBADD   = @Argon2_LIBS@ @JsonCpp_LIBS@ @GnuTLS_LIBS@ @Nettle_LIBS@ @OpenSSL_LIBS@ @Fmt_LIBS@
-libopendht_la_LDFLAGS  = @LDFLAGS@ @Argon2_LDFLAGS@ -version-number @OPENDHT_MAJOR_VERSION@:@OPENDHT_MINOR_VERSION@:@OPENDHT_PATCH_VERSION@
+libopendht_la_LDFLAGS  = @LDFLAGS@ -version-number @OPENDHT_MAJOR_VERSION@:@OPENDHT_MINOR_VERSION@:@OPENDHT_PATCH_VERSION@
 libopendht_la_SOURCES  = \
        dht.cpp \
        storage.h \
@@ -87,30 +87,3 @@ endif

 clean-local:
 	rm -rf libargon2.la
-
-######################
-#  ARGON2 submodule  #
-######################
-
-if WITH_INCLUDED_ARGON2
-noinst_LTLIBRARIES         = libargon2.la
-libopendht_la_DEPENDENCIES = libargon2.la
-
-libargon2_la_CFLAGS  = -std=c89 -fPIC -pthread -O3 -Wall -I@top_builddir@/argon2/include -I@top_builddir@/argon2/src
-libargon2_la_SOURCES = \
-        @top_builddir@/argon2/src/argon2.c \
-        @top_builddir@/argon2/src/core.c \
-        @top_builddir@/argon2/src/blake2/blake2b.c \
-        @top_builddir@/argon2/src/thread.c \
-        @top_builddir@/argon2/src/ref.c \
-        @top_builddir@/argon2/src/encoding.c
-
-noinst_HEADERS = \
-        @top_builddir@/argon2/include/argon2.h \
-        @top_builddir@/argon2/src/blake2/blake2.h \
-        @top_builddir@/argon2/src/blake2/blake2-impl.h \
-        @top_builddir@/argon2/src/blake2/blamka-round-ref.h \
-        @top_builddir@/argon2/src/core.h \
-        @top_builddir@/argon2/src/encoding.h \
-        @top_builddir@/argon2/src/thread.h
-endif
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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-2020 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-2020 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) 2020 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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2020 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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
 *
@@ -69,7 +69,7 @@ constexpr gnutls_digest_algorithm_t gnutlsHashAlgo(size_t min_res) {
                               GNUTLS_DIG_SHA1));
 }

-constexpr size_t gnutlsHashSize(int algo) {
+constexpr size_t gnutlsHashSize(gnutls_digest_algorithm_t algo) {
    return (algo == GNUTLS_DIG_SHA512) ? 512/8 : (
           (algo == GNUTLS_DIG_SHA256) ? 256/8 : (
           (algo == GNUTLS_DIG_SHA1)   ? 160/8 : 0 ));
@@ -368,13 +368,22 @@ PrivateKey::serialize(uint8_t* out, size_t* out_len, const std::string& password
        : gnutls_x509_privkey_export_pkcs8(x509_key, GNUTLS_X509_FMT_PEM, password.c_str(), GNUTLS_PKCS_PBES2_AES_256, out, out_len);
 }

-PublicKey
+const PublicKey&
 PrivateKey::getPublicKey() const
 {
-    PublicKey pk;
-    if (auto err = gnutls_pubkey_import_privkey(pk.pk, key, GNUTLS_KEY_KEY_CERT_SIGN | GNUTLS_KEY_CRL_SIGN, 0))
+    return *getSharedPublicKey();
+}
+
+const std::shared_ptr<PublicKey>&
+PrivateKey::getSharedPublicKey() const
+{
+    if (publicKey_)
+        return publicKey_;
+    auto pk = std::make_shared<PublicKey>();
+    if (auto err = gnutls_pubkey_import_privkey(pk->pk, key, GNUTLS_KEY_KEY_CERT_SIGN | GNUTLS_KEY_CRL_SIGN, 0))
        throw CryptoException(std::string("Can't retreive public key: ") + gnutls_strerror(err));
-    return pk;
+    publicKey_ = pk;
+    return publicKey_;
 }

 PublicKey::PublicKey()
@@ -540,12 +549,7 @@ PublicKey::getId() const
        return {};
    InfoHash id;
    size_t sz = id.size();
-#if GNUTLS_VERSION_NUMBER < 0x030401
-    const int flags = 0;
-#else
-    const int flags = (id.size() == 32) ? GNUTLS_KEYID_USE_SHA256 : 0;
-#endif
-    if (auto err = gnutls_pubkey_get_key_id(pk, flags, id.data(), &sz))
+    if (auto err = gnutls_pubkey_get_key_id(pk, 0, id.data(), &sz))
        throw CryptoException(std::string("Can't get public key ID: ") + gnutls_strerror(err));
    if (sz != id.size())
        throw CryptoException("Can't get public key ID: wrong output length.");
@@ -849,12 +853,15 @@ Certificate::getId() const
 {
    if (not cert)
        return {};
+    if (cachedId_)
+        return cachedId_;
    InfoHash id;
    size_t sz = id.size();
    if (auto err = gnutls_x509_crt_get_key_id(cert, 0, id.data(), &sz))
        throw CryptoException(std::string("Can't get certificate public key ID: ") + gnutls_strerror(err));
    if (sz != id.size())
        throw CryptoException("Can't get certificate public key ID: wrong output length.");
+    cachedId_ = id;
    return id;
 }

@@ -863,6 +870,8 @@ Certificate::getLongId() const
 {
    if (not cert)
        return {};
+    if (cachedLongId_)
+        return cachedLongId_;
 #if GNUTLS_VERSION_NUMBER < 0x030401
    throw CryptoException("Can't get certificate 256 bits public key ID: GnuTLS 3.4.1 or higher required.");
 #else
@@ -872,6 +881,7 @@ Certificate::getLongId() const
        throw CryptoException(std::string("Can't get certificate 256 bits public key ID: ") + gnutls_strerror(err));
    if (sz != id.size())
        throw CryptoException("Can't get certificate 256 bits public key ID: wrong output length.");
+    cachedLongId_ = id;
    return id;
 #endif
 }
@@ -1047,6 +1057,8 @@ Certificate::generateOcspRequest(gnutls_x509_crt_t& issuer)
    Blob noncebuf(32);
    gnutls_datum_t nonce = { noncebuf.data(), (unsigned)noncebuf.size() };
    err = gnutls_rnd(GNUTLS_RND_NONCE, nonce.data, nonce.size);
+    if (err < 0)
+        throw CryptoException(gnutls_strerror(err));
    err = gnutls_ocsp_req_set_nonce(req.get(), 0, &nonce);
    if (err < 0)
        throw CryptoException(gnutls_strerror(err));
@@ -1153,14 +1165,14 @@ setRandomSerial(gnutls_x509_crt_t cert)
 }

 Certificate
-Certificate::generate(const PrivateKey& key, const std::string& name, const Identity& ca, bool is_ca)
+Certificate::generate(const PrivateKey& key, const std::string& name, const Identity& ca, bool is_ca, int64_t validity)
 {
    gnutls_x509_crt_t cert;
    if (not key.x509_key or gnutls_x509_crt_init(&cert) != GNUTLS_E_SUCCESS)
        return {};
    Certificate ret {cert};

-    setValidityPeriod(cert, 10 * 365 * 24 * 60 * 60);
+    setValidityPeriod(cert, validity <= 0 ? 10 * 365 * 24 * 60 * 60 : validity);
    if (int err = gnutls_x509_crt_set_key(cert, key.x509_key)) {
        throw CryptoException(std::string("Error when setting certificate key ") + gnutls_strerror(err));
    }
@@ -1169,7 +1181,7 @@ Certificate::generate(const PrivateKey& key, const std::string& name, const Iden
    }

    // TODO: compute the subject key using the recommended RFC method
-    auto pk = key.getPublicKey();
+    const auto& pk = key.getPublicKey();
    auto pk_id = pk.getId();
    const std::string uid_str = pk_id.toString();

@@ -1206,7 +1218,7 @@ Certificate::generate(const PrivateKey& key, const std::string& name, const Iden
 }

 Certificate
-Certificate::generate(const CertificateRequest& request, const Identity& ca)
+Certificate::generate(const CertificateRequest& request, const Identity& ca, int64_t validity)
 {
    gnutls_x509_crt_t cert;
    if (auto err = gnutls_x509_crt_init(&cert))
@@ -1219,7 +1231,7 @@ Certificate::generate(const CertificateRequest& request, const Identity& ca)
        throw CryptoException(std::string("Can't set certificate version: ") + gnutls_strerror(err));
    }

-    setValidityPeriod(cert, 10 * 365 * 24 * 60 * 60);
+    setValidityPeriod(cert, validity <= 0 ? 10 * 365 * 24 * 60 * 60 : validity);
    setRandomSerial(cert);

    if (auto err = gnutls_x509_crt_privkey_sign(cert, ca.second->cert, ca.first->key, ca.second->getPreferredDigest(), 0)) {
@@ -1230,6 +1242,32 @@ Certificate::generate(const CertificateRequest& request, const Identity& ca)
    return ret.getPacked();
 }

+void
+Certificate::setValidity(const Identity& ca, int64_t validity)
+{
+    setValidityPeriod(cert, validity);
+    setRandomSerial(cert);
+    if (ca.first && ca.second) {
+        if (not ca.second->isCA()) {
+            throw CryptoException("Signing certificate must be CA");
+        }
+        if (int err = gnutls_x509_crt_privkey_sign(cert, ca.second->cert, ca.first->key, ca.second->getPreferredDigest(), 0)) {
+            throw CryptoException(std::string("Error when signing certificate ") + gnutls_strerror(err));
+        }
+    }
+}
+
+void
+Certificate::setValidity(const PrivateKey& key, int64_t validity)
+{
+    setValidityPeriod(cert, validity);
+    setRandomSerial(cert);
+    const auto& pk = key.getPublicKey();
+    if (int err = gnutls_x509_crt_privkey_sign(cert, cert, key.key, pk.getPreferredDigest(), 0)) {
+        throw CryptoException(std::string("Error when signing certificate ") + gnutls_strerror(err));
+    }
+}
+
 std::vector<std::shared_ptr<RevocationList>>
 Certificate::getRevocationLists() const
 {
@@ -1437,7 +1475,7 @@ RevocationList::RevocationList(const Blob& b)
    } catch (const std::exception& e) {
        gnutls_x509_crl_deinit(crl);
        crl = nullptr;
-        throw e;
+        throw;
    }
 }

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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>
 *
@@ -30,16 +30,20 @@
 #include <sstream>
 #include <fstream>

+#include <inttypes.h>
+
 namespace dht {

 using namespace std::placeholders;

 constexpr std::chrono::minutes Dht::MAX_STORAGE_MAINTENANCE_EXPIRE_TIME;
 constexpr std::chrono::minutes Dht::SEARCH_EXPIRE_TIME;
+constexpr std::chrono::seconds Dht::BOOTSTRAP_PERIOD;
 constexpr duration Dht::LISTEN_EXPIRE_TIME;
 constexpr duration Dht::LISTEN_EXPIRE_TIME_PUBLIC;
 constexpr duration Dht::REANNOUNCE_MARGIN;
 static constexpr size_t MAX_REQUESTS_PER_SEC {8 * 1024};
+static constexpr duration BOOTSTRAP_PERIOD_MAX {std::chrono::hours(24)};

 NodeStatus
 Dht::updateStatus(sa_family_t af)
@@ -49,9 +53,9 @@ Dht::updateStatus(sa_family_t af)
    d.status = d.getStatus(scheduler.time());
    if (d.status != old) {
        auto& other = dht(af == AF_INET ? AF_INET6 : AF_INET);
-        if (other.status == NodeStatus::Disconnected && d.status == NodeStatus::Disconnected)
+        if (other.status == NodeStatus::Disconnected && d.status == NodeStatus::Disconnected) {
            onDisconnected();
-        else if (other.status == NodeStatus::Connected || d.status == NodeStatus::Connected) {
+        } else if (other.status == NodeStatus::Connected || d.status == NodeStatus::Connected) {
            onConnected();
        }
    }
@@ -284,7 +288,7 @@ Dht::searchNodeGetDone(const net::Request& req,
            if (srn->syncJob)
                scheduler.edit(srn->syncJob, syncTime);
            else
-                srn->syncJob = scheduler.add(syncTime, std::bind(&Dht::searchStep, this, sr));
+                srn->syncJob = scheduler.add(syncTime, std::bind(&Dht::searchStep, this, ws));
        }
        onGetValuesDone(req.node, answer, sr, query);
    }
@@ -486,21 +490,23 @@ void Dht::searchSendAnnounceValue(const Sp<Search>& sr) {
            } catch (std::out_of_range&) { }

            auto next_refresh_time = now + getType(a.value->type).expiration;
+            auto& acked = sn->acked[a.value->id];
+            scheduler.cancel(acked.refresh);
            /* only put the value if the node doesn't already have it */
            if (not hasValue or seq_no < a.value->seq) {
                if (logger_)
-                    logger_->d(sr->id, sn->node->id, "[search %s] [node %s] sending 'put' (vid: %d)",
+                    logger_->d(sr->id, sn->node->id, "[search %s] [node %s] sending 'put' (vid: %016" PRIx64 ")",
                        sr->id.toString().c_str(), sn->node->toString().c_str(), a.value->id);
                auto created = a.permanent ? time_point::max() : a.created;
-                sn->acked[a.value->id] = {
+                acked = {
                    network_engine.sendAnnounceValue(sn->node, sr->id, a.value, created, sn->token, onDone, onExpired),
                    next_refresh_time
                };
            } else if (hasValue and a.permanent) {
                if (logger_)
-                    logger_->w(sr->id, sn->node->id, "[search %s] [node %s] sending 'refresh' (vid: %d)",
+                    logger_->w(sr->id, sn->node->id, "[search %s] [node %s] sending 'refresh' (vid: %016" PRIx64 ")",
                        sr->id.toString().c_str(), sn->node->toString().c_str(), a.value->id);
-                sn->acked[a.value->id] = {
+                acked = {
                    network_engine.sendRefreshValue(sn->node, sr->id, a.value->id, sn->token, onDone,
                    [this, ws, node=sn->node, v=a.value,
                     onDone,
@@ -528,21 +534,17 @@ void Dht::searchSendAnnounceValue(const Sp<Search>& sr) {
                };
            } else {
                if (logger_)
-                    logger_->w(sr->id, sn->node->id, "[search %s] [node %s] already has value (vid: %d). Aborting.",
+                    logger_->w(sr->id, sn->node->id, "[search %s] [node %s] already has value (vid: %016" PRIx64 "). Aborting.",
                        sr->id.toString().c_str(), sn->node->toString().c_str(), a.value->id);
                auto ack_req = std::make_shared<net::Request>(net::Request::State::COMPLETED);
                ack_req->reply_time = now;
-                sn->acked[a.value->id] = std::make_pair(std::move(ack_req), next_refresh_time);
+                acked = {std::move(ack_req), next_refresh_time};

                /* step to clear announces */
                scheduler.edit(sr->nextSearchStep, now);
            }
            if (a.permanent) {
-                scheduler.add(next_refresh_time - REANNOUNCE_MARGIN, [this,ws] {
-                    if (auto sr = ws.lock()) {
-                        searchStep(sr);
-                    }
-                });
+                acked.refresh = scheduler.add(next_refresh_time - REANNOUNCE_MARGIN, std::bind(&Dht::searchStep, this, ws));
            }
        }
    };
@@ -567,7 +569,7 @@ void Dht::searchSendAnnounceValue(const Sp<Search>& sr) {
                    sendQuery = true;
                } else {
                    if (logger_)
-                        logger_->w(sr->id, n.node->id, "[search %s] [node %s] sending 'put' (vid: %d)",
+                        logger_->w(sr->id, n.node->id, "[search %s] [node %s] sending 'put' (vid: %016" PRIx64 ")",
                            sr->id.toString().c_str(), n.node->toString().c_str(), a.value->id);
                    n.acked[a.value->id] = {
                        network_engine.sendAnnounceValue(n.node, sr->id, a.value, a.created, n.token, onDone, onExpired),
@@ -640,8 +642,8 @@ Dht::searchSynchedNodeListen(const Sp<Search>& sr, SearchNode& n)
                if (auto sr = ws.lock()) {
                    scheduler.edit(sr->nextSearchStep, scheduler.time());
                    if (auto sn = sr->getNode(req.node)) {
-                        scheduler.add(sn->getListenTime(query, getListenExpiration()), std::bind(&Dht::searchStep, this, sr));
-                        sn->onListenSynced(query);
+                        auto job = scheduler.add(sn->getListenTime(query, getListenExpiration()), std::bind(&Dht::searchStep, this, ws));
+                        sn->onListenSynced(query, true, std::move(job));
                    }
                    onListenDone(req.node, answer, sr);
                }
@@ -667,8 +669,9 @@ Dht::searchSynchedNodeListen(const Sp<Search>& sr, SearchNode& n)
 /* When a search is in progress, we periodically call search_step to send
   further requests. */
 void
-Dht::searchStep(Sp<Search> sr)
+Dht::searchStep(std::weak_ptr<Search> ws)
 {
+    auto sr = ws.lock();
    if (not sr or sr->expired or sr->done) return;

    const auto& now = scheduler.time();
@@ -821,7 +824,7 @@ Dht::search(const InfoHash& id, sa_family_t af, GetCallback gcb, QueryCallback q
        sr->expired = false;
        sr->nodes.clear();
        sr->nodes.reserve(SEARCH_NODES+1);
-        sr->nextSearchStep = scheduler.add(time_point::max(), std::bind(&Dht::searchStep, this, sr));
+        sr->nextSearchStep = scheduler.add(time_point::max(), std::bind(&Dht::searchStep, this, std::weak_ptr<Search>(sr)));
        if (logger_)
            logger_->w(id, "[search %s IPv%c] new search", id.toString().c_str(), (af == AF_INET) ? '4' : '6');
        if (search_id == 0)
@@ -873,6 +876,11 @@ Dht::listenTo(const InfoHash& id, sa_family_t af, ValueCallback cb, Value::Filte
 size_t
 Dht::listen(const InfoHash& id, ValueCallback cb, Value::Filter f, Where where)
 {
+    if (not id) {
+        if (logger_)
+            logger_->w(id, "Listen called with invalid key");
+        return 0;
+    }
    scheduler.syncTime();

    auto token = ++listener_token;
@@ -955,7 +963,9 @@ struct GetStatus : public OpStatus {
 void
 Dht::put(const InfoHash& id, Sp<Value> val, DoneCallback callback, time_point created, bool permanent)
 {
-    if (not val) {
+    if (not id or not val) {
+        if (logger_)
+            logger_->w(id, "Put called with invalid key or value");
        if (callback)
            callback(false, {});
        return;
@@ -1025,6 +1035,13 @@ bool callbackWrapper(Cb get_cb, DoneCallback done_cb, const std::vector<Sp<T>>&
 void
 Dht::get(const InfoHash& id, GetCallback getcb, DoneCallback donecb, Value::Filter&& filter, Where&& where)
 {
+    if (not id) {
+        if (logger_)
+            logger_->w(id, "Get called with invalid key");
+        if (donecb)
+            donecb(false, {});
+        return;
+    }
    scheduler.syncTime();

    auto op = std::make_shared<GetStatus<std::map<Value::Id, Sp<Value>>>>();
@@ -1065,6 +1082,13 @@ Dht::get(const InfoHash& id, GetCallback getcb, DoneCallback donecb, Value::Filt

 void Dht::query(const InfoHash& id, QueryCallback cb, DoneCallback done_cb, Query&& q)
 {
+    if (not id) {
+        if (logger_)
+            logger_->w(id, "Query called with invalid key");
+        if (done_cb)
+            done_cb(false, {});
+        return;
+    }
    scheduler.syncTime();
    auto op = std::make_shared<GetStatus<std::vector<Sp<FieldValueIndex>>>>();
    auto f = q.where.getFilter();
@@ -1253,8 +1277,9 @@ Dht::storageStore(const InfoHash& id, const Sp<Value>& value, time_point created
    if (auto vs = store.first) {
        total_store_size += store.second.size_diff;
        total_values += store.second.values_diff;
+        scheduler.cancel(vs->expiration_job);
        if (not permanent) {
-            scheduler.add(expiration, std::bind(&Dht::expireStorage, this, id));
+            vs->expiration_job = scheduler.add(expiration, std::bind(&Dht::expireStorage, this, id));
        }
        if (total_store_size > max_store_size) {
            expireStore();
@@ -1414,6 +1439,7 @@ Dht::connectivityChanged(sa_family_t 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
 }

 void
@@ -1595,10 +1621,10 @@ Dht::dumpSearch(const Search& sr, std::ostream& out) const
                out << "[";
                for (const auto& a : sr.announce) {
                    auto ack = n.acked.find(a.value->id);
-                    if (ack == n.acked.end() or not ack->second.first) {
+                    if (ack == n.acked.end() or not ack->second.req) {
                        out << ' ';
                    } else {
-                        out << ack->second.first->getStateChar();
+                        out << ack->second.req->getStateChar();
                    }
                }
                out << "] ";
@@ -1995,11 +2021,7 @@ Dht::expire()
 void
 Dht::onConnected()
 {
-    if (bootstrapJob) {
-        bootstrapJob->cancel();
-        bootstrapJob.reset();
-    }
-    bootstrap_period = std::chrono::seconds(10);
+    stopBootstrap();
    auto callbacks = std::move(onConnectCallbacks_);
    while (not callbacks.empty()) {
        callbacks.front()();
@@ -2009,6 +2031,13 @@ Dht::onConnected()

 void
 Dht::onDisconnected()
+{
+    if (not bootstrapJob)
+        bootstrap();
+}
+
+void
+Dht::bootstrap()
 {
    if (dht4.status != NodeStatus::Disconnected || dht6.status != NodeStatus::Disconnected)
        return;
@@ -2027,10 +2056,23 @@ Dht::onDisconnected()
                logger_->e(myid, "Can't resolve %s:%s: %s", boootstrap.first.c_str(), boootstrap.second.c_str(), e.what());
        }
    }
-    if (bootstrapJob)
-        bootstrapJob->cancel();
-    bootstrapJob = scheduler.add(scheduler.time() + bootstrap_period, std::bind(&Dht::onDisconnected, this));
-    bootstrap_period *= 2;
+    scheduler.cancel(bootstrapJob);
+    bootstrapJob = scheduler.add(scheduler.time() + bootstrap_period, std::bind(&Dht::bootstrap, this));
+    bootstrap_period = std::min(bootstrap_period * 2, BOOTSTRAP_PERIOD_MAX);
+}
+
+void
+Dht::startBootstrap()
+{
+    stopBootstrap();
+    bootstrapJob = scheduler.add(scheduler.time(), std::bind(&Dht::bootstrap, this));
+}
+
+void
+Dht::stopBootstrap()
+{
+    scheduler.cancel(bootstrapJob);
+    bootstrap_period = BOOTSTRAP_PERIOD;
 }

 void
@@ -2147,25 +2189,25 @@ Dht::exportNodes() const
    if (b4 != dht4.buckets.end()) {
        for (auto& n : b4->nodes)
            if (n->isGood(now))
-                nodes.push_back(n->exportNode());
+                nodes.emplace_back(n->exportNode());
    }
    const auto b6 = dht6.buckets.findBucket(myid);
    if (b6 != dht6.buckets.end()) {
        for (auto& n : b6->nodes)
            if (n->isGood(now))
-                nodes.push_back(n->exportNode());
+                nodes.emplace_back(n->exportNode());
    }
    for (auto b = dht4.buckets.begin(); b != dht4.buckets.end(); ++b) {
        if (b == b4) continue;
        for (auto& n : b->nodes)
            if (n->isGood(now))
-                nodes.push_back(n->exportNode());
+                nodes.emplace_back(n->exportNode());
    }
    for (auto b = dht6.buckets.begin(); b != dht6.buckets.end(); ++b) {
        if (b == b6) continue;
        for (auto& n : b->nodes)
            if (n->isGood(now))
-                nodes.push_back(n->exportNode());
+                nodes.emplace_back(n->exportNode());
    }
    return nodes;
 }
@@ -2438,7 +2480,7 @@ Dht::onAnnounce(Sp<Node> n,
            if (*lv == *vc) {
                storageRefresh(hash, v->id);
                if (logger_)
-                    logger_->d(hash, node.id, "[store %s] [node %s] refreshed value %s", hash.toString().c_str(), node.toString().c_str(), std::to_string(v->id).c_str());
+                    logger_->d(hash, node.id, "[store %s] [node %s] refreshed value %016" PRIx64, hash.toString().c_str(), node.toString().c_str(), v->id);
            } else {
                const auto& type = getType(lv->type);
                if (type.editPolicy(hash, lv, vc, node.id, node.getAddr())) {
@@ -2481,7 +2523,7 @@ Dht::onRefresh(Sp<Node> node, const InfoHash& hash, const Blob& token, const Val
    }
    if (storageRefresh(hash, vid)) {
        if (logger_)
-            logger_->d(hash, node->id, "[store %s] [node %s] refreshed value %s", hash.toString().c_str(), node->toString().c_str(), std::to_string(vid).c_str());
+            logger_->d(hash, node->id, "[store %s] [node %s] refreshed value %016" PRIx64, hash.toString().c_str(), node->toString().c_str(), vid);
    } else {
        if (logger_)
            logger_->d(hash, node->id, "[store %s] [node %s] got refresh for unknown value",
@@ -2517,8 +2559,12 @@ Dht::storageRefresh(const InfoHash& id, Value::Id vid)
        }

        auto expiration = s->second.refresh(now, vid, types);
-        if (expiration != time_point::max())
-            scheduler.add(expiration, std::bind(&Dht::expireStorage, this, id));
+        if (expiration.first) {
+            scheduler.cancel(expiration.first->expiration_job);
+            if (expiration.second != time_point::max()) {
+                expiration.first->expiration_job = scheduler.add(expiration.second, std::bind(&Dht::expireStorage, this, id));
+            }
+        }
        return true;
    }
    return false;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -41,15 +41,15 @@ struct DhtProxyClient::OperationState {
 struct DhtProxyClient::Listener
 {
    Listener(OpValueCache&& c):
-        cache(std::move(c))
-    {}
+        cache(std::move(c)) {}

-    unsigned callbackId;
    OpValueCache cache;
    CacheValueCallback cb;
    Sp<OperationState> opstate;
    std::shared_ptr<http::Request> request;
+#ifdef OPENDHT_PUSH_NOTIFICATIONS
    std::unique_ptr<asio::steady_timer> refreshSubscriberTimer;
+#endif
 };

 struct PermanentPut {
@@ -720,7 +720,8 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
    }
    auto newStatus = std::max(statusIpv4_, statusIpv6_);
    if (newStatus == NodeStatus::Connected) {
-        if (oldStatus == NodeStatus::Disconnected || oldStatus == NodeStatus::Connecting) {
+        if (oldStatus == NodeStatus::Disconnected || oldStatus == NodeStatus::Connecting || launchConnectedCbs_) {
+            launchConnectedCbs_ = false;
            listenerRestartTimer_->expires_at(std::chrono::steady_clock::now());
            listenerRestartTimer_->async_wait(std::bind(&DhtProxyClient::restartListeners, this, std::placeholders::_1));
            if (not onConnectCallbacks_.empty()) {
@@ -813,6 +814,7 @@ DhtProxyClient::listen(const InfoHash& key, ValueCallback cb, Value::Filter filt
            }
            return false;
        };
+#ifdef OPENDHT_PUSH_NOTIFICATIONS
        if (not deviceKey_.empty()) {
            /*
             * Relaunch push listeners even if a timeout is not received
@@ -825,17 +827,13 @@ DhtProxyClient::listen(const InfoHash& key, ValueCallback cb, Value::Filter filt
            l->second.refreshSubscriberTimer->async_wait(std::bind(&DhtProxyClient::handleResubscribe, this,
                                                         std::placeholders::_1, key, token, opstate));
        }
+#endif
        ListenMethod method;
        restinio::http_request_header_t header;
        if (deviceKey_.empty()){ // listen
            method = ListenMethod::LISTEN;
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-            header.method(restinio::method_listen);
-            header.request_target("/" + key.toString());
-#else
            header.method(restinio::http_method_get());
            header.request_target("/key/" + key.toString() + "/listen");
-#endif
        }
        else {
            method = ListenMethod::SUBSCRIBE;
@@ -1151,13 +1149,8 @@ DhtProxyClient::restartListeners(const asio::error_code &ec)
            auto cb = listener.cb;
            // define header
            restinio::http_request_header_t header;
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-            header.method(restinio::method_listen);
-            header.request_target("/" + search.first.toString());
-#else
            header.method(restinio::http_method_get());
            header.request_target("/key/" + search.first.toString() + "/listen");
-#endif
            sendListen(header, cb, opstate, listener, ListenMethod::LISTEN);
        }
    }
@@ -1170,6 +1163,9 @@ DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string
    {
        // If a push notification is received, the proxy is up and running
        std::lock_guard<std::mutex> l(lockCurrentProxyInfos_);
+        auto oldStatus = std::max(statusIpv4_, statusIpv6_);
+        if (oldStatus != NodeStatus::Connected)
+            launchConnectedCbs_ = true;
        statusIpv4_ = NodeStatus::Connected;
        statusIpv6_ = NodeStatus::Connected;
    }
@@ -1235,7 +1231,7 @@ DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string
                        ids.emplace_back(std::stoull(substr));
                    }
                    {
-                        std::lock_guard<std::mutex> lock(lockCallbacks_);
+                        std::lock_guard<std::mutex> lockCb(lockCallbacks_);
                        callbacks_.emplace_back([this, key, token, opstate, ids, sendTime]() {
                            if (opstate->stop)
                                return;
@@ -1275,11 +1271,7 @@ DhtProxyClient::resubscribe(const InfoHash& key, const size_t token, Listener& l
        logger_->d("[proxy:client] [resubscribe] [search %s]", key.to_c_str());

    auto opstate = listener.opstate;
-    opstate->stop = true;
-    if (listener.request){
-        listener.request.reset();
-    }
-    opstate->stop = false;
+    listener.request.reset(); // This will update ok to false
    opstate->ok = true;

    restinio::http_request_header_t header;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -38,26 +38,7 @@

 using namespace std::placeholders;
 using namespace std::chrono_literals;
-
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-namespace restinio {
-struct custom_http_methods_t
-{
-    static constexpr restinio::http_method_id_t from_nodejs(int m) noexcept {
-        if(m == method_listen.raw_id())
-            return method_listen;
-        else if(m == method_stats.raw_id())
-            return method_stats;
-        else if(m == method_sign.raw_id())
-            return method_sign;
-        else if(m == method_encrypt.raw_id())
-            return method_encrypt;
-        else
-            return restinio::default_http_methods_t::from_nodejs(m);
-    }
-};
-}
-#endif
+using namespace std::literals;

 namespace dht {
 constexpr char RESP_MSG_JSON_INCORRECT[] = "{\"err:\":\"Incorrect JSON\"}";
@@ -119,7 +100,7 @@ class DhtProxyServer::ConnectionListener
 {
 public:
    ConnectionListener() {};
-    ConnectionListener(std::function<void(restinio::connection_id_t)> onClosed) : onClosed_(std::move(onClosed)) {};
+    explicit ConnectionListener(std::function<void(restinio::connection_id_t)> onClosed) : onClosed_(std::move(onClosed)) {};
    ~ConnectionListener() {};

    /**
@@ -156,9 +137,6 @@ DhtProxyServer::onConnectionClosed(restinio::connection_id_t id)
 struct DhtProxyServer::RestRouterTraitsTls : public restinio::default_tls_traits_t
 {
    using timer_manager_t = restinio::asio_timer_manager_t;
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-    using http_methods_mapper_t = restinio::custom_http_methods_t;
-#endif
    using logger_t = opendht_logger_t;
    using request_handler_t = RestRouter;
    using connection_state_listener_t = ConnectionListener;
@@ -166,9 +144,6 @@ struct DhtProxyServer::RestRouterTraitsTls : public restinio::default_tls_traits
 struct DhtProxyServer::RestRouterTraits : public restinio::default_traits_t
 {
    using timer_manager_t = restinio::asio_timer_manager_t;
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-    using http_methods_mapper_t = restinio::custom_http_methods_t;
-#endif
    using logger_t = opendht_logger_t;
    using request_handler_t = RestRouter;
    using connection_state_listener_t = ConnectionListener;
@@ -177,25 +152,25 @@ struct DhtProxyServer::RestRouterTraits : public restinio::default_traits_t
 void
 DhtProxyServer::PermanentPut::msgpack_unpack(const msgpack::object& o)
 {
-    if (auto cid = findMapValue(o, "cid")) {
+    if (auto cid = findMapValue(o, "cid"sv)) {
        clientId = cid->as<std::string>();
    }
-    if (auto exp = findMapValue(o, "exp")) {
+    if (auto exp = findMapValue(o, "exp"sv)) {
        expiration = from_time_t(exp->as<time_t>());
    }
-    if (auto token = findMapValue(o, "token")) {
+    if (auto token = findMapValue(o, "token"sv)) {
        pushToken = token->as<std::string>();
    }
-    if (auto sid = findMapValue(o, "sid")) {
+    if (auto sid = findMapValue(o, "sid"sv)) {
        if (not sessionCtx)
            sessionCtx = std::make_shared<PushSessionContext>(sid->as<std::string>());
        else
            sessionCtx->sessionId = sid->as<std::string>();
    }
-    if (auto t = findMapValue(o, "t")) {
+    if (auto t = findMapValue(o, "t"sv)) {
        type = t->as<PushType>();
    }
-    if (auto val = findMapValue(o, "value")) {
+    if (auto val = findMapValue(o, "value"sv)) {
        value = std::make_shared<dht::Value>(*val);
    }
 }
@@ -204,19 +179,19 @@ DhtProxyServer::PermanentPut::msgpack_unpack(const msgpack::object& o)
 void
 DhtProxyServer::Listener::msgpack_unpack(const msgpack::object& o)
 {
-    if (auto cid = findMapValue(o, "cid")) {
+    if (auto cid = findMapValue(o, "cid"sv)) {
        clientId = cid->as<std::string>();
    }
-    if (auto exp = findMapValue(o, "exp")) {
+    if (auto exp = findMapValue(o, "exp"sv)) {
        expiration = from_time_t(exp->as<time_t>());
    }
-    if (auto sid = findMapValue(o, "sid")) {
+    if (auto sid = findMapValue(o, "sid"sv)) {
        if (not sessionCtx)
            sessionCtx = std::make_shared<PushSessionContext>(sid->as<std::string>());
        else
            sessionCtx->sessionId = sid->as<std::string>();
    }
-    if (auto t = findMapValue(o, "t")) {
+    if (auto t = findMapValue(o, "t"sv)) {
        type = t->as<PushType>();
    }
 }
@@ -371,7 +346,7 @@ DhtProxyServer::loadState(Is& is, size_t size) {
        while (pac.next(oh)) {
            if (oh.get().type != msgpack::type::MAP)
                continue;
-            if (auto puts = findMapValue(oh.get(), "puts")) {
+            if (auto puts = findMapValue(oh.get(), "puts"sv)) {
                std::lock_guard<std::mutex> lock(lockSearchPuts_);
                puts_ = puts->as<decltype(puts_)>();
                if (logger_)
@@ -408,9 +383,9 @@ DhtProxyServer::loadState(Is& is, size_t size) {
                    logger_->d("No persistent puts in state");
            }
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
-            if (auto listeners = findMapValue(oh.get(), "pushListeners")) {
+            if (auto pushListeners = findMapValue(oh.get(), "pushListeners"sv)) {
                std::lock_guard<std::mutex> lock(lockListener_);
-                pushListeners_ = listeners->as<decltype(pushListeners_)>();
+                pushListeners_ = pushListeners->as<decltype(pushListeners_)>();
                if (logger_)
                    logger_->d("Loading %zu push listeners", pushListeners_.size());
                for (auto& pushListener : pushListeners_) {
@@ -613,11 +588,6 @@ DhtProxyServer::createRestRouter()
    // **************************** LEGACY ROUTES ****************************
    // node.info
    router->http_get("/", std::bind(&DhtProxyServer::getNodeInfo, this, _1, _2));
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-    // node.stats
-    router->add_handler(restinio::custom_http_methods_t::from_nodejs(restinio::method_stats.raw_id()),
-                        "/", std::bind(&DhtProxyServer::getStats, this, _1, _2));
-#endif
    // key.options
    router->add_handler(restinio::http_method_options(),
                        "/:hash", std::bind(&DhtProxyServer::options, this, _1, _2));
@@ -625,11 +595,6 @@ DhtProxyServer::createRestRouter()
    router->http_get("/:hash", std::bind(&DhtProxyServer::get, this, _1, _2));
    // key.post
    router->http_post("/:hash", std::bind(&DhtProxyServer::put, this, _1, _2));
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-    // key.listen
-    router->add_handler(restinio::custom_http_methods_t::from_nodejs(restinio::method_listen.raw_id()),
-                        "/:hash", std::bind(&DhtProxyServer::listen, this, _1, _2));
-#endif
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
    // key.subscribe
    router->add_handler(restinio::http_method_subscribe(),
@@ -639,14 +604,6 @@ DhtProxyServer::createRestRouter()
                        "/:hash", std::bind(&DhtProxyServer::unsubscribe, this, _1, _2));
 #endif //OPENDHT_PUSH_NOTIFICATIONS
 #ifdef OPENDHT_PROXY_SERVER_IDENTITY
-#ifdef OPENDHT_PROXY_HTTP_PARSER_FORK
-    // key.sign
-    router->add_handler(restinio::custom_http_methods_t::from_nodejs(restinio::method_sign.raw_id()),
-                        "/:hash", std::bind(&DhtProxyServer::putSigned, this, _1, _2));
-    // key.encrypt
-    router->add_handler(restinio::custom_http_methods_t::from_nodejs(restinio::method_encrypt.raw_id()),
-                        "/:hash", std::bind(&DhtProxyServer::putEncrypted, this, _1, _2));
-#endif
 #endif // OPENDHT_PROXY_SERVER_IDENTITY

    // **************************** NEW ROUTES ****************************
@@ -727,9 +684,9 @@ DhtProxyServer::get(restinio::request_handle_t request,
 {
    requestNum_++;
    try {
-        InfoHash infoHash(params["hash"].to_string());
+        InfoHash infoHash(params["hash"]);
        if (!infoHash)
-            infoHash = InfoHash::get(params["hash"].to_string());
+            infoHash = InfoHash::get(params["hash"]);
        auto response = std::make_shared<ResponseByPartsBuilder>(
            initHttpResponse(request->create_response<ResponseByParts>()));
        response->flush();
@@ -758,9 +715,9 @@ DhtProxyServer::listen(restinio::request_handle_t request,
    requestNum_++;

    try {
-        InfoHash infoHash(params["hash"].to_string());
+        InfoHash infoHash(params["hash"]);
        if (!infoHash)
-            infoHash = InfoHash::get(params["hash"].to_string());
+            infoHash = InfoHash::get(params["hash"]);
        auto response = std::make_shared<ResponseByPartsBuilder>(
            initHttpResponse(request->create_response<ResponseByParts>()));
        response->flush();
@@ -794,9 +751,9 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
 {
    requestNum_++;
    try {
-        InfoHash infoHash(params["hash"].to_string());
+        InfoHash infoHash(params["hash"]);
        if (!infoHash)
-            infoHash = InfoHash::get(params["hash"].to_string());
+            infoHash = InfoHash::get(params["hash"]);

        std::string err;
        Json::Value r;
@@ -936,9 +893,9 @@ DhtProxyServer::unsubscribe(restinio::request_handle_t request,
 {
    requestNum_++;

-    InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"]);
    if (!infoHash)
-        infoHash = InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"]);

    if (logger_)
        logger_->d("[proxy:server] [unsubscribe %s]", infoHash.toString().c_str());
@@ -1048,7 +1005,13 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
        notification["platform"] = type == PushType::Android ? 2 : 1;
        notification["data"] = std::move(json);
        notification["priority"] = highPriority ? "high" : "normal";
-        notification["time_to_live"] = 600;
+        if (type == PushType::Android)
+            notification["time_to_live"] = 3600 * 24; // 24 hours
+        else {
+            const auto expiration = std::chrono::system_clock::now() + std::chrono::hours(24);
+            uint32_t exp = std::chrono::duration_cast<std::chrono::seconds>(expiration.time_since_epoch()).count();
+            notification["expiration"] = exp;
+        }

        Json::Value notifications(Json::arrayValue);
        notifications[0] = notification;
@@ -1118,9 +1081,9 @@ DhtProxyServer::put(restinio::request_handle_t request,
                    restinio::router::route_params_t params)
 {
    requestNum_++;
-    InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"]);
    if (!infoHash)
-        infoHash = InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"]);

    if (request->body().empty()){
        auto response = initHttpResponse(request->create_response(restinio::status_bad_request()));
@@ -1259,9 +1222,9 @@ DhtProxyServer::putSigned(restinio::request_handle_t request,
                          restinio::router::route_params_t params) const
 {
    requestNum_++;
-    InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"]);
    if (!infoHash)
-        infoHash = InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"]);

    if (request->body().empty()){
        auto response = initHttpResponse(request->create_response(restinio::status_bad_request()));
@@ -1309,9 +1272,9 @@ DhtProxyServer::putEncrypted(restinio::request_handle_t request,
                             restinio::router::route_params_t params)
 {
    requestNum_++;
-    InfoHash infoHash(params["hash"].to_string());
+    InfoHash infoHash(params["hash"]);
    if (!infoHash)
-        infoHash = InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"]);

    if (request->body().empty()){
        auto response = initHttpResponse(request->create_response(restinio::status_bad_request()));
@@ -1381,10 +1344,10 @@ DhtProxyServer::getFiltered(restinio::request_handle_t request,
                            restinio::router::route_params_t params)
 {
    requestNum_++;
-    auto value = params["value"].to_string();
-    InfoHash infoHash(params["hash"].to_string());
+    auto query = params["value"];
+    InfoHash infoHash(params["hash"]);
    if (!infoHash)
-        infoHash = InfoHash::get(params["hash"].to_string());
+        infoHash = InfoHash::get(params["hash"]);

    try {
        auto response = std::make_shared<ResponseByPartsBuilder>(
@@ -1399,7 +1362,7 @@ DhtProxyServer::getFiltered(restinio::request_handle_t request,
            [response] (bool /*ok*/){
                response->done();
            },
-            {}, value);
+            {}, query);
        return restinio::request_handling_status_t::accepted;
    } catch (const std::exception& e){
        return serverError(*request);
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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>
@@ -36,7 +36,6 @@

 namespace dht {

-constexpr std::chrono::seconds DhtRunner::BOOTSTRAP_PERIOD;
 static const std::string PEER_DISCOVERY_DHT_SERVICE = "dht";

 struct DhtRunner::Listener {
@@ -106,81 +105,96 @@ 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.");
+            context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", this);
        return;
    }

-    auto local4 = config.bind4;
-    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");
-        local4.setFamily(AF_INET);
-        local6.setFamily(AF_INET6);
-    }
-    auto state_path = config.dht_config.node_config.persist_path;
-    if (not state_path.empty() && (local4.getPort() == 0 || local6.getPort() == 0)) {
-        state_path += "_port.txt";
-        std::ifstream inConfig(state_path);
-        if (inConfig.is_open()) {
-            in_port_t port;
-            if (inConfig >> port) {
-                if (local4.getPort() == 0) {
-                    if (context.logger)
-                        context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", this, port);
-                    local4.setPort(port);
+    try {
+        auto local4 = config.bind4;
+        auto local6 = config.bind6;
+        if (not local4 and not local6) {
+            if (context.logger)
+                context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", this);
+            local4.setFamily(AF_INET);
+            local6.setFamily(AF_INET6);
+        }
+        auto state_path = config.dht_config.node_config.persist_path;
+        if (not state_path.empty() && (local4.getPort() == 0 || local6.getPort() == 0)) {
+            state_path += "_port.txt";
+            std::ifstream inConfig(state_path);
+            if (inConfig.is_open()) {
+                in_port_t port;
+                if (inConfig >> port) {
+                    if (local4.getPort() == 0) {
+                        if (context.logger)
+                            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", this, port);
-                    local6.setPort(port);
+                if (inConfig >> port) {
+                    if (local6.getPort() == 0) {
+                        if (context.logger)
+                            context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", this, port);
+                        local6.setPort(port);
+                    }
                }
            }
        }
-    }

-    if (not context.sock)
-        context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
-
-    if (not state_path.empty()) {
-        std::ofstream outConfig(state_path);
-        outConfig << context.sock->getBoundRef(AF_INET).getPort() << std::endl;
-        outConfig << context.sock->getBoundRef(AF_INET6).getPort() << std::endl;
-    }
-
-    if (context.logger) {
-        logger_ = context.logger;
-        logger_->d("[runner %p] state changed to Running", this);
-    }
-
-    context.sock->setOnReceive([&] (net::PacketList&& pkts) {
-        net::PacketList ret;
-        {
-            std::lock_guard<std::mutex> lck(sock_mtx);
-            auto maxSize = net::RX_QUEUE_MAX_SIZE - pkts.size();
-            while (rcv.size() > maxSize) {
-                if (logger_)
-                    logger_->e("Dropping packet: queue is full!");
-                rcv.pop_front();
-            }
-
-            rcv.splice(rcv.end(), std::move(pkts));
-            ret = std::move(rcv_free);
+        if (context.logger) {
+            logger_ = context.logger;
        }
-        cv.notify_all();
-        return ret;
-    });
+
+        if (not context.sock) {
+            context.sock.reset(new net::UdpSocket(local4, local6, context.logger));
+        }
+
+        if (not state_path.empty()) {
+            std::ofstream outConfig(state_path);
+            outConfig << context.sock->getBoundRef(AF_INET).getPort() << std::endl;
+            outConfig << context.sock->getBoundRef(AF_INET6).getPort() << std::endl;
+        }
+
+        if (context.logger) {
+            logger_->d("[runner %p] state changed to Running", this);
+        }
+
+        context.sock->setOnReceive([&] (net::PacketList&& pkts) {
+            net::PacketList ret;
+            {
+                std::lock_guard<std::mutex> lck(sock_mtx);
+                auto maxSize = net::RX_QUEUE_MAX_SIZE - pkts.size();
+                while (rcv.size() > maxSize) {
+                    if (logger_)
+                        logger_->e("Dropping packet: queue is full!");
+                    rcv.pop_front();
+                }
+
+                rcv.splice(rcv.end(), std::move(pkts));
+                ret = std::move(rcv_free);
+            }
+            cv.notify_all();
+            return ret;
+        });

 #ifdef OPENDHT_PROXY_CLIENT
-    config_ = config;
-    identityAnnouncedCb_ = context.identityAnnouncedCb;
+        config_ = config;
+        identityAnnouncedCb_ = context.identityAnnouncedCb;
 #endif
-    auto dht = std::unique_ptr<DhtInterface>(new Dht(std::move(context.sock), SecureDht::getConfig(config.dht_config), context.logger));
-    dht_ = std::unique_ptr<SecureDht>(new SecureDht(std::move(dht), config.dht_config, std::move(context.identityAnnouncedCb), context.logger));
+        auto dht = std::make_unique<Dht>(std::move(context.sock), SecureDht::getConfig(config.dht_config), context.logger);
+        dht_ = std::make_unique<SecureDht>(std::move(dht), config.dht_config, std::move(context.identityAnnouncedCb), context.logger);
+        enableProxy(not config.proxy_server.empty());
+    } catch(const std::exception& e) {
+        config_ = {};
+        identityAnnouncedCb_ = {};
+        dht_.reset();
+#ifdef OPENDHT_PROXY_CLIENT
+        dht_via_proxy_.reset();
+#endif
+        running = State::Idle;
+        throw;
+    }

-    enableProxy(not config.proxy_server.empty());
    if (context.logger and dht_via_proxy_) {
        dht_via_proxy_->setLogger(context.logger);
    }
@@ -406,6 +420,14 @@ DhtRunner::getId() const
    return {};
 }

+std::shared_ptr<crypto::PublicKey>
+DhtRunner::getPublicKey() const
+{
+    if (auto dht = activeDht())
+        return dht->getPublicKey();
+    return {};
+}
+
 InfoHash
 DhtRunner::getNodeId() const
 {
@@ -697,8 +719,8 @@ DhtRunner::loop_()
            rcv_free.splice(rcv_free.end(), std::move(received_treated));
    }

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

    NodeStatus nstatus4 = dht->updateStatus(AF_INET);
    NodeStatus nstatus6 = dht->updateStatus(AF_INET6);
@@ -958,6 +980,31 @@ DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, Done
    putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), std::move(cb), permanent);
 }

+void
+DhtRunner::putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
+{
+    std::unique_lock<std::mutex> lck(storage_mtx);
+    if (running != State::Running) {
+        lck.unlock();
+        if (cb) cb(false, {});
+        return;
+    }
+    ongoing_ops++;
+    pending_ops.emplace([=,
+        cb = std::move(cb),
+        value = std::move(value)
+    ] (SecureDht& dht) mutable {
+        dht.putEncrypted(hash, *to, value, bindOpDoneCallback(std::move(cb)), permanent);
+    });
+    cv.notify_all();
+}
+
+void
+DhtRunner::putEncrypted(InfoHash hash, const std::shared_ptr<crypto::PublicKey>& to, Value&& value, DoneCallback cb, bool permanent)
+{
+    putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), std::move(cb), permanent);
+}
+
 void
 DhtRunner::bootstrap(const std::string& host, const std::string& service)
 {
@@ -989,7 +1036,7 @@ DhtRunner::clearBootstrap()
 }

 void
-DhtRunner::bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple&& cb)
+DhtRunner::bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple cb)
 {
    if (running != State::Running) {
        cb(false);
@@ -1019,7 +1066,7 @@ DhtRunner::bootstrap(std::vector<SockAddr> nodes, DoneCallbackSimple&& cb)
 }

 void
-DhtRunner::bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb)
+DhtRunner::bootstrap(const SockAddr& addr, DoneCallbackSimple cb)
 {
    std::unique_lock<std::mutex> lck(storage_mtx);
    if (running != State::Running) {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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,6 +22,8 @@
 #include <sstream>
 #include <cstdio>

+using namespace std::literals;
+
 namespace dht {

 const HexMap hex_map = {};
@@ -33,9 +35,9 @@ NodeExport::msgpack_unpack(msgpack::object o)
        throw msgpack::type_error();
    if (o.via.map.size < 2)
        throw msgpack::type_error();
-    if (o.via.map.ptr[0].key.as<std::string>() != "id")
+    if (o.via.map.ptr[0].key.as<std::string_view>() != "id"sv)
        throw msgpack::type_error();
-    if (o.via.map.ptr[1].key.as<std::string>() != "addr")
+    if (o.via.map.ptr[1].key.as<std::string_view>() != "addr"sv)
        throw msgpack::type_error();
    const auto& addr = o.via.map.ptr[1].val;
    if (addr.type != msgpack::type::BIN)
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -38,7 +38,7 @@ 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)
+    if (ret <= 0)
        return;

    // write timestamp
@@ -89,7 +89,7 @@ std::shared_ptr<Logger>
 getSyslogLogger(const char* name) {
 #ifndef _WIN32
    struct Syslog {
-        Syslog(const char* n) {
+        explicit Syslog(const char* n) {
            openlog(n, LOG_NDELAY, LOG_USER);
        }
        ~Syslog() {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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>
 *
@@ -219,7 +219,7 @@ NetworkEngine::tellListenerExpired(Sp<Node> n, Tid socket_id, const InfoHash&, c
        Tid tid (n->getNewTid());

        pk.pack(KEY_Q);   pk.pack(QUERY_UPDATE);
-        pk.pack(KEY_TID);     pk.pack(tid);
+        pk.pack(KEY_TID); pk.pack(tid);

        auto req = std::make_shared<Request>(MessageType::UpdateValue, tid, n,
            Blob(buffer.data(), buffer.data() + buffer.size()),
@@ -460,9 +460,9 @@ NetworkEngine::processMessage(const uint8_t *buf, size_t buflen, SockAddr f)
                    // process the full message
                    process(std::move(pmsg_it->second.msg), from);
                    partial_messages.erase(pmsg_it);
-		} catch (...) {
+                } catch (...) {
                    return;
-		}  
+                }
            } else
                scheduler.add(now + RX_TIMEOUT, std::bind(&NetworkEngine::maintainRxBuffer, this, msg->tid));
        }
@@ -485,11 +485,11 @@ NetworkEngine::processMessage(const uint8_t *buf, size_t buflen, SockAddr f)
    }

    if (msg->value_parts.empty()) {
-        try {	    
+        try {
            process(std::move(msg), from);
-	} catch(...) {
+        } catch(...) {
            return;
-	}
+        }
    } else {
        // starting partial message session
        auto k = msg->tid;
@@ -955,8 +955,8 @@ NetworkEngine::sendValueParts(Tid tid, const std::vector<Blob>& svals, const Soc
            pk.pack(KEY_TID); pk.pack(tid);
            pk.pack(KEY_V); pk.pack_map(1);
                pk.pack(i); pk.pack_map(2);
-                    pk.pack(std::string("o")); pk.pack(start);
-                    pk.pack(std::string("d")); pk.pack_bin(end-start);
+                    pk.pack("o"sv); pk.pack(start);
+                    pk.pack("d"sv); pk.pack_bin(end-start);
                                               pk.pack_bin_body((const char*)v.data()+start, end-start);
            send(addr, buffer.data(), buffer.size());
            start = end;
@@ -998,8 +998,8 @@ NetworkEngine::sendNodesValues(const SockAddr& addr, Tid tid, const Blob& nodes,
            auto fields = query.select.getSelection();
            pk.pack(KEY_REQ_FIELDS);
            pk.pack_map(2);
-            pk.pack(std::string("f")); pk.pack(fields);
-            pk.pack(std::string("v")); pk.pack_array(st.size()*fields.size());
+            pk.pack("f"sv); pk.pack(fields);
+            pk.pack("v"sv); pk.pack_array(st.size()*fields.size());
            for (const auto& v : st)
                v->msgpack_pack_fields(fields, pk);
            //DHT_LOG_DBG("sending closest nodes (%d+%d nodes.), %u value headers containing %u fields",
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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-2020 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>
 *
@@ -137,10 +137,7 @@ Node::openSocket(SocketCb&& cb)
    if (++transaction_id == 0)
        transaction_id = 1;

-    auto sock = std::make_shared<Socket>(std::move(cb));
-    auto s = sockets_.emplace(transaction_id, std::move(sock));
-    if (not s.second)
-        s.first->second = std::move(sock);
+    sockets_[transaction_id] = std::make_shared<Socket>(std::move(cb));
    return transaction_id;
 }

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2020 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
Author	SHA1	Message	Date
Adrien Béraud	7987229145	unit tests: wait 1ms between puts	2022-04-03 17:16:24 -04:00
Adrien Béraud	966e6205ce	ci/github: add macOS build action	2022-04-03 16:53:54 -04:00
Adrien Béraud	7915b987ec	misc: use more string_view	2022-04-02 17:14:36 -04:00
Adrien Béraud	29bdc1a46f	Revert "cmake: check atomic for `RISC-V` architecture" Reason for partial revert: Adding the atomic library is meant by CheckAtomic to be automatic through CMAKE_REQUIRED_LIBRARIES.	2022-04-01 19:35:15 -04:00
Adrien Béraud	e0d32e80fb	build/dev: use gdb on linux, llvm on macOS with vscode tasks	2022-04-01 19:17:44 -04:00
Sprite	e753d200c6	cmake: fix incorrect variable name	2022-04-01 11:30:47 -04:00
Sprite	85fd395c52	cmake: simplify atomic checks	2022-04-01 11:30:47 -04:00
Sprite	0f146a354b	cmake: check atomic for `RISC-V` architecture	2022-04-01 11:30:47 -04:00
Adrien Béraud	9fcaca9232	build/dev: add tests to vscode tasks	2022-04-01 11:09:01 -04:00
Adrien Béraud	1bc65bc5f5	network engine: use string_view for better performance	2022-04-01 11:04:59 -04:00
Adrien Béraud	478d28a326	dhtnode: display total count of values for get and listen	2022-03-30 17:56:39 -04:00
Adrien Béraud	4d544d53a8	ci: use scan-build with debug mode	2022-03-29 15:07:24 -04:00
Adrien Béraud	694c44bbec	value: use namespace std::literals	2022-03-29 14:54:59 -04:00
Adrien Béraud	16915ff424	build/dev: add vscode devcontainer and dhtnode task	2022-03-29 14:47:42 -04:00
Adrien Béraud	a22566599c	proxy client: fix building Listener map	2022-03-29 14:47:42 -04:00
Adrien Béraud	f9b2285593	use string view literals where relevant	2022-03-29 14:47:01 -04:00
Adrien Béraud	9c2268fa41	fix various cppcheck warnings/errors	2022-03-29 10:15:00 -04:00
Adrien Béraud	d4e6fd545a	search: use const for iterator comparison	2022-03-24 21:33:51 -04:00
Adrien Béraud	dfd0a09361	ci/github: add Clang static analysis	2022-03-23 18:32:26 -04:00
Adrien Béraud	0afa40820a	autotools: update m4 for C++17	2022-03-23 17:49:14 -04:00
Adrien Béraud	f984a6a69a	ci/github: update to checkout@v3	2022-03-23 17:25:23 -04:00
Adrien Béraud	b4bbc6ae38	update readme	2022-03-23 15:43:31 -04:00
Adrien Béraud	bc98d974cb	ci: remove travis	2022-03-23 15:43:24 -04:00
Adrien Béraud	785e54838b	docker: fix Bionic (Ubuntu 18.04) support	2022-03-23 15:19:29 -04:00
Adrien Béraud	bb7611fc3d	docker: build with tools, peer discovery	2022-03-23 14:42:02 -04:00
Adrien Béraud	f675a6bdd3	python: adapt for C++17	2022-03-23 14:28:12 -04:00
Adrien Béraud	21a71b1559	proxy server: support c++17	2022-03-23 13:35:30 -04:00
Adrien Béraud	ca5455302d	value: support std::string_view	2022-03-23 13:35:14 -04:00
Adrien Béraud	f206a8ac9e	infohash: support std::string_view	2022-03-23 13:15:37 -04:00
Adrien Béraud	0c4cec66ff	update Dockerfiles, remove Travis	2022-03-23 12:04:26 -04:00
Adrien Béraud	a03124d889	build: use C++17	2022-03-22 17:02:31 -04:00
Adrien Béraud	9691746fde	build: remove OPENDHT_LTO	2022-03-22 17:02:31 -04:00
Adrien Béraud	d7c9311014	update dockerfiles	2022-03-22 17:02:31 -04:00
Adrien Béraud	290e8594b6	update copyright	2022-03-21 11:32:56 -04:00
Adrien Béraud	c59f951e5a	update copyright	2022-03-10 19:51:25 -05:00
Adrien Béraud	6919a34f88	c: add license header	2022-03-10 19:49:53 -05:00
Adrien Béraud	3480bb1098	c: include errno.h	2022-03-10 19:49:00 -05:00
Adrien Béraud	27b8c870f3	c: add dht_privatekey_decrypt, handle crypto exceptions	2022-03-10 19:46:25 -05:00
Adrien Béraud	be43212a73	c: add callback to dht_runner_ping	2022-03-10 19:45:29 -05:00
Adrien Béraud	f0b9bc56a6	c: add dht_runner_is_running, dht_runner_get_bound_port	2022-03-10 19:43:58 -05:00
Adrien Béraud	5654816f5a	dhtrunner: re-throw exception directly in init	2022-03-10 19:43:10 -05:00
Adrien Béraud	b0fb476d97	dhtrunner: pass function argument by value	2022-03-10 19:42:37 -05:00
Adrien Béraud	fada8d067d	c: handle exception during initialization	2022-03-10 19:10:24 -05:00
Adrien Béraud	90022ee3e8	build: update version to 2.3.5	2022-03-09 14:33:25 -05:00
Adrien Béraud	de68a47a16	dhtrunner: handle exception during initialization	2022-03-09 14:32:22 -05:00
Adrien Béraud	714af68292	c: specify void argument for dht_runner_new	2022-03-03 14:44:52 -05:00
Adrien Béraud	e6768edaf0	build: update version to 2.3.4	2022-03-01 19:54:43 -05:00
Adrien Béraud	6145e54543	cmake: update CheckAtomic	2022-02-28 12:37:49 -05:00
Adrien Béraud	ac51c2300e	dht: remove canceled tasks from scheduler	2022-02-27 03:34:36 -05:00
Adrien Béraud	f590980c3e	infohash: include cstddef	2022-02-27 03:34:36 -05:00
Adrien Béraud	5dbade3d0b	value cache: move to lambda	2022-02-26 22:16:15 -05:00
Adrien Béraud	2028d4b13e	build: update version to 2.3.3	2022-02-25 23:52:26 -05:00
Adrien Béraud	a6f7b49b92	build: use msgpack cmake	2022-02-25 23:52:15 -05:00
Adrien Béraud	c2415f38fa	dht: avoid job & search leak	2022-02-24 13:33:42 -05:00
Adrien Béraud	9cf717ab43	tools/c: adapt include directory	2022-02-22 11:49:44 -05:00
Adrien Béraud	d4589bb6f6	tools/c: use new api	2022-02-22 11:49:44 -05:00
Adrien Béraud	484878aec3	c: add missing value apis	2022-02-22 11:49:44 -05:00
Adrien Béraud	ace3a94e08	scheduler: remove debug log This reverts commit `5d771e119c`.	2022-02-19 16:32:07 -05:00
Adrien Béraud	5d771e119c	c: install header to opendht directory	2022-02-19 12:33:31 -05:00
Adrien Béraud	8dcc695947	value: cleanup	2022-02-19 10:53:31 -05:00
Adrien Béraud	1ae28e07b6	storage: cleanup	2022-02-19 10:53:31 -05:00
Adrien Béraud	2de0737443	cmake: support some policies	2022-02-19 10:53:31 -05:00
Adrien Béraud	bc32f848cb	thread pool: cleanup	2022-02-19 10:53:31 -05:00
Adrien Béraud	edee6d63d6	build: use msgpack without boost	2022-02-19 10:49:25 -05:00
Adrien Béraud	af3f6f40bb	c: install header	2022-02-19 10:48:28 -05:00
Adrien Béraud	32f72c245d	dht: add max bootstrap period	2022-02-19 09:23:57 -05:00
Adrien Béraud	043ef8da72	dht: reset bootstrap period on connectivity change Also starts a bootstrap if disconnected.	2022-02-19 09:23:57 -05:00
Adrien Béraud	6812b733bb	dht: respect exponential backoff	2022-02-19 09:23:57 -05:00
Adrien Béraud	2ec28dcb83	dhtrunner: use configured logger for dropped packets	2022-02-19 09:23:57 -05:00
Adrien Béraud	db000a2f88	build: update version to 2.3.2	2022-01-26 14:17:57 -05:00
Adrien Béraud	59880df60e	perftest: cleanup	2022-01-26 14:16:33 -05:00
Adrien Béraud	75f1b07e7a	crypto: cleanup	2022-01-26 14:16:33 -05:00
Adrien Béraud	f191c4f636	storage: 0-init size_diff	2022-01-26 14:16:33 -05:00
Sébastien Blin	1b2bc7b1e3	crypto: add parameter to change Certificate's validity period This allow to create certificate with a different validity than 10 years and be able to change the expiration of a certificate	2022-01-19 14:51:45 -05:00
Bruno Pagani	a89e4d626e	tests: fix building with GCC11 Fixes `error: ‘sleep_for’ is not a member of ‘std::this_thread’`	2021-11-13 12:31:17 -05:00
Sébastien Blin	dbbfdaab0f	proxyclient: onConnectedCallbacks must be launched if started by notif	2021-10-27 13:45:30 -04:00
Sébastien Blin	536f30ec84	opendht.cpp: fix build	2021-10-22 11:03:12 -04:00
Adrien Béraud	b7aec1310c	crypto: make cachedId mutable	2021-09-16 11:28:59 -04:00
Adrien Béraud	31d76b1080	github: remove argon2 build	2021-09-16 11:19:10 -04:00
Adrien Béraud	2fbafc3591	crypto: cache Certificate Id	2021-09-16 11:08:02 -04:00
Adrien Béraud	19fe34415a	thread pool: fix build on MSVC	2021-09-15 16:45:56 -04:00
Sébastien Blin	2a50f85a30	proxy_server: set expiration for iOS devices	2021-09-10 10:21:31 -04:00
Sébastien Blin	26b71ab993	proxyclient: do not play with stop when resubscribing At this point we do not care for the request. Subscribes are instantaneous, so the request will be terminated at this point. Changing the stop status can cause some push notifications to be dropped if coming at this moment.	2021-09-10 10:21:31 -04:00
Sébastien Blin	04a78445c6	dht_proxy_server: increase ttl for push to 24 hours If the android device is offline during more than 10 minutes, it can misses push notifications and cause an incorrect state with values not expired even if the re-subscribe is correct.	2021-09-10 10:21:31 -04:00
Adrien Béraud	fa19897016	HexMap: align on 64 bits	2021-08-09 18:20:12 -04:00
Adrien Béraud	3806355509	gitignore: add DS_Store	2021-08-09 18:20:12 -04:00
Adrien Béraud	3f6738185b	tests: fix testIdOps()	2021-08-05 12:42:29 -04:00
Adrien Béraud	e58d09e5da	dht: always display value ID as hex	2021-08-05 12:42:29 -04:00
heroku-miraheze	71cd9d22c6	Moved to Libera.chat.	2021-07-19 11:25:59 -04:00
Adrien Béraud	6c58d4f2e9	build: update version to 2.3.0	2021-06-09 16:56:19 -04:00
Adrien Béraud	4070eecea7	gitignore: add tools	2021-06-09 16:56:19 -04:00
Adrien Béraud	ffb53ceb1d	thread pool: add ExecutionContext	2021-06-09 13:59:33 -04:00
Adrien Béraud	0c00544798	remove embedded argon2, HTTP_PARSER_FORK	2021-06-09 13:57:10 -04:00
Adrien Béraud	471d443e4a	tests: add multithread test	2021-06-07 14:45:58 -04:00
Adrien Béraud	ba9a445263	securedht: clenup	2021-06-07 14:45:58 -04:00
Adrien Béraud	056bc2850b	test putEncrypted(pk)	2021-06-07 14:45:58 -04:00
Adrien Béraud	b668d6ad68	dhtrunner: add putEncrypted with public key	2021-06-07 14:45:58 -04:00
Adrien Béraud	29fab5560f	dhtrunner: add getPublicKey()	2021-06-07 14:45:58 -04:00
Adrien Béraud	8aef63ce4a	crypto: cache public key	2021-06-07 14:45:58 -04:00
Adrien Béraud	1ea7a2994e	value: use non-const PublicKey	2021-06-07 14:45:58 -04:00
Adrien Béraud	208b3fa6fe	SignedValue: add owner	2021-06-07 14:45:58 -04:00
Adrien Béraud	d9ff95da49	Revert "dhtrunner: force execution of pending ops on shutdown" This reverts commit `c8a0b443f3`.	2021-06-07 14:45:58 -04:00
Adrien Béraud	c8a0b443f3	dhtrunner: force execution of pending ops on shutdown	2021-06-03 16:54:31 -04:00
Adrien Béraud	00e595d737	dht: fail if op key is null	2021-06-03 16:54:31 -04:00