uv

tcp
wip
2026-11-09 12:57:03 +00:00 · 2017-10-17 19:00:53 +02:00 · 2017-10-17 19:00:53 +02:00 · 2017-10-17 19:00:53 +02:00 · 2017-10-17 19:00:52 +02:00 · 2017-10-17 19:00:13 +02:00
41 changed files with 2766 additions and 1714 deletions
@@ -1,7 +1,7 @@
 cmake_minimum_required (VERSION 3.1)
 project (opendht)
 set (opendht_VERSION_MAJOR 1)
-set (opendht_VERSION_MINOR 3.6)
+set (opendht_VERSION_MINOR 4.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -15,10 +15,17 @@ option (OPENDHT_TOOLS "Build DHT tools" ON)
 option (OPENDHT_SYSTEMD "Install systemd module" OFF)
 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)
+
+find_package(Doxygen)
+option (OPENDHT_DOCUMENTATION "Create and install the HTML based API documentation (requires Doxygen)" ${DOXYGEN_FOUND})

 # Dependencies
 list (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+find_package (Threads)
 find_package (PkgConfig)
+pkg_search_module(libuv libuv)
+pkg_search_module(libsodium libsodium)
 find_package (GnuTLS 3.3 REQUIRED)
 pkg_search_module (Nettle nettle)
 find_package (Msgpack 1.2 REQUIRED)
@@ -26,7 +33,6 @@ if (OPENDHT_TOOLS)
    find_package (Readline 6 REQUIRED)
 endif ()
 if (NOT OPENDHT_ARGON2)
-    find_package(PkgConfig)
    pkg_search_module(argon2 libargon2)
    if (argon2_FOUND)
        message("Argon2 found " ${argon2_req})
@@ -38,9 +44,12 @@ if (NOT OPENDHT_ARGON2)
 endif ()

 # Build flags
-set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD 14)
 set (CMAKE_CXX_STANDARD_REQUIRED on)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor -pedantic-errors -fvisibility=hidden")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor -pedantic-errors -fvisibility=hidden")
+if (OPENDHT_SANITIZE)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fstack-protector-strong")
+endif ()
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")
 if (NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
@@ -69,7 +78,13 @@ endif ()
 if (Nettle_INCLUDE_DIRS)
    include_directories (SYSTEM "${Nettle_INCLUDE_DIRS}")
 endif ()
-link_directories (${Nettle_LIBRARY_DIRS})
+if (libuv_INCLUDE_DIRS)
+    include_directories (SYSTEM "${libuv_INCLUDE_DIRS}")
+endif ()
+if (libsodium_INCLUDE_DIRS)
+    include_directories (SYSTEM "${libsodium_INCLUDE_DIRS}")
+endif ()
+link_directories (${libuv_LIBRARY_DIRS} ${libsodium_LIBRARY_DIRS} ${Nettle_LIBRARY_DIRS})
 include_directories (
    ./
    include/
@@ -85,6 +100,7 @@ set (libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
 set (includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
 set (bindir "${CMAKE_INSTALL_FULL_BINDIR}")
 set (sysconfdir "${CMAKE_INSTALL_FULL_SYSCONFDIR}")
+set (top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")

 # Sources
 list (APPEND opendht_SOURCES
@@ -98,6 +114,7 @@ list (APPEND opendht_SOURCES
    src/storage.h
    src/listener.h
    src/search.h
+    src/parsed_message.h
    src/request.h
    src/callbacks.cpp
    src/routing_table.cpp
@@ -167,7 +184,7 @@ if (OPENDHT_STATIC)
        target_link_libraries(opendht-static ${argon2_LIBRARIES})
        target_include_directories(opendht-static SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
    endif ()
-    target_link_libraries(opendht-static ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES})
+    target_link_libraries(opendht-static ${CMAKE_THREAD_LIBS_INIT} ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES} ${libuv_LIBRARIES} ${libsodium_LIBRARIES})
    install (TARGETS opendht-static DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht)
 endif ()

@@ -180,15 +197,15 @@ if (OPENDHT_SHARED)
    set_target_properties (opendht PROPERTIES SOVERSION ${opendht_VERSION_MAJOR} VERSION ${opendht_VERSION})
    target_compile_definitions(opendht PRIVATE OPENDHT_BUILD)
    if (OPENDHT_LTO)
-        target_link_libraries(opendht -flto -fuse-linker-plugin)
+        target_link_libraries(opendht PRIVATE -flto -fuse-linker-plugin)
    endif ()
    if (OPENDHT_ARGON2)
        target_include_directories(opendht SYSTEM PRIVATE argon2)
    else ()
-        target_link_libraries(opendht ${argon2_LIBRARIES})
+        target_link_libraries(opendht PRIVATE ${argon2_LIBRARIES})
        target_include_directories(opendht SYSTEM PRIVATE ${argon2_INCLUDE_DIRS})
    endif ()
-    target_link_libraries(opendht  ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES})
+    target_link_libraries(opendht PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${GNUTLS_LIBRARIES} ${Nettle_LIBRARIES} ${libuv_LIBRARIES} ${libsodium_LIBRARIES})
    install (TARGETS opendht DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht)
 endif ()

@@ -1,7 +1,7 @@
 dnl define macros
 m4_define([opendht_major_version], 1)
-m4_define([opendht_minor_version], 3)
-m4_define([opendht_patch_version], 6)
+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])

@@ -1,3 +1,16 @@
 if (OPENDHT_TOOLS)
 	INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/dhtnode.1 DESTINATION ${CMAKE_INSTALL_PREFIX}/share/man/man1)
 endif ()
+
+if (OPENDHT_DOCUMENTATION)
+    if (NOT DOXYGEN_FOUND)
+         message(FATAL_ERROR "Doxygen is needed to build the documentation.")
+    endif()
+    configure_file (Doxyfile.in Doxyfile @ONLY)
+    add_custom_target(doc ALL
+                      COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+                      COMMENT "Generating API documentation with Doxygen"
+                      VERBATIM)
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION share/doc/opendht)
+endif()
@@ -49,6 +49,12 @@ struct OPENDHT_PUBLIC NodeStats {
    std::string toString() const;
 };

+
+struct OPENDHT_PUBLIC NetworkConfig {
+    std::string bind_addr {"::0"};
+    in_port_t bind_port {0};
+};
+
 /**
 * Dht configuration.
 */
@@ -68,6 +74,8 @@ struct OPENDHT_PUBLIC Config {

    /** Makes the DHT responsible to maintain its stored values. Consumes more ressources. */
    bool maintain_storage;
+
+    NetworkConfig network_config;
 };

 /**
@@ -87,6 +95,7 @@ using QueryCallback = std::function<bool(const std::vector<std::shared_ptr<Field
 using GetCallback = std::function<bool(const std::vector<std::shared_ptr<Value>>& values)>;
 using GetCallbackSimple = std::function<bool(std::shared_ptr<Value> value)>;
 using ShutdownCallback = std::function<void()>;
+using StatusCallback = std::function<void(NodeStatus, NodeStatus)>;

 using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;

@@ -95,7 +104,7 @@ typedef bool (*GetCallbackRaw)(std::shared_ptr<Value>, void *user_data);
 OPENDHT_PUBLIC GetCallbackSimple bindGetCb(GetCallbackRaw raw_cb, void* user_data);
 OPENDHT_PUBLIC GetCallback bindGetCb(GetCallbackSimple cb);

-using DoneCallback = std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)>;
+using DoneCallback = std::function<void(bool success, std::vector<std::shared_ptr<Node>>&& nodes)>;
 typedef void (*DoneCallbackRaw)(bool, std::vector<std::shared_ptr<Node>>*, void *user_data);
 typedef void (*ShutdownCallbackRaw)(void *user_data);
 typedef void (*DoneCallbackSimpleRaw)(bool, void *user_data);
@@ -28,6 +28,8 @@ extern "C" {
 #include <gnutls/x509.h>
 }

+#include <sodium.h>
+
 #include <vector>
 #include <memory>

@@ -35,7 +37,13 @@ extern "C" {
 #include <iso646.h>
 #endif

+#include <sys/mman.h>
+
 namespace dht {
+
+/**
+ * Contains all crypto primitives
+ */
 namespace crypto {

 class OPENDHT_PUBLIC CryptoException : public std::runtime_error {
@@ -496,11 +504,19 @@ public:
    secure_vector() {}
    secure_vector(secure_vector<T> const&) = default;
    secure_vector(secure_vector<T> &&) = default;
-    explicit secure_vector(unsigned size): data_(size) {}
-    explicit secure_vector(unsigned size, T _item): data_(size, _item) {}
-    explicit secure_vector(const std::vector<T>& c): data_(c) {}
-    secure_vector(std::vector<T>&& c): data_(std::move(c)) {}
-    ~secure_vector() { clean(); }
+    explicit secure_vector(unsigned size): data_(size) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    explicit secure_vector(unsigned size, T _item): data_(size, _item) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    explicit secure_vector(const std::vector<T>& c): data_(c) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    secure_vector(std::vector<T>&& c): data_(std::move(c)) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    ~secure_vector() { clean(); munlock(data_.data(), data_.size()*sizeof(T)); }

    static secure_vector<T> getRandom(size_t size) {
        secure_vector<T> ret(size/sizeof(T));
@@ -513,24 +529,30 @@ public:
        if (&c == this)
            return *this;
        clean();
+        munlock(data_.data(), data_.size()*sizeof(T));
        data_ = c.data_;
+        mlock(data_.data(), data_.size()*sizeof(T));
        return *this;
    }
    secure_vector<T>& operator=(secure_vector<T>&& c) {
        if (&c == this)
            return *this;
        clean();
+        munlock(data_.data(), data_.size()*sizeof(T));
        data_ = std::move(c.data_);
        return *this;
    }
    secure_vector<T>& operator=(std::vector<T>&& c) {
        clean();
+        munlock(data_.data(), data_.size()*sizeof(T));
        data_ = std::move(c);
+        mlock(data_.data(), data_.size()*sizeof(T));
        return *this;
    }
    std::vector<T>& writable() { clean(); return data_; }
    const std::vector<T>& makeInsecure() const { return data_; }
    const uint8_t* data() const { return data_.data(); }
+    uint8_t* data() { return data_.data(); }

    void clean() {
        clean(data_.begin(), data_.end());
@@ -547,14 +569,17 @@ public:
        if (s < data_.size()) {
            //shrink
            clean(data_.begin()+s, data_.end());
+            munlock(data_.data()+s, (data_.size()-s)*sizeof(T));
            data_.resize(s);
        } else {
            //grow
            auto data = std::move(data_); // move protected data
            clear();
            data_.resize(s);
+            mlock(data_.data(), data_.size()*sizeof(T));
            std::copy(data.begin(), data.end(), data_.begin());
            clean(data.begin(), data.end());
+            munlock(data.data(), data.size()*sizeof(T));
        }
    }

@@ -571,8 +596,154 @@ private:
    std::vector<T> data_;
 };

+
+template <class T, size_t N>
+class OPENDHT_PUBLIC secure_array
+{
+public:
+    secure_array() {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    explicit secure_array(T _item): data_( _item) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    explicit secure_array(const std::array<T,N>& c): data_(c) {
+        mlock(data_.data(), data_.size()*sizeof(T));
+    }
+    secure_array(secure_array<T,N> const&) = default;
+    secure_array(secure_array<T,N> &&) = delete;
+    ~secure_array() { clean(); munlock(data_.data(), data_.size()*sizeof(T)); }
+
+    static secure_array<T,N> getRandom() {
+        secure_array<T,N> ret;
+        crypto::random_device rdev;
+        std::uniform_int_distribution<uint8_t> rand_byte;
+        std::generate_n((uint8_t*)ret.data_.data(), ret.size()*sizeof(T), std::bind(rand_byte, std::ref(rdev)));
+        return ret;
+    }
+    secure_array<T,N>& operator=(const secure_array<T,N>& c) {
+        if (&c == this)
+            return *this;
+        clean();
+        data_ = c.data_;
+        return *this;
+    }
+    secure_array<T,N>& operator=(secure_array<T,N>&& c) = delete;
+    std::array<T,N>& writable() { clean(); return data_; }
+    const std::array<T,N>& makeInsecure() const { return data_; }
+    const uint8_t* data() const { return data_.data(); }
+    uint8_t* data() { return data_.data(); }
+
+    void clean() {
+        clean(data_.begin(), data_.end());
+    }
+    size_t size() const { return data_.size(); }
+
+private:
+    /**
+     * Securely wipe memory
+     */
+    static void clean(const typename std::array<T,N>::iterator& i, const typename std::array<T,N>::iterator& j) {
+        volatile uint8_t* b = reinterpret_cast<uint8_t*>(&*i);
+        volatile uint8_t* e = reinterpret_cast<uint8_t*>(&*j);
+        std::fill(b, e, 0);
+    }
+
+    std::array<T, N> data_;
+};
+
+
 using SecureBlob = secure_vector<uint8_t>;

+/*class EcPublicKey : public std::array<uint8_t, crypto_box_PUBLICKEYBYTES> {
+public:
+    Blob encrypt(const Blob& message) const {
+        Blob ret(crypto_box_SEALBYTES+message.size());
+        crypto_box_seal(ret.data(), message.data(), message.size(), data());
+        return ret;
+    }
+
+    const InfoHash& getId() const {
+        return *reinterpret_cast<const InfoHash*>(this);
+    }
+
+};*/
+
+class EcSecretKey {
+public:
+    using KeyData = secure_array<uint8_t, crypto_box_SECRETKEYBYTES>;
+    using EcPublicKey = InfoHash;
+
+    static EcSecretKey generate() {
+        EcSecretKey ret;
+        crypto_box_keypair(ret.pk.data(), ret.key.data());
+        return ret;
+    }
+
+    const EcPublicKey& getPublicKey() const {
+        return pk;
+    }
+
+    Blob encrypt(const uint8_t* data, size_t size, const EcPublicKey& pub) const {
+        Blob ret(crypto_box_NONCEBYTES+crypto_box_MACBYTES+size);
+        randombytes_buf(ret.data(), crypto_box_NONCEBYTES);
+        if (crypto_box_easy(ret.data()+crypto_box_NONCEBYTES, data, size, ret.data(),
+                            pub.data(), key.data()) != 0) {
+            throw CryptoException("Can't encrypt data");
+        }
+        return ret;
+    }
+
+    Blob decrypt(const uint8_t* cypher, size_t cypher_size) const {
+        if (cypher_size <= crypto_box_SEALBYTES)
+            throw DecryptError("Unexpected cipher length");
+        Blob ret(cypher_size - crypto_box_SEALBYTES);
+        if (crypto_box_seal_open(ret.data(), cypher, cypher_size, pk.data(), key.data()) != 0) {
+            throw DecryptError("Can't decrypt data");
+        }
+        return ret;
+    }
+
+    Blob decrypt(const uint8_t* cypher, size_t cypher_size, const EcPublicKey& pub) const {
+        if (cypher_size <= crypto_box_NONCEBYTES+crypto_box_MACBYTES)
+            throw DecryptError("Unexpected cipher length");
+        Blob ret(cypher_size - crypto_box_NONCEBYTES - crypto_box_MACBYTES);
+        if (crypto_box_open_easy(ret.data(),
+                cypher+crypto_box_NONCEBYTES,
+                cypher_size-crypto_box_NONCEBYTES,
+                cypher,
+                pub.data(), key.data()) != 0) {
+            throw DecryptError("Can't decrypt data");
+        }
+        return ret;
+    }
+
+    SecureBlob computeSecret(const EcPublicKey& pub, bool sending) const {
+        // shared key = h(q ‖ client_publickey ‖ server_publickey)
+        crypto_generichash_state h;
+        crypto_generichash_init(&h, nullptr, 0U, crypto_generichash_BYTES);
+        {
+            std::array<uint8_t, crypto_scalarmult_BYTES> q;
+            if (auto err = crypto_scalarmult(q.data(), key.data(), pub.data()))
+                throw CryptoException("Can't compute secret: " + std::to_string(err));
+            crypto_generichash_update(&h, q.data(), q.size());
+        }
+        {
+            const auto& sender_pk = sending ? pk : pub;
+            const auto& receiver_pk = sending ? pub : pk;
+            crypto_generichash_update(&h, sender_pk.data(), sender_pk.size());
+            crypto_generichash_update(&h, receiver_pk.data(), receiver_pk.size());
+        }
+        SecureBlob ret(crypto_generichash_BYTES);
+        crypto_generichash_final(&h, ret.data(), ret.size());
+        return ret;
+    }
+
+private:
+    KeyData key;
+    EcPublicKey pk;
+};
+
 /**
 * Generate an RSA key pair (4096 bits) and a certificate.
 * @param name the name used in the generated certificate
@@ -604,18 +775,18 @@ OPENDHT_PUBLIC Blob hash(const Blob& data, size_t hash_length = 512/8);
 * that can be transmitted in clear, and will be generated if
 * not provided (32 bytes).
 */
-OPENDHT_PUBLIC Blob stretchKey(const std::string& password, Blob& salt, size_t key_length = 512/8);
+OPENDHT_PUBLIC SecureBlob stretchKey(const std::string& password, Blob& salt, size_t key_length = 512/8);

 /**
 * AES-GCM encryption. Key must be 128, 192 or 256 bits long (16, 24 or 32 bytes).
 */
-OPENDHT_PUBLIC Blob aesEncrypt(const Blob& data, const Blob& key);
+OPENDHT_PUBLIC Blob aesEncrypt(const Blob& data, const SecureBlob& key);
 OPENDHT_PUBLIC Blob aesEncrypt(const Blob& data, const std::string& password);

 /**
 * AES-GCM decryption.
 */
-OPENDHT_PUBLIC Blob aesDecrypt(const Blob& data, const Blob& key);
+OPENDHT_PUBLIC Blob aesDecrypt(const Blob& data, const SecureBlob& key);
 OPENDHT_PUBLIC Blob aesDecrypt(const Blob& data, const std::string& password);

 }
@@ -19,6 +19,7 @@
 #pragma once

 #include "value.h"
+#include "sockaddr.h"

 namespace dht {
 enum class ImStatus : uint8_t {
@@ -45,7 +46,7 @@ public:

    static Value::Filter getFilter() { return {}; }

-    static bool storePolicy(InfoHash key, std::shared_ptr<Value>& value, InfoHash from, const sockaddr* from_addr, socklen_t from_len);
+    static bool storePolicy(InfoHash key, std::shared_ptr<Value>& value, const InfoHash& from, const SockAddr&);

    static Value::Filter ServiceFilter(std::string s);

@@ -204,16 +205,12 @@ private:
 public:
    static const ValueType TYPE;

-    IpServiceAnnouncement(in_port_t p = 0) {
-        ss.ss_family = 0;
-        setPort(p);
+    IpServiceAnnouncement(sa_family_t family = AF_UNSPEC, in_port_t p = 0) {
+        addr.setFamily(family);
+        addr.setPort(p);
    }

-    IpServiceAnnouncement(const sockaddr* sa, socklen_t sa_len) {
-        ss.ss_family = 0;
-        if (sa)
-            std::copy_n((const uint8_t*)sa, sa_len, (uint8_t*)&ss);
-    }
+    IpServiceAnnouncement(const SockAddr& sa) : addr(sa) {}

    IpServiceAnnouncement(const Blob& b) {
        msgpack_unpack(unpackMsg(b).get());
@@ -222,53 +219,40 @@ public:
    template <typename Packer>
    void msgpack_pack(Packer& pk) const
    {
-        pk.pack_array(2);
-        pk.pack(reinterpret_cast<const sockaddr_in*>(&ss)->sin_port);
-        if (ss.ss_family == AF_INET) {
-            pk.pack_bin(sizeof(in_addr));
-            pk.pack_bin_body((const char*)&reinterpret_cast<const sockaddr_in*>(&ss)->sin_addr, sizeof(in_addr));
-        } else if (ss.ss_family == AF_INET6) {
-            pk.pack_bin(sizeof(in6_addr));
-            pk.pack_bin_body((const char*)&reinterpret_cast<const sockaddr_in6*>(&ss)->sin6_addr, sizeof(in6_addr));
-        }
+        pk.pack_bin(addr.getLength());
+        pk.pack_bin_body((const char*)addr.get(), addr.getLength());
    }

    virtual void msgpack_unpack(msgpack::object o)
    {
-        if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
-        if (o.via.array.size < 2) throw msgpack::type_error();
-        reinterpret_cast<sockaddr_in*>(&ss)->sin_port = o.via.array.ptr[0].as<in_port_t>();
-        auto ip_dat = o.via.array.ptr[1].as<Blob>();
-        if (ip_dat.size() == sizeof(in_addr))
-            std::copy(ip_dat.begin(), ip_dat.end(), (char*)&reinterpret_cast<sockaddr_in*>(&ss)->sin_addr);
-        else if (ip_dat.size() == sizeof(in6_addr))
-            std::copy(ip_dat.begin(), ip_dat.end(), (char*)&reinterpret_cast<sockaddr_in6*>(&ss)->sin6_addr);
+        if (o.type == msgpack::type::BIN)
+            addr = {(sockaddr*)o.via.bin.ptr, (socklen_t)o.via.bin.size};
        else
            throw msgpack::type_error();
    }

    in_port_t getPort() const {
-        return ntohs(reinterpret_cast<const sockaddr_in*>(&ss)->sin_port);
+        return addr.getPort();
    }
    void setPort(in_port_t p) {
-        reinterpret_cast<sockaddr_in*>(&ss)->sin_port = htons(p);
+        addr.setPort(p);
    }

-    sockaddr_storage getPeerAddr() const {
-        return ss;
+    const SockAddr& getPeerAddr() const {
+        return addr;
    }

    virtual const ValueType& getType() const {
        return TYPE;
    }

-    static bool storePolicy(InfoHash, std::shared_ptr<Value>&, InfoHash, const sockaddr*, socklen_t);
+    static bool storePolicy(InfoHash, std::shared_ptr<Value>&, const InfoHash&, const SockAddr&);

    /** print value for debugging */
    friend std::ostream& operator<< (std::ostream&, const IpServiceAnnouncement&);

 private:
-    sockaddr_storage ss;
+    SockAddr addr;
 };


@@ -54,9 +54,6 @@ struct LocalListener;
 /**
 * Main Dht class.
 * Provides a Distributed Hash Table node.
- *
- * Must be given open UDP sockets and ::periodic must be
- * called regularly.
 */
 class OPENDHT_PUBLIC Dht {
 public:
@@ -73,13 +70,13 @@ public:
     * Initialise the Dht with two open sockets (for IPv4 and IP6)
     * and an ID for the node.
     */
-    Dht(int s, int s6, Config config);
+    Dht(uv_loop_t* loop, Config config);
    virtual ~Dht();

    /**
     * Get the ID of the node.
     */
-    inline const InfoHash& getNodeId() const { return myid; }
+    inline const InfoHash& getNodeId() const { return network_engine.getNodeId(); }

    /**
     * Get the current status of the node for the given family.
@@ -89,6 +86,9 @@ public:
    NodeStatus getStatus() const {
        return std::max(getStatus(AF_INET), getStatus(AF_INET6));
    }
+    void setOnStatusChanged(StatusCallback&& cb) {
+        statusCb = std::move(cb);
+    }

    /**
     * Performs final operations before quitting.
@@ -136,13 +136,13 @@ public:
        insertNode(n.id, SockAddr(n.ss, n.sslen));
    }

-    void pingNode(const sockaddr*, socklen_t, DoneCallbackSimple&& cb={});
-
-    time_point periodic(const uint8_t *buf, size_t buflen, const SockAddr&);
-    time_point periodic(const uint8_t *buf, size_t buflen, const sockaddr* from, socklen_t fromlen) {
-        return periodic(buf, buflen, SockAddr(from, fromlen));
+    void bootstrap(const std::string& host, const std::string& service);
+    void clearBootstrap() {
+        bootstrap_nodes.clear();
    }

+    void pingNode(const SockAddr&, DoneCallback&& cb={});
+
    /**
     * Get a value by searching on all available protocols (IPv4, IPv6),
     * and call the provided get callback when values are found at key.
@@ -168,8 +168,8 @@ public:
     * @param key the key for which to query data for.
     * @param cb a function called when new values are found on the network.
     *           It should return false to stop the operation.
-     * @param donecb a function called when the operation is complete.
-                     cb and donecb won't be called again afterward.
+     * @param done_cb a function called when the operation is complete.
+                     cb and done_cb won't be called again afterward.
     * @param q a query used to filter values on the remotes before they send a
     *          response.
     */
@@ -307,6 +307,10 @@ public:

    std::vector<SockAddr> getPublicAddress(sa_family_t family = 0);

+    SockAddr getBoundAddr() {
+        return network_engine.getBoundAddr();
+    }
+
 protected:
    Logger DHT_LOG;
    bool logFilerEnable_ {};
@@ -378,6 +382,8 @@ private:
    const bool is_bootstrap {false};
    const bool maintain_storage {false};

+    std::vector<std::pair<std::string,std::string>> bootstrap_nodes {};
+
    // the stuff
    RoutingTable buckets4 {};
    RoutingTable buckets6 {};
@@ -400,9 +406,7 @@ private:

    // timing
    Scheduler scheduler;
-    Sp<Scheduler::Job> nextNodesConfirmation {};
-    Sp<Scheduler::Job> nextStorageMaintenance {};
-    time_point mybucket_grow_time {time_point::min()}, mybucket6_grow_time {time_point::min()};
+    Sp<Job> nextNodesConfirmation {};

    net::NetworkEngine network_engine;
    unsigned pending_pings4 {0};
@@ -410,9 +414,13 @@ private:

    using ReportedAddr = std::pair<unsigned, SockAddr>;
    std::vector<ReportedAddr> reported_addr;
-
    std::mt19937_64 rd {crypto::getSeededRandomEngine<std::mt19937_64>()};
+    
+    NodeStatus status4 {NodeStatus::Disconnected},
+               status6 {NodeStatus::Disconnected};
+    StatusCallback statusCb {nullptr};

+    void updateStatus();
    void rotateSecrets();

    Blob makeToken(const SockAddr&, bool old) const;
@@ -422,7 +430,7 @@ private:

    // Storage
    void storageAddListener(const InfoHash& id, const Sp<Node>& node, size_t tid, Query&& = {});
-    bool storageStore(const InfoHash& id, const Sp<Value>& value, time_point created, const SockAddr* sa = nullptr);
+    bool storageStore(const InfoHash& id, const Sp<Value>& value, time_point created, const SockAddr& sa = {});
    void expireStore();
    void expireStorage(InfoHash h);
    void expireStore(decltype(store)::iterator);
@@ -505,7 +513,7 @@ private:
     * @param query   The query sent to the node.
     */
    void searchNodeGetDone(const net::Request& status,
-            net::NetworkEngine::RequestAnswer&& answer,
+            net::RequestAnswer&& answer,
            std::weak_ptr<Search> ws,
            Sp<Query> query);

@@ -554,48 +562,46 @@ private:

    bool neighbourhoodMaintenance(RoutingTable&);

-    void processMessage(const uint8_t *buf, size_t buflen, const SockAddr&);
-
    void onError(Sp<net::Request> node, net::DhtProtocolException e);
    /* when our address is reported by a distant peer. */
    void onReportedAddr(const InfoHash& id, const SockAddr&);
    /* when we receive a ping request */
-    net::NetworkEngine::RequestAnswer onPing(Sp<Node> node);
+    net::RequestAnswer onPing(Sp<Node> node);
    /* when we receive a "find node" request */
-    net::NetworkEngine::RequestAnswer onFindNode(Sp<Node> node, const InfoHash& hash, want_t want);
+    net::RequestAnswer onFindNode(Sp<Node> node, const InfoHash& hash, want_t want);
    void onFindNodeDone(const Sp<Node>& status,
-            net::NetworkEngine::RequestAnswer& a,
+            net::RequestAnswer& a,
            Sp<Search> sr);
    /* when we receive a "get values" request */
-    net::NetworkEngine::RequestAnswer onGetValues(Sp<Node> node,
+    net::RequestAnswer onGetValues(Sp<Node> node,
            const InfoHash& hash,
            want_t want,
            const Query& q);
    void onGetValuesDone(const Sp<Node>& status,
-            net::NetworkEngine::RequestAnswer& a,
+            net::RequestAnswer& a,
            Sp<Search>& sr,
            const Sp<Query>& orig_query);
    /* when we receive a listen request */
-    net::NetworkEngine::RequestAnswer onListen(Sp<Node> node,
+    net::RequestAnswer onListen(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
            size_t socket_id,
            const Query& query);
    void onListenDone(const Sp<Node>& status,
-            net::NetworkEngine::RequestAnswer& a,
+            net::RequestAnswer& a,
            Sp<Search>& sr);
    /* when we receive an announce request */
-    net::NetworkEngine::RequestAnswer onAnnounce(Sp<Node> node,
+    net::RequestAnswer onAnnounce(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
            const std::vector<Sp<Value>>& v,
            const time_point& created);
-    net::NetworkEngine::RequestAnswer onRefresh(Sp<Node> node,
+    net::RequestAnswer onRefresh(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
            const Value::Id& vid);
    void onAnnounceDone(const Sp<Node>& status,
-            net::NetworkEngine::RequestAnswer& a,
+            net::RequestAnswer& a,
            Sp<Search>& sr);
 };

@@ -26,6 +26,7 @@
 #include "sockaddr.h"
 #include "log_enable.h"
 #include "def.h"
+#include "uv_utils.h"

 #include <thread>
 #include <mutex>
@@ -51,8 +52,6 @@ struct SecureDhtConfig;
 class OPENDHT_PUBLIC DhtRunner {

 public:
-    typedef std::function<void(NodeStatus, NodeStatus)> StatusCallback;
-
    DhtRunner();
    virtual ~DhtRunner();

@@ -202,8 +201,11 @@ public:
     * 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(const std::vector<std::pair<sockaddr_storage, socklen_t>>& nodes, DoneCallbackSimple&& cb={});
-    void bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb={});
+    void ping(const std::vector<std::pair<sockaddr_storage, socklen_t>>& nodes, DoneCallback&& cb={});
+    void ping(const SockAddr& addr, DoneCallback&& cb={});
+    void ping(const SockAddr& addr, DoneCallbackSimple&& cb={}) {
+        ping(addr, bindDoneCb(cb));
+    }

    /**
     * Insert known nodes to the routing table, without necessarly ping them.
@@ -241,16 +243,14 @@ public:
     * Returns the currently bound address.
     * @param f: address family of the bound address to retreive.
     */
-    const SockAddr& getBound(sa_family_t f = AF_INET) const {
-        return (f == AF_INET) ? bound4 : bound6;
-    }
+    SockAddr getBound() const;

    /**
     * Returns the currently bound port, in host byte order.
     * @param f: address family of the bound port to retreive.
     */
-    in_port_t getBoundPort(sa_family_t f = AF_INET) const {
-        return ntohs(((sockaddr_in*)&getBound(f).first)->sin_port);
+    in_port_t getBoundPort() const {
+        return getBound().getPort();
    }

    std::pair<size_t, size_t> getStoreSize() const;
@@ -306,20 +306,24 @@ public:
     * @param cb: Optional callback to receive general state information.
     */
    void run(in_port_t port, const crypto::Identity identity, bool threaded = false, NetId network = 0) {
-        run(port, {
+        run({
            /*.dht_config = */{
                /*.node_config = */{
                    /*.node_id = */{},
                    /*.network = */network,
                    /*.is_bootstrap = */false,
-                    /*.maintain_storage*/false
+                    /*.maintain_storage = */false,
+                    /* .network_config = */{
+                        /*.addr = */ "::0",
+                        /*.port = */ port
+                    }
                },
                /*.id = */identity
            },
            /*.threaded = */threaded
        });
    }
-    void run(in_port_t port, Config config);
+    void run(Config config);

    /**
     * @param local4: Local IPv4 address and port to bind. Can be null.
@@ -329,25 +333,22 @@ public:
     * @param threaded: If false, loop() must be called periodically. Otherwise a thread is launched.
     * @param cb: Optional callback to receive general state information.
     */
-    void run(const sockaddr_in* local4, const sockaddr_in6* local6, Config config);
+    //void run(const sockaddr_in* local4, const sockaddr_in6* local6, Config config);

    /**
     * Same as @run(sockaddr_in, sockaddr_in6, Identity, bool, StatusCallback), but with string IP addresses and service (port).
     */
-    void run(const char* ip4, const char* ip6, const char* service, Config config);
+    //void run(const char* ip4, const char* ip6, const char* service, Config config);

-    void setOnStatusChanged(StatusCallback&& cb) {
-        statusCb = std::move(cb);
-    }
+    void setOnStatusChanged(StatusCallback&& cb);

    /**
     * In non-threaded mode, the user should call this method
     * regularly and everytime a new packet is received.
     * @return the next op
     */
-    time_point loop() {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        return loop_();
+    void loop() {
+        uv_loop_.runOnce();
    }

    /**
@@ -373,33 +374,41 @@ private:
     */
    void tryBootstrapContinuously();

-    void doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDhtConfig config);
-    time_point loop_();
+    void doRun(SecureDhtConfig config);
+    void loop_();

    static std::vector<std::pair<sockaddr_storage, socklen_t>> getAddrInfo(const std::string& host, const std::string& service);

-    NodeStatus getStatus() const {
-        return std::max(status4, status6);
+    void loopCallback() {
+        std::lock_guard<std::mutex> lck(dht_mtx);
+        if (running)
+            loop_();
+        else {
+            uv_close((uv_handle_t*)&uv_async_, nullptr);
+            uv_loop_.stop();
+        }
+    }
+
+    static void loop_callback(uv_async_t* handle) {
+        if (handle->data)
+            static_cast<DhtRunner*>(handle->data)->loopCallback();
    }

    std::unique_ptr<SecureDht> dht_;
+    EventLoop uv_loop_;
+    uv_async_t uv_async_;
    mutable std::mutex dht_mtx {};
    std::thread dht_thread {};
-    std::condition_variable cv {};
-
-    std::thread rcv_thread {};
-    std::mutex sock_mtx {};
-    std::vector<std::pair<Blob, SockAddr>> rcv {};

    /** true if currently actively boostraping */
    std::atomic_bool bootstraping {false};
    /* bootstrap nodes given as (host, service) pairs */
-    std::vector<std::pair<std::string,std::string>> bootstrap_nodes_all {};
+    /*std::vector<std::pair<std::string,std::string>> bootstrap_nodes_all {};
    std::vector<std::pair<std::string,std::string>> bootstrap_nodes {};
-    std::thread bootstrap_thread {};
+    std::thread bootstrap_thread {};*/
    /** protects bootstrap_nodes, bootstrap_thread */
-    std::mutex bootstrap_mtx {};
-    std::condition_variable bootstrap_cv {};
+    /*std::mutex bootstrap_mtx {};
+    std::condition_variable bootstrap_cv {};*/

    std::queue<std::function<void(SecureDht&)>> pending_ops_prio {};
    std::queue<std::function<void(SecureDht&)>> pending_ops {};
@@ -407,12 +416,12 @@ private:

    std::atomic<bool> running {false};

-    NodeStatus status4 {NodeStatus::Disconnected},
+    /*NodeStatus status4 {NodeStatus::Disconnected},
               status6 {NodeStatus::Disconnected};
    StatusCallback statusCb {nullptr};

    SockAddr bound4 {};
-    SockAddr bound6 {};
+    SockAddr bound6 {};*/
 };

 }
@@ -22,6 +22,8 @@

 #include <msgpack.hpp>

+#include <sodium.h>
+
 #ifndef _WIN32
 #include <netinet/in.h>
 #include <netdb.h>
@@ -46,7 +48,7 @@ typedef uint16_t in_port_t;


 // bytes
-#define HASH_LEN 20u
+#define HASH_LEN crypto_box_PUBLICKEYBYTES

 namespace dht {

@@ -147,6 +149,12 @@ public:
            std::copy_n(h, HASH_LEN, begin());
    }

+    std::vector<uint8_t> encrypt(const uint8_t* msg, size_t msg_size) const {
+        std::vector<uint8_t> ret(crypto_box_SEALBYTES+msg_size);
+        crypto_box_seal(ret.data(), msg, msg_size, data());
+        return ret;
+    }
+
    /**
     * Constructor from an hexadecimal string (without "0x").
     * hex must be at least 2.HASH_LEN characters long.
@@ -242,17 +250,24 @@ public:
        num ^= (-b ^ num) & (1 << bit);
    }

-    double
-    toFloat() const
-    {
+    double toFloat() const {
+        using D = size_t;
        double v = 0.;
-        for (unsigned i = 0; i < std::min<size_t>(HASH_LEN, sizeof(unsigned)-1); i++)
-            v += *(cbegin()+i)/(double)(1<<(8*(i+1)));
+        for (size_t i = 0; i < std::min<size_t>(HASH_LEN, sizeof(D)-1); i++)
+            v += *(cbegin()+i) / (double)((D)1 << 8*(i+1));
        return v;
    }

-    bool
-    operator<(const InfoHash& o) const {
+    bool operator==(const InfoHash& h) const {
+        auto a = reinterpret_cast<const uint32_t*>(data());
+        auto b = reinterpret_cast<const uint32_t*>(h.data());
+        for (size_t i=0; i<(size()/sizeof(uint32_t)); i++)
+            if (a[i] != b[i])
+                return false;
+        return true;
+    }
+
+    bool operator<(const InfoHash& o) const {
        for(unsigned i = 0; i < HASH_LEN; i++) {
            if((*this)[i] != o[i])
                return (*this)[i] < o[i];
@@ -24,6 +24,10 @@
 #include <iostream>

 namespace dht {
+
+/**
+ * Logging-related functions
+ */
 namespace log {

 /**
@@ -42,41 +42,26 @@ struct TransPrefix : public std::array<uint8_t, 2> {
 struct TransId final : public std::array<uint8_t, 4> {
    static const constexpr uint16_t INVALID {0};

-    TransId() { std::fill_n(begin(), 4, 0); }
+    TransId() { std::fill(begin(), end(), 0); }
    TransId(const std::array<char, 4>& o) { std::copy(o.begin(), o.end(), begin()); }
    TransId(const TransPrefix prefix, uint16_t seqno = 0) {
        std::copy_n(prefix.begin(), prefix.size(), begin());
        *reinterpret_cast<uint16_t*>(data()+prefix.size()) = seqno;
    }
-
-    TransId(const char* q, size_t l) : array<uint8_t, 4>() {
-        if (l > 4) {
-            length = 0;
-        } else {
-            std::copy_n(q, l, begin());
-            length = l;
-        }
-    }
-
-    uint16_t getTid() const {
-        return *reinterpret_cast<const uint16_t*>(&(*this)[2]);
+    TransId(uint32_t id) {
+        *reinterpret_cast<uint32_t*>(data()) = htonl(id);
    }

    uint32_t toInt() const {
-        return *reinterpret_cast<const uint32_t*>(&(*this)[0]);
+        return ntohl(*reinterpret_cast<const uint32_t*>(&(*this)[0]));
    }

-    bool matches(const TransPrefix prefix, uint16_t* tid = nullptr) const {
-        if (std::equal(begin(), begin()+2, prefix.begin())) {
-            if (tid)
-                *tid = getTid();
-            return true;
-        } else
-            return false;
+    bool matches(const TransPrefix prefix) const {
+        return std::equal(begin(), begin()+2, prefix.begin());
    }
-
-    unsigned length {4};
 };

+TransId unpackTid(msgpack::object& o);
+
 } /* namespace net */
 } /* dht */
@@ -28,13 +28,14 @@
 #include "rng.h"
 #include "rate_limiter.h"
 #include "net.h"
+#include "callbacks.h"
+#include "uv_utils.h"

 #include <vector>
 #include <string>
 #include <functional>
 #include <algorithm>
 #include <memory>
-#include <random>
 #include <queue>

 namespace dht {
@@ -81,6 +82,20 @@ private:

 struct ParsedMessage;

+/**
+ * Answer for a request.
+ */
+struct RequestAnswer {
+    Blob ntoken {};
+    Value::Id vid {};
+    std::vector<Sp<Value>> values {};
+    std::vector<Sp<FieldValueIndex>> fields {};
+    std::vector<Sp<Node>> nodes4 {};
+    std::vector<Sp<Node>> nodes6 {};
+    RequestAnswer() {}
+    RequestAnswer(ParsedMessage&& msg);
+};
+
 /*!
 * @class   NetworkEngine
 * @brief   An abstraction of communication protocol on the network.
@@ -101,26 +116,6 @@ struct ParsedMessage;
 */
 class NetworkEngine final
 {
-public:
-    /*!
-     * @class   RequestAnswer
-     * @brief   Answer for a request.
-     * @details
-     * Answer for a request to be (de)serialized. Used for reponding to a node
-     * and looking up the response from a node.
-     */
-    struct RequestAnswer {
-        Blob ntoken {};
-        Value::Id vid {};
-        std::vector<Sp<Value>> values {};
-        std::vector<Sp<FieldValueIndex>> fields {};
-        std::vector<Sp<Node>> nodes4 {};
-        std::vector<Sp<Node>> nodes6 {};
-        RequestAnswer() {}
-        RequestAnswer(ParsedMessage&& msg);
-    };
-
-
 private:
    /**
     * Called when we receive an error message.
@@ -137,7 +132,7 @@ private:
    /**
     * Called when an addres is reported from a requested node.
     *
-     * @param h: id 
+     * @param h: id
     * @param saddr_len (type: socklen_t) lenght of the sockaddr struct.
     */
    std::function<void(const InfoHash&, const SockAddr&)> onReportedAddr;
@@ -206,12 +201,11 @@ private:
            const Value::Id&)> onRefresh {};

 public:
-    using SocketCb = std::function<void(const Sp<Node>&, RequestAnswer&&)>;
    using RequestCb = std::function<void(const Request&, RequestAnswer&&)>;
    using RequestExpiredCb = std::function<void(const Request&, bool)>;

-    NetworkEngine(Logger& log, Scheduler& scheduler);
-    NetworkEngine(InfoHash& myid, NetId net, int s, int s6, Logger& log, Scheduler& scheduler,
+    NetworkEngine(uv_loop_t*, Logger& log, Scheduler& scheduler);
+    NetworkEngine(uv_loop_t*, const NetworkConfig& config, NetId net, Logger& log, Scheduler& scheduler,
            decltype(NetworkEngine::onError) onError,
            decltype(NetworkEngine::onNewNode) onNewNode,
            decltype(NetworkEngine::onReportedAddr) onReportedAddr,
@@ -224,7 +218,16 @@ public:

    virtual ~NetworkEngine();

+    const InfoHash& getNodeId() const {
+        return id_key.getPublicKey();
+    }
+
    void clear();
+    void close(OnClose cb) {
+        sock->close(cb);
+        tcp_sock->close();
+        cache.closeAll();
+    }

    /**
     * Sends values (with closest nodes) to a listenner.
@@ -244,13 +247,7 @@ public:
            std::vector<Sp<Value>>&& values, const Query& q);

    bool isRunning(sa_family_t af) const;
-    inline want_t want () const { return dht_socket >= 0 && dht_socket6 >= 0 ? (WANT4 | WANT6) : -1; }
-
-    /**
-     * Cancel a request. Setting req->cancelled = true is not enough in the case
-     * a request is "persistent".
-     */
-    void cancelRequest(Sp<Request>& req);
+    inline want_t want () const { /*return dht_socket >= 0 && dht_socket6 >= 0 ? (WANT4 | WANT6) : -1;*/return WANT4 | WANT6; }

    void connectivityChanged(sa_family_t);

@@ -268,7 +265,7 @@ public:
     * @return the request with information concerning its success.
     */
    Sp<Request>
-        sendPing(Sp<Node> n, RequestCb&& on_done, RequestExpiredCb&& on_expired);
+        sendPing(const Sp<Node>& n, RequestCb&& on_done, RequestExpiredCb&& on_expired);
    /**
     * Send a "ping" request to a given node.
     *
@@ -280,8 +277,8 @@ public:
     * @return the request with information concerning its success.
     */
    Sp<Request>
-        sendPing(const sockaddr* sa, socklen_t salen, RequestCb&& on_done, RequestExpiredCb&& on_expired) {
-            return sendPing(std::make_shared<Node>(zeroes, sa, salen),
+        sendPing(const SockAddr& sa, RequestCb&& on_done, RequestExpiredCb&& on_expired) {
+            return sendPing(std::make_shared<Node>(zeroes, sa),
                    std::forward<RequestCb>(on_done),
                    std::forward<RequestExpiredCb>(on_expired));
        }
@@ -297,7 +294,7 @@ public:
     *
     * @return the request with information concerning its success.
     */
-    Sp<Request> sendFindNode(Sp<Node> n,
+    Sp<Request> sendFindNode(const Sp<Node>& n,
                             const InfoHash& hash,
                             want_t want,
                             RequestCb&& on_done,
@@ -316,7 +313,7 @@ public:
     *
     * @return the request with information concerning its success.
     */
-    Sp<Request> sendGetValues(Sp<Node> n,
+    Sp<Request> sendGetValues(const Sp<Node>& n,
                              const InfoHash& hash,
                              const Query& query,
                              want_t want,
@@ -345,7 +342,7 @@ public:
     *
     * @return the request with information concerning its success.
     */
-    Sp<Request> sendListen(Sp<Node> n,
+    Sp<Request> sendListen(const Sp<Node>& n,
                           const InfoHash& hash,
                           const Query& query,
                           const Blob& token,
@@ -366,7 +363,7 @@ public:
     *
     * @return the request with information concerning its success.
     */
-    Sp<Request> sendAnnounceValue(Sp<Node> n,
+    Sp<Request> sendAnnounceValue(const Sp<Node>& n,
                                  const InfoHash& hash,
                                  const Sp<Value>& v,
                                  time_point created,
@@ -386,43 +383,15 @@ public:
     *
     * @return the request with information concerning its success.
     */
-    Sp<Request> sendRefreshValue(Sp<Node> n,
+    Sp<Request> sendRefreshValue(const Sp<Node>& n,
                                 const InfoHash& hash,
                                 const Value::Id& vid,
                                 const Blob& token,
                                 RequestCb&& on_done,
                                 RequestExpiredCb&& on_expired);
-    /**
-     * Opens a socket on which a node will be able allowed to write for further
-     * additionnal updates following the response to a previous request.
-     *
-     * @param node  The node which will be allowed to write on this socket.
-     * @param cb    The callback to execute once updates arrive on the socket.
-     *
-     * @return the socket.
-     */
-    Sp<Socket> openSocket(const Sp<Node>& node, TransPrefix tp, SocketCb&& cb);
-
-    /**
-     * Closes a socket so that no further data will be red on that socket.
-     *
-     * @param socket  The socket to close.
-     */
-    void closeSocket(Sp<Socket> socket);
-
-    /**
-     * Parses a message and calls appropriate callbacks.
-     *
-     * @param buf  The buffer containing the binary message.
-     * @param buflen  The length of the buffer.
-     * @param from  The address info of the sender.
-     * @param fromlen  The length of the corresponding sockaddr structure.
-     * @param now  The time to adjust the clock in the network engine.
-     */
-    void processMessage(const uint8_t *buf, size_t buflen, const SockAddr& addr);

    Sp<Node> insertNode(const InfoHash& myid, const SockAddr& addr) {
-        auto n = cache.getNode(myid, addr, scheduler.time(), 0);
+        auto n = cache.getNode(myid, addr, {}, scheduler.time(), 0);
        onNewNode(n, 0);
        return n;
    }
@@ -440,6 +409,10 @@ public:
        return cache.getCachedNodes(id, sa_f, count);
    }

+    SockAddr getBoundAddr() {
+        return sock->getBoundAddr();
+    }
+
 private:

    struct PartialMessage;
@@ -447,7 +420,7 @@ private:
    /***************
     *  Constants  *
     ***************/
-    static constexpr long unsigned MAX_REQUESTS_PER_SEC {1600};
+    static constexpr size_t MAX_REQUESTS_PER_SEC {1600};
    /* the length of a node info buffer in ipv4 format */
    static const constexpr size_t NODE4_INFO_BUF_LEN {HASH_LEN + sizeof(in_addr) + sizeof(in_port_t)};
    /* the length of a node info buffer in ipv6 format */
@@ -467,9 +440,21 @@ private:
    static constexpr size_t MAX_PACKET_VALUE_SIZE {600};

    static const std::string my_v;
-    static std::mt19937 rd_device;

-    void process(std::unique_ptr<ParsedMessage>&&, const SockAddr& from);
+    /**
+     * Parses a message and calls appropriate callbacks.
+     *
+     * @param buf  The buffer containing the binary message.
+     * @param buflen  The length of the buffer.
+     * @param from  The address info of the sender.
+     * @param fromlen  The length of the corresponding sockaddr structure.
+     * @param now  The time to adjust the clock in the network engine.
+     */
+    void processMessage(const uint8_t* data, size_t size, const SockAddr& addr);
+    Sp<Node> processEncrypted(const msgpack::object& o, const SockAddr& from);
+    Sp<Node> process(const msgpack::object& o, const SockAddr& addr);
+
+    Sp<Node> process(std::unique_ptr<ParsedMessage>&&, const SockAddr& from, const Sp<TcpSocket>& s = {});

    bool rateLimit(const SockAddr& addr);

@@ -482,17 +467,7 @@ private:
     * Sends a request to a node. Request::MAX_ATTEMPT_COUNT attempts will
     * be made before the request expires.
     */
-    void sendRequest(Sp<Request>& request);
-
-    /**
-     * Generates a new request id, skipping the invalid id.
-     *
-     * @return the new id.
-     */
-    uint16_t getNewTid() {
-        ++transaction_id;
-        return transaction_id == TransId::INVALID ? ++transaction_id : transaction_id;
-    }
+    void sendRequest(const Sp<Request>& request);

    struct MessageStats {
        unsigned ping    {0};
@@ -504,20 +479,24 @@ private:
    };


-    // basic wrapper for socket sendto function
-    int send(const char *buf, size_t len, int flags, const SockAddr& addr);
+    int send(msgpack::sbuffer& msg, const Node& node, const Sp<TcpSocket>& sock = {});
+    int sendUDP(msgpack::sbuffer& msg, const SockAddr& addr);
+
+    int send(const Blob& msg, int flags, const Node& node, UdpSocket::OnSent&& cb);
+
+    void startTcp(const Sp<TcpSocket>& sock, const Sp<Node>& node = {});

    void sendValueParts(TransId tid, const std::vector<Blob>& svals, const SockAddr& addr);
-    std::vector<Blob> packValueHeader(msgpack::sbuffer&, const std::vector<Sp<Value>>&);
+    std::vector<Blob> packValueHeader(msgpack::sbuffer&, const std::vector<Sp<Value>>&, bool stream);
    void maintainRxBuffer(const TransId& tid);

    /*************
     *  Answers  *
     *************/
    /* answer to a ping  request */
-    void sendPong(const SockAddr& addr, TransId tid);
+    void sendPong(const Sp<Node>& node, TransId tid);
    /* answer to findnodes/getvalues request */
-    void sendNodesValues(const SockAddr& addr,
+    void sendNodesValues(const Sp<Node>& node,
            TransId tid,
            const Blob& nodes,
            const Blob& nodes6,
@@ -532,66 +511,42 @@ private:
            std::vector<Sp<Node>>& nodes,
            std::vector<Sp<Node>>& nodes6);
    /* answer to a listen request */
-    void sendListenConfirmation(const SockAddr& addr, TransId tid);
+    void sendListenConfirmation(const Sp<Node>& node, TransId tid);
    /* answer to put request */
-    void sendValueAnnounced(const SockAddr& addr, TransId, Value::Id);
+    void sendValueAnnounced(const Sp<Node>& node, TransId, Value::Id);
    /* answer in case of error */
-    void sendError(const SockAddr& addr,
+    void sendError(const Sp<Node>& node,
            TransId tid,
            uint16_t code,
            const std::string& message,
-            bool include_id=false);
+            bool include_id=false,
+            const Sp<TcpSocket>& sock= {});

    void deserializeNodes(ParsedMessage& msg, const SockAddr& from);

    /* DHT info */
-    const InfoHash& myid;
+    //const InfoHash& myid;
    const NetId network {0};
-    const int dht_socket {-1};
-    const int dht_socket6 {-1};
    const Logger& DHT_LOG;

+    Sp<UdpSocket> sock;
+    Sp<TcpSocket> tcp_sock;
+    std::set<Sp<TcpSocket>> pending_connect;
    NodeCache cache {};

-    /**
-     * A comparator to classify IP addresses, only considering the
-     * first 64 bits in IPv6.
-     */
-    struct cmpSockAddr {
-        bool operator()(const SockAddr& a, const SockAddr& b) const {
-            if (a.second != b.second)
-                return a.second < b.second;
-            socklen_t start, len;
-            switch(a.getFamily()) {
-                case AF_INET:
-                    start = offsetof(sockaddr_in, sin_addr);
-                    len = sizeof(in_addr);
-                    break;
-                case AF_INET6:
-                    start = offsetof(sockaddr_in6, sin6_addr);
-                    // don't consider more than 64 bits (IPv6)
-                    len = 8;
-                    break;
-                default:
-                    start = 0;
-                    len = a.second;
-                    break;
-            }
+    crypto::EcSecretKey id_key;
+    //crypto::EcSecretKey id_key;

-            return std::memcmp((uint8_t*)&a.first+start, (uint8_t*)&b.first+start, len) < 0;
-        }
-    };
    // global limiting should be triggered by at least 8 different IPs
    using IpLimiter = RateLimiter<MAX_REQUESTS_PER_SEC/8>;
    using IpLimiterMap = std::map<SockAddr, IpLimiter, SockAddr::ipCmp>;
    IpLimiterMap address_rate_limiter {};
    RateLimiter<MAX_REQUESTS_PER_SEC> rate_limiter {};
+    size_t limiter_maintenance {0};

    // requests handling
-    uint16_t transaction_id {1};
    std::map<TransId, Sp<Request>> requests {};
    std::map<TransId, PartialMessage> partial_messages;
-    std::map<TransId, Sp<Socket>> opened_sockets {};

    MessageStats in_stats {}, out_stats {};
    std::set<SockAddr> blacklist {};
@@ -22,36 +22,70 @@
 #include "infohash.h" // includes socket structures
 #include "utils.h"
 #include "sockaddr.h"
+#include "net.h"
+#include "uv_utils.h"
+#include "crypto.h"

 #include <list>
+#include <map>

 namespace dht {

+struct Node;
 namespace net {
 struct Request;
+struct Socket;
+struct RequestAnswer;
 } /* namespace net */

+using SocketCb = std::function<void(const Sp<Node>&, net::RequestAnswer&&)>;
+using SocketId = uint32_t;
+struct Socket {
+    Socket() {}
+    Socket(SocketCb&& on_receive) :
+        on_receive(std::move(on_receive)) {}
+    SocketCb on_receive {};
+};
+
 struct Node {
-    InfoHash id;
-    SockAddr addr;
+    const InfoHash id;

-    time_point time {time_point::min()};            /* last time eared about */
-    time_point reply_time {time_point::min()};      /* time of last correct reply received */
+    Sp<TcpSocket> sock;

+    InfoHash last_known_pk;
+    //std::list<crypto::EcSecretKey>
+
+    Node(const InfoHash& id, const SockAddr& addr, const Sp<TcpSocket>& s = {}, bool client=false);
    Node(const InfoHash& id, const sockaddr* sa, socklen_t salen)
-        : id(id), addr(sa, salen) {}
-    Node(const InfoHash& id, const SockAddr& addr) : id(id), addr(addr) {}
+        : Node(id, SockAddr(sa, salen)) {}
+    ~Node() {
+        if (sock)
+            sock->close();
+    }

    InfoHash getId() const {
        return id;
    }
-    std::pair<const sockaddr*, socklen_t> getAddr() const {
-        return {(const sockaddr*)&addr.first, addr.second};
-    }
+    const SockAddr& getAddr() const { return addr; }
    std::string getAddrStr() const {
        return addr.toString();
    }

+    bool isClient() const { return is_client; }
+    bool isIncoming() { return time > reply_time; }
+
+    const time_point& getTime() const { return time; }
+    const time_point& getReplyTime() const { return reply_time; }
+    void setTime(const time_point& t) { time = t; }
+
+    SockAddr getAddress() const {
+        return canStream() ? sock->getPeerAddr() : addr;
+    }
+
+    void startTCP() {
+
+    }
+
    /**
     * Makes notice about an additionnal authentication error with this node. Up
     * to MAX_AUTH_ERRORS errors are accepted in order to let the node recover.
@@ -68,21 +102,70 @@ struct Node {
    bool isPendingMessage() const;
    size_t getPendingMessageCount() const;

-    NodeExport exportNode() const { return NodeExport {id, addr.first, addr.second}; }
+    bool isOld(const time_point& now) const {
+        return time + NODE_EXPIRE_TIME < now;
+    }
+    bool isRemovable(const time_point& now) const {
+        return isExpired() and isOld(now);
+    }
+
+    NodeExport exportNode() const {
+        NodeExport ne;
+        ne.id = id;
+        ne.sslen = addr.getLength();
+        std::memcpy(&ne.ss, addr.get(), ne.sslen);
+        return ne;
+    }
    sa_family_t getFamily() const { return addr.getFamily(); }

-    void update(const SockAddr&);
+    void update(const SockAddr&, const Sp<TcpSocket>&);

-    void requested(std::shared_ptr<net::Request>& req);
-    void received(time_point now, std::shared_ptr<net::Request> req);
+    bool canStream() const {
+        return sock and not sock->isClosed() and sock->canWrite();
+    }
+
+    void requested(const Sp<net::Request>& req);
+    void received(time_point now, const Sp<net::Request>& req);
+    Sp<net::Request> getRequest(const net::TransId& tid);
+    void cancelRequest(const Sp<net::Request>& req);

    void setExpired();

+    /**
+     * Opens a socket on which a node will be able allowed to write for further
+     * additionnal updates following the response to a previous request.
+     *
+     * @param node  The node which will be allowed to write on this socket.
+     * @param cb    The callback to execute once updates arrive on the socket.
+     *
+     * @return the socket.
+     */
+    SocketId openSocket(SocketCb&& cb);
+
+    Socket* getSocket(SocketId id);
+
+    /**
+     * Closes a socket so that no further data will be red on that socket.
+     *
+     * @param socket  The socket to close.
+     */
+    void closeSocket(SocketId id);
+
    /**
     * Resets the state of the node so it's not expired anymore.
     */
    void reset() { expired_ = false; reply_time = time_point::min(); }

+    /**
+     * Generates a new request id, skipping the invalid id.
+     *
+     * @return the new id.
+     */
+    uint16_t getNewTid() {
+        ++transaction_id;
+        return transaction_id == net::TransId::INVALID ? ++transaction_id : transaction_id;
+    }
+
    std::string toString() const;

    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const Node& h);
@@ -99,15 +182,17 @@ private:
    /* Number of times we accept authentication errors from this node. */
    static const constexpr unsigned MAX_AUTH_ERRORS {3};

-    std::list<std::weak_ptr<net::Request>> requests_ {};
+    SockAddr addr;
+    bool is_client {false};
+    time_point time {time_point::min()};            /* last time eared about */
+    time_point reply_time {time_point::min()};      /* time of last correct reply received */
    unsigned auth_errors {0};
    bool expired_ {false};
+    SocketId transaction_id;
+    using TransactionDist = std::uniform_int_distribution<decltype(transaction_id)>;

-    void clearPendingQueue() {
-        requests_.remove_if([](std::weak_ptr<net::Request>& w) {
-            return w.expired();
-        });
-    }
+    std::map<net::TransId, Sp<net::Request>> requests_ {};
+    std::map<SocketId, Socket> sockets_;
 };

 }
@@ -26,9 +26,9 @@
 namespace dht {

 struct NodeCache {
-    std::shared_ptr<Node> getNode(const InfoHash& id, sa_family_t family);
-    std::shared_ptr<Node> getNode(const InfoHash& id, const SockAddr&, time_point now, bool confirmed);
-    std::vector<std::shared_ptr<Node>> getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count);
+    Sp<Node> getNode(const InfoHash& id, sa_family_t family);
+    Sp<Node> getNode(const InfoHash& id, const SockAddr&, const Sp<TcpSocket>&, time_point now, bool confirmed, bool client=false);
+    std::vector<Sp<Node>> getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count) const;

    /**
     * Reset the connectivity state of every node,
@@ -36,15 +36,19 @@ struct NodeCache {
     * To use in case of connectivity change etc.
     */
    void clearBadNodes(sa_family_t family = 0);
+    void closeAll(sa_family_t family = 0);

 private:
    class NodeMap : public std::map<InfoHash, std::weak_ptr<Node>> {
    public:
-        std::shared_ptr<Node> getNode(const InfoHash& id);
-        std::shared_ptr<Node> getNode(const InfoHash& id, const SockAddr&, time_point now, bool confirmed);
+        Sp<Node> getNode(const InfoHash& id);
+        Sp<Node> getNode(const InfoHash& id, const SockAddr&, const Sp<TcpSocket>&, time_point now, bool confirmed, bool client);
        void clearBadNodes();
+        void closeAll();
    };

+    const NodeMap& cache(sa_family_t af) const { return af == AF_INET ? cache_4 : cache_6; }
+    NodeMap& cache(sa_family_t af) { return af == AF_INET ? cache_4 : cache_6; }
    NodeMap cache_4;
    NodeMap cache_6;
 };
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2017 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
@@ -26,10 +26,10 @@ namespace dht {
 template<size_t Quota, unsigned long Perdiod=1>
 class RateLimiter {
 public:
-    /** Clear outdated records and return current quota usage */ 
+    /** Clear outdated records and return current quota usage */
    size_t maintain(const time_point& now) {
-        using namespace std::chrono;
-        while (not records.empty() and duration_cast<seconds>(now - records.front()) >= seconds(Perdiod))
+        auto limit = now - std::chrono::seconds(Perdiod);
+        while (not records.empty() and records.front() < limit)
            records.pop();
        return records.size();
    }
@@ -24,6 +24,9 @@
 namespace dht {

 static constexpr unsigned TARGET_NODES {8};
+namespace net {
+class NetworkEngine;
+}

 struct Bucket {
    Bucket() : cached() {}
@@ -37,12 +40,25 @@ struct Bucket {

    /** Return a random node in a bucket. */
    Sp<Node> randomNode();
+
+    void sendCachedPing(net::NetworkEngine& ne);
+
+    /** Return false if there is a single non-expired node in this bucket. */
+    bool expired() const {
+        for (const auto& n : nodes)
+            if (not n->isExpired())
+                return false;
+        return true;
+    }
 };

 class RoutingTable : public std::list<Bucket> {
 public:
    using std::list<Bucket>::list;

+    time_point grow_time {time_point::min()};
+    bool is_client {false};
+
    InfoHash middle(const RoutingTable::const_iterator&) const;

    std::vector<Sp<Node>> findClosestNodes(const InfoHash id, time_point now, size_t count = TARGET_NODES) const;
@@ -65,6 +81,14 @@ public:
        return empty() || (size() == 1 && front().nodes.empty());
    }

+    void connectivityChanged(const time_point& now) {
+        grow_time = now;
+        for (auto& b : *this)
+            b.time = time_point::min();
+    }
+
+    bool onNewNode(const Sp<Node>& node, int comfirm, const time_point& now, const InfoHash& myid, net::NetworkEngine& ne);
+
    /**
     * Return a random id in the bucket's range.
     */
@@ -22,6 +22,9 @@

 #include "utils.h"
 #include "log_enable.h"
+#include "uv_utils.h"
+
+#include <uv.h>

 #include <functional>
 #include <map>
@@ -36,12 +39,7 @@ namespace dht {
 */
 class Scheduler {
 public:
-    Scheduler(const Logger& l) : DHT_LOG(l) {}
-
-    struct Job {
-        Job(std::function<void()>&& f) : do_(std::move(f)) {}
-        std::function<void()> do_;
-    };
+    Scheduler(uv_loop_t* loop, const Logger& l) : loop_(loop), DHT_LOG(l) {}

    /**
     * Adds another job to the queue.
@@ -51,10 +49,32 @@ 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));
-        if (t != time_point::max())
-            timers.emplace(std::move(t), job);
+    Sp<Job> add(const time_point& t, std::function<void()>&& job_func) {
+        if (not loop_)
+            return {};
+        auto job = Job::make(loop_, std::move(job_func));
+        if (t != time_point::max()) {
+            garbageCollection();
+            pending_jobs.emplace(job);
+            job->run(t);
+        } else
+            job->cancel();
+        return job;
+    }
+    Sp<Job> add(const duration& t, std::function<void()>&& job_func) {
+        if (not loop_)
+            return {};
+        auto job = Job::make(loop_, std::move(job_func));
+        garbageCollection();
+        pending_jobs.emplace(job);
+        job->run(t);
+        return job;
+    }
+    Sp<Job> run(std::function<void()>&& job_func) {
+        auto job = Job::make(loop_, std::move(job_func));
+        garbageCollection();
+        pending_jobs.emplace(job);
+        job->run();
        return job;
    }

@@ -66,7 +86,9 @@ public:
     *
     * @return pointer to the newly scheduled job.
     */
-    void edit(Sp<Scheduler::Job>& job, time_point t) {
+    void edit(Sp<Job>& job, const duration& t = {}) {
+        if (not loop_)
+            return;
        if (not job) {
            DHT_LOG.ERR("editing an empty job");
            return;
@@ -75,50 +97,73 @@ public:
        // Force clearing old value.
        auto task = std::move(job->do_);
        job->do_ = {};
+        job->cancel();
+        job = add(t, std::move(task));
+    }
+    void edit(Sp<Job>& job, const time_point& t) {
+        if (not loop_)
+            return;
+        if (not job) {
+            DHT_LOG.ERR("editing an empty job");
+            return;
+        }
+        auto task = std::move(job->do_);
+        job->do_ = {};
+        job->cancel();
        job = add(t, std::move(task));
    }

-    /**
-     * Runs the jobs to do up to now.
-     *
-     * @return The time for the next job to run.
-     */
-    time_point run() {
-        syncTime();
-        while (not timers.empty()) {
-            auto timer = timers.begin();
-            /*
-             * Running jobs scheduled before "now" prevents run+rescheduling
-             * loops before this method ends. It is garanteed by the fact that a
-             * job will at least be scheduled for "now" and not before.
-             */
-            if (timer->first > now)
-                break;
-
-            auto job = std::move(timer->second);
-            timers.erase(timer);
-
-            if (job->do_)
-                job->do_();
-        }
-        return getNextJobTime();
+    void stop() {
+        loop_ = nullptr;
+        size_t del {0};
+        for (auto& w : pending_jobs)
+            if (auto job = w.lock()) {
+                job->cancel();
+                del++;
+            }
+        pending_jobs.clear();
+        DHT_LOG.DEBUG("stopping scheduler, %lu events canceled", del);
    }

-    inline time_point getNextJobTime() const {
-        return timers.empty() ? time_point::max() : timers.begin()->first;
+    ~Scheduler(){
+        stop();
    }

    /**
     * Accessors for the common time reference used for synchronizing
     * operations.
     */
-    inline const time_point& time() const { return now; }
-    inline time_point syncTime() { return (now = clock::now()); }
+    inline time_point time() const {
+        return time_point(std::chrono::duration_cast<duration>(std::chrono::milliseconds(uv_now(loop_))));
+    }
+    inline time_point syncTime() {
+        return time();
+    }
+    uv_loop_t* getLoop() const {
+        return loop_;
+    }

 private:
-    time_point now {clock::now()};
-    std::multimap<time_point, Sp<Job>> timers {}; /* the jobs ordered by time */
+    std::set<std::weak_ptr<Job>, std::owner_less<std::weak_ptr<Job>>> pending_jobs {};
+    size_t lastSize_ {0};
+    uv_loop_t* loop_;
    const Logger& DHT_LOG;
+
+    void garbageCollection() {
+        if (pending_jobs.size() > lastSize_ * 2) {
+            unsigned del {0};
+            for (auto it = pending_jobs.begin(); it != pending_jobs.end();) {
+                if (it->expired()) {
+                    it = pending_jobs.erase(it);
+                    del++;
+                } else 
+                    ++it;
+            }
+            //DHT_LOG.DEBUG("pending_jobs cleanup: %u removed, %zu remaining", del, pending_jobs.size());
+            lastSize_ = pending_jobs.size();
+        }
+    }
+
 };

 }
@@ -44,7 +44,7 @@ public:
     * id:    the identity to use for the crypto layer and to compute
     *        our own hash on the Dht.
     */
-    SecureDht(int s, int s6, Config config);
+    SecureDht(uv_loop_t* loop, Config config);

    virtual ~SecureDht();

@@ -158,7 +158,7 @@ private:
 const ValueType CERTIFICATE_TYPE = {
    8, "Certificate", std::chrono::hours(24 * 7),
    // A certificate can only be stored at its public key ID.
-    [](InfoHash id, Sp<Value>& v, InfoHash, const sockaddr*, socklen_t) {
+    [](InfoHash id, Sp<Value>& v, const InfoHash&, const SockAddr&) {
        try {
            crypto::Certificate crt(v->data);
            // TODO check certificate signature
@@ -166,7 +166,7 @@ const ValueType CERTIFICATE_TYPE = {
        } catch (const std::exception& e) {}
        return false;
    },
-    [](InfoHash, const Sp<Value>& o, Sp<Value>& n, InfoHash, const sockaddr*, socklen_t) {
+    [](InfoHash, const Sp<Value>& o, Sp<Value>& n, const InfoHash&, const SockAddr&) {
        try {
            return crypto::Certificate(o->data).getPublicKey().getId() == crypto::Certificate(n->data).getPublicKey().getId();
        } catch (const std::exception& e) {}
@@ -34,56 +34,116 @@ typedef uint16_t sa_family_t;
 typedef uint16_t in_port_t;
 #endif

+#include <string>
+#include <memory>
+
+#include <cstring>
+#include <cstddef>
+
 namespace dht {

 OPENDHT_PUBLIC std::string print_addr(const sockaddr* sa, socklen_t slen);
 OPENDHT_PUBLIC std::string print_addr(const sockaddr_storage& ss, socklen_t sslen);

-struct OPENDHT_PUBLIC SockAddr : public std::pair<sockaddr_storage, socklen_t> {
+/**
+ * A Socket Address (sockaddr*), with abstraction for IPv4, IPv6 address families.
+ */
+class OPENDHT_PUBLIC SockAddr {
 public:
-    SockAddr() : pair<sockaddr_storage, socklen_t>::pair({},0) {}
-    SockAddr(const SockAddr& o) : pair<sockaddr_storage, socklen_t>::pair({},o.second) {
-        std::copy_n((uint8_t*)&o.first, o.second, (uint8_t*)&first);
+    SockAddr() {}
+    SockAddr(const SockAddr& o) {
+        set(o.get(), o.getLength());
    }
-    SockAddr(const sockaddr* sa, socklen_t len) : pair<sockaddr_storage, socklen_t>::pair({},len) {
-        if (len > sizeof(sockaddr_storage))
+    SockAddr(SockAddr&& o) : len(o.len), addr(std::move(o.addr)) {
+        o.len = 0;
+    }
+
+    /**
+     * Build from existing address.
+     */
+    SockAddr(const sockaddr* sa, socklen_t length) {
+        if (length > sizeof(sockaddr_storage))
            throw std::runtime_error("Socket address length is too large");
-        std::copy_n((uint8_t*)sa, len, (uint8_t*)&first);
+        set(sa, length);
    }
+    SockAddr(const sockaddr* sa) {
+        socklen_t len = 0;
+        if (sa) {
+            if (sa->sa_family == AF_INET)
+                len = sizeof(sockaddr_in);
+            else if(sa->sa_family == AF_INET6)
+                len = sizeof(sockaddr_in6);
+            else
+                throw std::runtime_error("Unknown address family");
+        }
+        set(sa, len);
+    }
+
+    /**
+     * Build from an existing sockaddr_storage structure.
+     */
    SockAddr(const sockaddr_storage& ss, socklen_t len) : SockAddr((const sockaddr*)&ss, len) {}

    bool operator<(const SockAddr& o) const {
-        if (second != o.second)
-            return second < o.second;
-        return std::memcmp((uint8_t*)&first, (uint8_t*)&o.first, second) < 0;
+        if (len != o.len)
+            return len < o.len;
+        return std::memcmp((const uint8_t*)get(), (const uint8_t*)o.get(), len) < 0;
    }

    bool equals(const SockAddr& o) const {
-        return second == o.second
-            && std::memcmp((uint8_t*)&first, (uint8_t*)&o.first, second) == 0;
+        return len == o.len
+            && std::memcmp((const uint8_t*)get(), (const uint8_t*)o.get(), len) == 0;
    }
    SockAddr& operator=(const SockAddr& o) {
-        std::copy_n((const uint8_t*)&o.first, o.second, (uint8_t*)&first);
-        second = o.second;
+        set(o.get(), o.getLength());
+        return *this;
+    }
+    SockAddr& operator=(SockAddr&& o) {
+        len = o.len;
+        o.len = 0;
+        addr = std::move(o.addr);
        return *this;
    }

    std::string toString() const {
-        return print_addr(first, second);
-    }
-    sa_family_t getFamily() const { return second > sizeof(sa_family_t) ? first.ss_family : AF_UNSPEC; }
-    void setFamily(sa_family_t af) {
-        first.ss_family = af;
-        switch(af) {
-        case AF_INET:
-            second = sizeof(sockaddr_in);
-            break;
-        case AF_INET6:
-            second = sizeof(sockaddr_in6);
-            break;
-        }
+        return print_addr(get(), getLength());
    }

+    /**
+     * Returns the address family or AF_UNSPEC if the address is not set.
+     */
+    sa_family_t getFamily() const { return len > sizeof(sa_family_t) ? addr->sa_family : AF_UNSPEC; }
+
+    /**
+     * Resize the managed structure to the appropriate size (if needed),
+     * in which case the sockaddr structure is cleared to zero,
+     * and set the address family field (sa_family).
+     */
+    void setFamily(sa_family_t af) {
+        socklen_t new_length;
+        switch(af) {
+        case AF_INET:
+            new_length = sizeof(sockaddr_in);
+            break;
+        case AF_INET6:
+            new_length = sizeof(sockaddr_in6);
+            break;
+        default:
+            new_length = 0;
+        }
+        if (new_length != len) {
+            len = new_length;
+            if (len) addr.reset((sockaddr*)std::calloc(len, 1));
+            else     addr.reset();
+        }
+        if (len > sizeof(sa_family_t))
+            addr->sa_family = af;
+    }
+
+    /**
+     * Retreive the port (in host byte order) or 0 if the address is not
+     * of a supported family.
+     */
    in_port_t getPort() const {
        switch(getFamily()) {
        case AF_INET:
@@ -94,6 +154,10 @@ public:
            return 0;
        }
    }
+    /**
+     * Set the port. The address must be of a supported family.
+     * @param p The port in host byte order.
+     */
    void setPort(in_port_t p) {
        switch(getFamily()) {
        case AF_INET:
@@ -105,17 +169,42 @@ public:
        }
    }

+    /**
+     * Returns the accessible byte length at the pointer returned by #get().
+     * If zero, #get() returns null.
+     */
+    socklen_t getLength() const { return len; }
+
+    /**
+     * An address is defined to be true if its length is not zero.
+     */
+    explicit operator bool() const noexcept {
+        return len;
+    }
+
+    /**
+     * Returns the address to the managed sockaddr structure.
+     * The accessible length is returned by #getLength().
+     */
+    const sockaddr* get() const { return addr.get(); }
+
+    /**
+     * Returns the address to the managed sockaddr structure.
+     * The accessible length is returned by #getLength().
+     */
+    sockaddr* get() { return addr.get(); }
+
    const sockaddr_in& getIPv4() const {
-        return *reinterpret_cast<const sockaddr_in*>(&first);
+        return *reinterpret_cast<const sockaddr_in*>(get());
    }
    const sockaddr_in6& getIPv6() const {
-        return *reinterpret_cast<const sockaddr_in6*>(&first);
+        return *reinterpret_cast<const sockaddr_in6*>(get());
    }
    sockaddr_in& getIPv4() {
-        return *reinterpret_cast<sockaddr_in*>(&first);
+        return *reinterpret_cast<sockaddr_in*>(get());
    }
    sockaddr_in6& getIPv6() {
-        return *reinterpret_cast<sockaddr_in6*>(&first);
+        return *reinterpret_cast<sockaddr_in6*>(get());
    }

    /**
@@ -130,14 +219,17 @@ public:

    bool isUnspecified() const;

+    bool isMappedIPv4() const;
+    SockAddr getMappedIPv4() const;
+
    /**
     * A comparator to classify IP addresses, only considering the
     * first 64 bits in IPv6.
     */
    struct ipCmp {
        bool operator()(const SockAddr& a, const SockAddr& b) const {
-            if (a.second != b.second)
-                return a.second < b.second;
+            if (a.len != b.len)
+                return a.len < b.len;
            socklen_t start, len;
            switch(a.getFamily()) {
                case AF_INET:
@@ -151,18 +243,30 @@ public:
                    break;
                default:
                    start = 0;
-                    len = a.second;
+                    len = a.len;
                    break;
            }
-
-            return std::memcmp((uint8_t*)&a.first+start, (uint8_t*)&b.first+start, len) < 0;
+            return std::memcmp((uint8_t*)a.get()+start,
+                               (uint8_t*)b.get()+start, len) < 0;
        }
    };
+private:
+    socklen_t len {0};
+    struct free_delete { void operator()(void* p) { std::free(p); } };
+    std::unique_ptr<sockaddr, free_delete> addr {};
+
+    void set(const sockaddr* sa, socklen_t length) {
+        if (len != length) {
+            len = length;
+            if (len) addr.reset((sockaddr*)std::malloc(len));
+            else     addr.reset();
+        }
+        if (len)
+            std::memcpy((uint8_t*)get(), (const uint8_t*)sa, len);
+    }

 };

 OPENDHT_PUBLIC bool operator==(const SockAddr& a, const SockAddr& b);

-OPENDHT_PUBLIC std::string printAddr(const SockAddr& addr);
-
 }
@@ -32,6 +32,9 @@
 #define WANT4 1
 #define WANT6 2

+/**
+ * OpenDHT C++ namespace
+ */
 namespace dht {

 using NetId = uint32_t;
@@ -93,6 +96,9 @@ public:

 // Serialization related definitions and utility functions

+/**
+ * Arbitrary binary data.
+ */
 using Blob = std::vector<uint8_t>;

 /**
@@ -0,0 +1,419 @@
+#pragma once
+
+#include "utils.h"
+
+#include <uv.h>
+
+namespace dht {
+
+struct EventLoop {
+    using OnSignal = std::function<void(int)>;
+
+    EventLoop() {
+        uv_loop_init(&loop);
+        uv_signal_init(&loop, &sig_handler);
+        sig_handler.data = this;
+        uv_signal_start(&sig_handler, &EventLoop::signal_handler, SIGINT);
+    }
+    ~EventLoop() {
+        uv_loop_close(&loop);
+    }
+    auto run() {
+        return uv_run(&loop, UV_RUN_DEFAULT);
+    }
+    auto runOnce() {
+        return uv_run(&loop, UV_RUN_NOWAIT);
+    }
+    void stop() {
+        uv_signal_stop(&sig_handler);
+        uv_walk(&loop, &EventLoop::close_walk_cb, this);
+    }
+    uv_loop_t* get() { return &loop; }
+    void setOnSignal(OnSignal cb) {
+        onSignal_ = cb;
+    }
+private:
+    uv_loop_t loop;
+    uv_signal_t sig_handler;
+    OnSignal onSignal_;
+    void onSignal(int sig) {
+        if (onSignal_)
+            onSignal_(sig);
+    }
+    static void close_walk_cb(uv_handle_t* handle, void* /*arg*/) {
+        if (not uv_is_closing(handle))
+            uv_close(handle, [](uv_handle_t* handle) {
+                std::cout << "handle " << handle << " of type " << handle->type << " closed" << std::endl;
+            });
+    }
+    static void signal_handler(uv_signal_t* handle, int signum) {
+        if (handle->data) {
+            static_cast<EventLoop*>(handle->data)->onSignal(signum);
+        }
+    }
+};
+
+using GetAddrInfoCb = std::function<void(std::vector<SockAddr>&&)>;
+
+void getAddrInfo(uv_loop_t* loop, const char* node, const char* service, GetAddrInfoCb&& cb);
+
+struct Job : std::enable_shared_from_this<Job> {
+    Job(uv_loop_t* loop, std::function<void()>&& f = {}) : do_(std::move(f)) {
+        uv_timer_init(loop, &timer_);
+        timer_.data = nullptr;
+    }
+    void run(uint64_t t = 0) {
+        uv_timer_start(&timer_, &Job::timer_cb, t, 0);
+    }
+    inline void run(const duration& t) {
+        run(getTimeout(t));
+    }
+    inline void run(const time_point& t) {
+        run(getTimeout(t));
+    }
+    void cancel() {
+        if (timer_.data and not uv_is_closing((uv_handle_t*)&timer_)) {
+            uv_timer_stop(&timer_);
+            uv_close((uv_handle_t*)&timer_, &Job::close_cb);
+        }
+    }
+    static Sp<Job> make(uv_loop_t* loop, std::function<void()>&& f = {}) {
+        auto job = std::make_shared<Job>(loop, std::move(f));
+        job->timer_.data = new Sp<Job>(job);
+        return job;
+    }
+    static uint64_t getTimeout(const duration& d) {
+        return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
+    }
+    uint64_t getTimeout(const time_point& tp) const {
+        uint64_t t = getTimeout(tp.time_since_epoch());
+        uint64_t now = uv_now(timer_.loop);
+        return (t < now) ? 0 : t - now;
+    }
+    std::function<void()> do_;
+private:
+    uv_timer_t timer_;
+    void onTimer() {
+        if (do_)
+            do_();
+        cancel();
+    }
+    void onClosed() {
+        if (timer_.data) {
+            delete static_cast<Sp<Job>*>(timer_.data);
+            timer_.data = nullptr;
+        }
+    }
+    static void timer_cb(uv_timer_t* handle) {
+        if (handle->data) {
+            auto timer = *static_cast<Sp<Job>*>(handle->data);
+            timer->onTimer();
+        }
+    }
+    static void close_cb(uv_handle_t* handle) {
+        if (handle->data) {
+            auto timer = *static_cast<Sp<Job>*>(handle->data);
+            timer->onClosed();
+        } else {
+            std::cerr << "Job::onClosed(): no data! " << handle << std::endl;
+        }
+    }
+};
+
+
+static inline void alloc_buffer(uv_handle_t* /*handle*/, size_t suggested_size, uv_buf_t *buf) {
+    buf->base = (char*)malloc(suggested_size);
+    buf->len = suggested_size;
+}
+
+
+using OnClose = std::function<void()>;
+
+struct UdpSocket : public std::enable_shared_from_this<UdpSocket>
+{
+    using OnReceive = std::function<void(const uint8_t* data, size_t size, const SockAddr& addr)>;
+    using OnSent = std::function<void(int status)>;
+
+    UdpSocket(uv_loop_t* loop) {
+        uv_udp_init(loop, &sock);
+        sock.data = nullptr;
+    }
+    void open(const char* bind_addr, in_port_t port, OnReceive cb) {
+        if (not sock.data)
+            sock.data = new std::shared_ptr<UdpSocket>(shared_from_this());
+        receive_cb = std::move(cb);
+        struct sockaddr_in6 addr;
+        uv_ip6_addr(bind_addr, port, &addr);
+        uv_udp_bind(&sock, (const struct sockaddr*)&addr, 0);
+        uv_udp_recv_start(&sock, &UdpSocket::on_alloc_buffer, &UdpSocket::on_receive);
+    }
+
+    int send(uint8_t* data, size_t size, const SockAddr& addr, OnSent&& cb = {}) {
+        auto req = new SendReq;
+        req->msg = data;
+        req->req.data = req;
+        req->cb = std::move(cb);
+        const uv_buf_t buf {
+            /*.base =*/ (char*)data,
+            /*.len =*/ size
+        };
+        return uv_udp_send(&req->req, &sock, &buf, 1, addr.get(), &UdpSocket::on_sent);
+    }
+
+    void close(OnClose cb) {
+        close_cb = cb;
+        uv_close((uv_handle_t*) &sock, &UdpSocket::on_close);
+    }
+    bool isRunning() const {
+        return uv_is_active((uv_handle_t*) &sock);
+    }
+    SockAddr getBoundAddr() {
+        sockaddr_storage addr;
+        int size = sizeof(addr);
+        uv_udp_getsockname(&sock, (sockaddr*)&addr, &size);
+        return {(const sockaddr*)&addr, (socklen_t)size};
+    }
+private:
+    struct SendReq {
+        uv_udp_send_t req;
+        uint8_t* msg;
+        OnSent cb;
+    };
+
+    uv_udp_t sock;
+    OnReceive receive_cb;
+    OnClose close_cb;
+
+    void onAllocBuffer(size_t suggested_size, uv_buf_t* buf) {
+        buf->base = (char*)malloc(suggested_size);
+        buf->len = suggested_size;
+    }
+    void onReceive(ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned /*flags*/) {
+        if (nread > 0 and addr and receive_cb) {
+            receive_cb((const uint8_t*)buf->base, nread, SockAddr(addr));
+        }
+        if (buf->base)
+            free(buf->base);
+    }
+    void onClosed() {
+        if (close_cb)
+            close_cb();
+        if (auto s = static_cast<std::shared_ptr<UdpSocket>*>(sock.data)) {
+            sock.data = nullptr;
+            delete s;
+        }
+    }
+    void onSent(SendReq& req, int status) {
+        if (req.cb) {
+            req.cb(status);
+        }
+        free(req.msg);
+    }
+    static std::shared_ptr<UdpSocket> get(uv_handle_t* handle) {
+        return handle->data ? *static_cast<std::shared_ptr<UdpSocket>*>(handle->data) : std::shared_ptr<UdpSocket>();
+    }
+    static void on_close(uv_handle_t* handle) {
+        if (auto node = get(handle))
+            node->onClosed();
+    }
+    static void on_sent(uv_udp_send_t* req, int status) {
+        if (auto data = static_cast<SendReq*>(req->data)) {
+            if (auto node = get((uv_handle_t*)req->handle))
+                node->onSent(*data, status);
+            delete data;
+        }
+    }
+    static void on_receive(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags) {
+        if (auto node = get((uv_handle_t*)handle))
+            node->onReceive(nread, buf, addr, flags);
+    }
+    static inline void on_alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t *buf) {
+        if (auto node = get((uv_handle_t*)handle))
+            node->onAllocBuffer(suggested_size, buf);
+    }
+};
+
+struct TcpSocket : public std::enable_shared_from_this<TcpSocket>
+{
+    using OnConnect = std::function<void(std::shared_ptr<TcpSocket>&& new_socket)>;
+    using OnConnected = std::function<void(int status)>;
+    using OnRead = std::function<void(const uint8_t* data, size_t size)>;
+    using OnWrite = std::function<void(int status)>;
+
+    TcpSocket(uv_loop_t* loop) {
+        uv_tcp_init(loop, &sock);
+        sock.data = nullptr;
+    }
+    void listen(const char* bind_addr, in_port_t port, OnConnect cb) {
+        if (not sock.data)
+            sock.data = new std::shared_ptr<TcpSocket>(shared_from_this());
+        connect_cb = cb;
+        struct sockaddr_in6 addr;
+        uv_ip6_addr(bind_addr, port, &addr);
+        uv_tcp_bind(&sock, (const struct sockaddr*)&addr, 0);
+        if (int r = uv_listen((uv_stream_t*)&sock, 128, &TcpSocket::on_new_connection)) {
+            fprintf(stderr, "Listen error %s\n", uv_strerror(r));
+        }
+    }
+    void connect(const sockaddr* addr, OnConnected&& cb) {
+        if (not sock.data)
+            sock.data = new std::shared_ptr<TcpSocket>(shared_from_this());
+        auto req = new ConnectReq;
+        req->connect.data = req;
+        req->sock = shared_from_this();
+        req->callback = std::move(cb);
+        uv_tcp_connect(&req->connect, &sock, addr, &TcpSocket::on_connect);
+    }
+    void start(OnRead&& cb) {
+        std::cerr << "TCP start" << std::endl;
+        read_cb = std::move(cb);
+        uv_read_start((uv_stream_t*)&sock, &TcpSocket::on_alloc_buffer, &TcpSocket::on_read);
+    }
+    int write(uint8_t* msg, size_t len, OnWrite&& cb = {}) {
+        std::cerr << "TCP write " << len << std::endl;
+        auto req = new WriteReq;
+        req->write.data = req;
+        req->msg = msg;
+        req->sock = shared_from_this();
+        req->callback = std::move(cb);
+        uv_buf_t buf;
+        buf.base = (char*)msg;
+        buf.len = len;
+        return uv_write(&req->write, (uv_stream_t *)&sock, &buf, 1, &TcpSocket::on_write_end);
+    }
+    void close(OnClose onclose = {}) {
+        std::cerr << "TCP close" << std::endl;
+        if (not isClosed()) {
+            close_cb = onclose;
+            uv_close((uv_handle_t*) &sock, &TcpSocket::on_close);
+        }
+    }
+    bool isClosed() {
+        return not sock.data or uv_is_closing((const uv_handle_t*) &sock);
+    }
+    bool canWrite() const {
+        return uv_is_writable((const uv_stream_t*)&sock);
+    }
+    SockAddr getBoundAddr() {
+        sockaddr_storage addr;
+        int size = sizeof(addr);
+        uv_tcp_getsockname(&sock, (sockaddr*)&addr, &size);
+        return {(const sockaddr*)&addr, (socklen_t)size};
+    }
+    SockAddr getPeerAddr() {
+        sockaddr_storage addr;
+        int size = sizeof(addr);
+        uv_tcp_getpeername(&sock, (sockaddr*)&addr, &size);
+        return {(const sockaddr*)&addr, (socklen_t)size};
+    }
+private:
+    uv_tcp_t sock;
+    OnConnect connect_cb;
+    OnRead read_cb;
+    OnClose close_cb;
+    struct ConnectReq {
+        uv_connect_t connect;
+        std::shared_ptr<TcpSocket> sock;
+        OnConnected callback;
+    };
+    struct WriteReq {
+        uv_write_t write;
+        uint8_t* msg;
+        std::shared_ptr<TcpSocket> sock;
+        OnWrite callback;
+    };
+    std::shared_ptr<TcpSocket> accept() {
+        auto s = std::make_shared<TcpSocket>(sock.loop);
+        s->sock.data = new std::shared_ptr<TcpSocket>(s);
+        if (uv_accept((uv_stream_t*)&sock, (uv_stream_t*) &s->sock) == 0) {
+            return s;
+        } else {
+            s->close();
+            return {};
+        }
+    }
+    void onNewConnection(int status) {
+        if (status < 0) {
+            fprintf(stderr, "New connection error %s\n", uv_strerror(status));
+            return;
+        }
+        if (auto s = accept())
+            connect_cb(std::move(s));
+        fprintf(stderr, "on_new_connection end\n");
+    }
+    void onConnected(int status, OnConnected&& cb) {
+        if (cb)
+            cb(status);
+    }
+    void onAllocBuffer(size_t suggested_size, uv_buf_t* buf) {
+        buf->base = (char*)malloc(suggested_size);
+        buf->len = suggested_size;
+    }
+    void onRead(ssize_t nread, const uv_buf_t *buf) {
+        if (nread < 0) {
+            if (nread != UV_EOF) {
+                fprintf(stderr, "Read error %s\n", uv_err_name(nread));
+            } else {
+                fprintf(stderr, "EOF\n");
+            }
+            close();
+        } else if (nread > 0) {
+            if (read_cb)
+                read_cb((const uint8_t*)buf->base, nread);
+        }
+        if (buf->base)
+            free(buf->base);
+    }
+    void onWrite(int status, OnWrite&& cb) {
+        if (cb)
+            cb(status);
+    }
+    void onClosed() {
+        read_cb = {};
+        connect_cb = {};
+        if (close_cb) {
+            close_cb();
+            close_cb = {};
+        }
+        if (auto s = static_cast<std::shared_ptr<TcpSocket>*>(sock.data)) {
+            sock.data = nullptr;
+            delete s;
+        }
+    }
+    static std::shared_ptr<TcpSocket> get(uv_handle_t* handle) {
+        return handle->data ? *static_cast<std::shared_ptr<TcpSocket>*>(handle->data) : std::shared_ptr<TcpSocket>();
+    }
+    static void on_new_connection(uv_stream_t* handle, int status) {
+        if (auto node = get((uv_handle_t*)handle))
+            node->onNewConnection(status);
+    }
+    static void on_close(uv_handle_t* handle) {
+        if (auto node = get(handle))
+            node->onClosed();
+    }
+    static inline void on_alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t *buf) {
+        if (auto node = get((uv_handle_t*)handle))
+            node->onAllocBuffer(suggested_size, buf);
+    }
+    static void on_read(uv_stream_t* client, ssize_t nread, const uv_buf_t *buf) {
+        if (auto node = get((uv_handle_t*)client))
+            node->onRead(nread, buf);
+    }
+    static void on_write_end(uv_write_t* req, int status) {
+        if (auto write = static_cast<WriteReq*>(req->data)) {
+            write->sock->onWrite(status, std::move(write->callback));
+            if (write->msg)
+                free(write->msg);
+            delete write;
+        }
+    }
+    static void on_connect(uv_connect_t* req, int status) {
+        if (auto conn = static_cast<ConnectReq*>(req->data)) {
+            conn->sock->onConnected(status, std::move(conn->callback));
+            delete conn;
+        }
+    }
+};
+
+
+}
@@ -22,6 +22,7 @@
 #include "infohash.h"
 #include "crypto.h"
 #include "utils.h"
+#include "sockaddr.h"

 #include <msgpack.hpp>

@@ -51,7 +52,7 @@ struct Query;
 * @param form_addr: network address of the incoming request.
 * @param from_len: network address lendth of the incoming request.
 */
-using StorePolicy = std::function<bool(InfoHash key, std::shared_ptr<Value>& value, InfoHash from, const sockaddr* from_addr, socklen_t from_len)>;
+using StorePolicy = std::function<bool(InfoHash key, std::shared_ptr<Value>& value, const InfoHash& from, const SockAddr& addr)>;

 /**
 * An edition policy is applied once to every incoming value storage requests,
@@ -67,15 +68,15 @@ using StorePolicy = std::function<bool(InfoHash key, std::shared_ptr<Value>& val
 * @param form_addr: network address of the incoming request.
 * @param from_len: network address lendth of the incoming request.
 */
-using EditPolicy = std::function<bool(InfoHash key, const std::shared_ptr<Value>& old_val, std::shared_ptr<Value>& new_val, InfoHash from, const sockaddr* from_addr, socklen_t from_len)>;
+using EditPolicy = std::function<bool(InfoHash key, const std::shared_ptr<Value>& old_val, std::shared_ptr<Value>& new_val, const InfoHash& from, const SockAddr& addr)>;

 static constexpr const size_t MAX_VALUE_SIZE {1024 * 64};

 struct OPENDHT_PUBLIC ValueType {
    typedef uint16_t Id;

-    static bool DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t);
-    static bool DEFAULT_EDIT_POLICY(InfoHash, const std::shared_ptr<Value>&, std::shared_ptr<Value>&, InfoHash, const sockaddr*, socklen_t) {
+    static bool DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, const InfoHash&, const SockAddr&);
+    static bool DEFAULT_EDIT_POLICY(InfoHash, const std::shared_ptr<Value>&, std::shared_ptr<Value>&, const InfoHash&, const SockAddr&) {
        return false;
    }

@@ -300,6 +300,8 @@ cdef class NodeSet(object):
        return s
    def __iter__(self):
        return NodeSetIter(self)
+    def __len__(self):
+        return self.size()

 cdef class PrivateKey(_WithID):
    cdef shared_ptr[cpp.PrivateKey] _key
@@ -442,6 +444,10 @@ cdef class DhtConfig(object):
        self._config.dht_config.node_config.node_id = id._infohash
    def setNetwork(self, unsigned netid):
        self._config.dht_config.node_config.network = netid
+    def setPort(self, cpp.in_port_t port):
+        self._config.dht_config.node_config.network_config.bind_port = port
+    def setBindAddr(self, string addr):
+        self._config.dht_config.node_config.network_config.bind_addr = addr
    def setMaintainStorage(self, bool maintain_storage):
        self._config.dht_config.node_config.maintain_storage = maintain_storage

@@ -460,7 +466,7 @@ cdef class DhtRunner(_WithID):
        if done_cb:
            cb_obj = {'done':done_cb}
            ref.Py_INCREF(cb_obj)
-            self.thisptr.get().bootstrap(addr._addr, cpp.bindDoneCbSimple(done_callback_simple, <void*>cb_obj))
+            self.thisptr.get().ping(addr._addr, cpp.bindDoneCbSimple(done_callback_simple, <void*>cb_obj))
        else:
            lock = threading.Condition()
            pending = 0
@@ -484,12 +490,10 @@ cdef class DhtRunner(_WithID):
    def run(self, Identity id=None, is_bootstrap=False, cpp.in_port_t port=0, str ipv4="", str ipv6="", DhtConfig config=DhtConfig()):
        if id:
            config.setIdentity(id)
-        if ipv4 or ipv6:
-            bind4 = ipv4.encode() if ipv4 else b''
-            bind6 = ipv6.encode() if ipv6 else b''
-            self.thisptr.get().run(bind4, bind6, str(port).encode(), config._config)
-        else:
-            self.thisptr.get().run(port, config._config)
+        config.setPort(port)
+        if ipv6:
+            config.setBindAddr(ipv6)
+        self.thisptr.get().run(config._config)
    def join(self):
        self.thisptr.get().join()
    def shutdown(self, shutdown_cb=None):
@@ -504,9 +508,9 @@ cdef class DhtRunner(_WithID):
        cpp.enableFileLogging(self.thisptr.get()[0], path.encode())
    def isRunning(self):
        return self.thisptr.get().isRunning()
-    def getBound(self, cpp.sa_family_t af = 0):
+    def getBound(self):
        s = SockAddr()
-        s._addr = self.thisptr.get().getBound(af)
+        s._addr = self.thisptr.get().getBound()
        return s
    def getStorageLog(self):
        return self.thisptr.get().getStorageLog().decode()
@@ -73,7 +73,7 @@ cdef extern from "opendht/sockaddr.h" namespace "dht":
        SockAddr() except +
        string toString() const
        in_port_t getPort() const
-        void setPort(in_port_t p)
+        void setPort(in_port_t p) const
        sa_family_t getFamily() const
        void setFamily(sa_family_t f)

@@ -198,11 +198,15 @@ cdef extern from "opendht/callbacks.h" namespace "dht":
    cdef DoneCallback bindDoneCb(DoneCallbackRaw cb, void *user_data)
    cdef DoneCallbackSimple bindDoneCbSimple(DoneCallbackSimpleRaw cb, void *user_data)

+    cppclass NetworkConfig:
+        string bind_addr
+        in_port_t bind_port
    cppclass Config:
        InfoHash node_id
        uint32_t network
        bool is_bootstrap
        bool maintain_storage
+        NetworkConfig network_config
    cppclass SecureDhtConfig:
        Config node_config
        Identity id
@@ -218,13 +222,12 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
        InfoHash getId() const
        InfoHash getNodeId() const
        void bootstrap(const_char*, const_char*)
-        void bootstrap(const SockAddr&, DoneCallbackSimple done_cb)
-        void run(in_port_t, Config config)
-        void run(const_char*, const_char*, const_char*, Config config)
+        void ping(const SockAddr&, DoneCallbackSimple done_cb)
+        void run(Config config)
        void join()
        void shutdown(ShutdownCallback)
        bool isRunning()
-        SockAddr getBound(sa_family_t af) const
+        SockAddr getBound() const
        string getStorageLog() const
        string getRoutingTablesLog(sa_family_t af) const
        string getSearchesLog(sa_family_t af) const
@@ -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++11"],
-          extra_link_args=["-std=c++11"],
+          extra_compile_args=["-std=c++14"],
+          extra_link_args=["-std=c++14"],
          libraries=["opendht"],
          library_dirs = ['@CURRENT_BINARY_DIR@', '@PROJECT_BINARY_DIR@']
      ))
@@ -9,6 +9,7 @@ libopendht_la_SOURCES  = \
        listener.h \
        request.h \
        search.h \
+        parsed_message.h \
        node_cache.cpp \
        callbacks.cpp \
        routing_table.cpp \
@@ -82,4 +83,3 @@ noinst_HEADERS = \
        @top_builddir@/argon2/src/encoding.h \
        @top_builddir@/argon2/src/thread.h
 endif
-
@@ -116,7 +116,7 @@ bool aesKeySizeGood(size_t key_size)
 #define GCM_DIGEST_SIZE GCM_BLOCK_SIZE
 #endif

-Blob aesEncrypt(const Blob& data, const Blob& key)
+Blob aesEncrypt(const Blob& data, const SecureBlob& key)
 {
    if (not aesKeySizeGood(key.size()))
        throw DecryptError("Wrong key size");
@@ -127,7 +127,7 @@ Blob aesEncrypt(const Blob& data, const Blob& key)
        std::generate_n(ret.begin(), GCM_IV_SIZE, std::bind(rand_byte, std::ref(rdev)));
    }
    struct gcm_aes_ctx aes;
-    gcm_aes_set_key(&aes, key.size(), key.data());
+    gcm_aes_set_key(&aes, key.size(), key.makeInsecure().data());
    gcm_aes_set_iv(&aes, GCM_IV_SIZE, ret.data());
    gcm_aes_update(&aes, data.size(), data.data());

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

-Blob aesDecrypt(const Blob& data, const Blob& key)
+Blob aesDecrypt(const Blob& data, const SecureBlob& key)
 {
    if (not aesKeySizeGood(key.size()))
        throw DecryptError("Wrong key size");
@@ -185,12 +185,12 @@ Blob aesDecrypt(const Blob& data, const std::string& password)
    if (data.size() <= PASSWORD_SALT_LENGTH)
        throw DecryptError("Wrong data size");
    Blob salt {data.begin(), data.begin()+PASSWORD_SALT_LENGTH};
-    Blob key = stretchKey(password, salt, 256/8);
+    SecureBlob key = stretchKey(password, salt, 256/8);
    Blob encrypted {data.begin()+PASSWORD_SALT_LENGTH, data.end()};
    return aesDecrypt(encrypted, key);
 }

-Blob stretchKey(const std::string& password, Blob& salt, size_t key_length)
+SecureBlob stretchKey(const std::string& password, Blob& salt, size_t key_length)
 {
    if (salt.empty()) {
        salt.resize(PASSWORD_SALT_LENGTH);
@@ -506,11 +506,7 @@ PublicKey::encrypt(const Blob& data) const
    unsigned aes_key_sz = aesKeySize(max_block_sz);
    if (aes_key_sz == 0)
        throw CryptoException("Key is not long enough for AES128");
-    Blob key(aes_key_sz);
-    {
-        crypto::random_device rdev;
-        std::generate_n(key.begin(), key.size(), std::bind(rand_byte, std::ref(rdev)));
-    }
+    auto key = SecureBlob::getRandom(aes_key_sz);
    auto data_encrypted = aesEncrypt(data, key);

    Blob ret;
@@ -529,7 +525,8 @@ PublicKey::getId() const
        return {};
    InfoHash id;
    size_t sz = id.size();
-    if (auto err = gnutls_pubkey_get_key_id(pk, 0, id.data(), &sz))
+    constexpr int flags = (id.size() == 32) ? GNUTLS_KEYID_USE_SHA256 : 0;
+    if (auto err = gnutls_pubkey_get_key_id(pk, flags, 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.");
@@ -940,7 +937,7 @@ Certificate::generate(const PrivateKey& key, const std::string& name, Identity c

    if (ca.first && ca.second) {
        if (not ca.second->isCA()) {
-            // Signing certificate must be CA.
+            std::cerr << "Error: signing certificate must be CA." << std::endl;
            return {};
        }
        //if (gnutls_x509_crt_sign2(cert, ca.second->cert, ca.first->x509_key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
@@ -27,14 +27,14 @@ std::ostream& operator<< (std::ostream& s, const DhtMessage& v)
 }

 bool
-DhtMessage::storePolicy(InfoHash h, std::shared_ptr<Value>& v, InfoHash f, const sockaddr* fa, socklen_t fas)
+DhtMessage::storePolicy(InfoHash h, std::shared_ptr<Value>& v, const InfoHash& f, const SockAddr& sa)
 {
    try {
        auto msg = unpackMsg<DhtMessage>(v->data);
        if (msg.service.empty())
            return false;
    } catch (const std::exception& e) {}
-    return ValueType::DEFAULT_STORE_POLICY(h, v, f, fa, fas);
+    return ValueType::DEFAULT_STORE_POLICY(h, v, f, sa);
 }

 Value::Filter
@@ -54,12 +54,11 @@ DhtMessage::ServiceFilter(std::string s)

 std::ostream& operator<< (std::ostream& s, const IpServiceAnnouncement& v)
 {
-    s << "Peer: ";
-    s << "port " << v.getPort();
-
-    if (v.ss.ss_family == AF_INET || v.ss.ss_family == AF_INET6) {
+    if (v.addr) {
+        s << "Peer: ";
+        s << "port " << v.getPort();
        char hbuf[NI_MAXHOST];
-        if (getnameinfo((sockaddr*)&v.ss, sizeof(v.ss), hbuf, sizeof(hbuf), nullptr, 0, NI_NUMERICHOST) == 0) {
+        if (getnameinfo(v.addr.get(), v.addr.getLength(), hbuf, sizeof(hbuf), nullptr, 0, NI_NUMERICHOST) == 0) {
            s << " addr " << std::string(hbuf, strlen(hbuf));
        }
    }
@@ -67,17 +66,17 @@ std::ostream& operator<< (std::ostream& s, const IpServiceAnnouncement& v)
 }

 bool
-IpServiceAnnouncement::storePolicy(InfoHash h, std::shared_ptr<Value>& v, InfoHash f, const sockaddr* from, socklen_t fromlen)
+IpServiceAnnouncement::storePolicy(InfoHash h, std::shared_ptr<Value>& v, const InfoHash& f, const SockAddr& sa)
 {
    try {
        auto msg = unpackMsg<IpServiceAnnouncement>(v->data);
        if (msg.getPort() == 0)
            return false;
-        IpServiceAnnouncement sa_addr {from, fromlen};
+        IpServiceAnnouncement sa_addr {sa};
        sa_addr.setPort(msg.getPort());
        // argument v is modified (not the value).
        v = std::make_shared<Value>(IpServiceAnnouncement::TYPE, sa_addr, v->id);
-        return ValueType::DEFAULT_STORE_POLICY(h, v, f, from, fromlen);
+        return ValueType::DEFAULT_STORE_POLICY(h, v, f, sa);
    } catch (const std::exception& e) {}
    return false;
 }
@@ -20,98 +20,32 @@
 #include "dhtrunner.h"
 #include "securedht.h"

-#ifndef _WIN32
-#include <unistd.h>
-#else
-#include <io.h>
-#endif
-
-#ifndef _WIN32
-#include <sys/socket.h>
-#else
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#define close(x) closesocket(x)
-#endif
-
 namespace dht {

 constexpr std::chrono::seconds DhtRunner::BOOTSTRAP_PERIOD;

 DhtRunner::DhtRunner() : dht_()
 {
-#ifdef _WIN32
-    WSADATA wsd;
-    if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
-        throw DhtException("Can't initialize Winsock2");
-#endif
+    uv_async_.data = this;
+    uv_async_init(uv_loop_.get(), &uv_async_, &DhtRunner::loop_callback);
 }

 DhtRunner::~DhtRunner()
 {
    join();
-#ifdef _WIN32
-    WSACleanup();
-#endif
 }

 void
-DhtRunner::run(in_port_t port, DhtRunner::Config config)
-{
-    sockaddr_in sin4;
-    std::fill_n((uint8_t*)&sin4, sizeof(sin4), 0);
-    sin4.sin_family = AF_INET;
-    sin4.sin_port = htons(port);
-    sockaddr_in6 sin6;
-    std::fill_n((uint8_t*)&sin6, sizeof(sin6), 0);
-    sin6.sin6_family = AF_INET6;
-    sin6.sin6_port = htons(port);
-    run(&sin4, &sin6, config);
-}
-
-void
-DhtRunner::run(const char* ip4, const char* ip6, const char* service, DhtRunner::Config config)
-{
-    auto res4 = getAddrInfo(ip4, service);
-    auto res6 = getAddrInfo(ip6, service);
-    run(res4.empty() ? nullptr : (sockaddr_in*) &res4.front().first,
-        res6.empty() ? nullptr : (sockaddr_in6*)&res6.front().first, config);
-}
-
-void
-DhtRunner::run(const sockaddr_in* local4, const sockaddr_in6* local6, DhtRunner::Config config)
+DhtRunner::run(DhtRunner::Config config)
 {
    if (running)
        return;
-    if (rcv_thread.joinable())
-        rcv_thread.join();
    running = true;
-    doRun(local4, local6, config.dht_config);
+    doRun(config.dht_config);
    if (not config.threaded)
        return;
    dht_thread = std::thread([this]() {
-        while (running) {
-            std::unique_lock<std::mutex> lk(dht_mtx);
-            auto wakeup = loop_();
-            cv.wait_until(lk, wakeup, [this]() {
-                if (not running)
-                    return true;
-                {
-                    std::lock_guard<std::mutex> lck(sock_mtx);
-                    if (not rcv.empty())
-                        return true;
-                }
-                {
-                    std::lock_guard<std::mutex> lck(storage_mtx);
-                    if (not pending_ops_prio.empty())
-                        return true;
-                    auto s = getStatus();
-                    if (not pending_ops.empty() and (s == NodeStatus::Connected or (s == NodeStatus::Disconnected and not bootstraping)))
-                        return true;
-                }
-                return false;
-            });
-        }
+        uv_loop_.run();
    });
 }

@@ -121,21 +55,19 @@ DhtRunner::shutdown(ShutdownCallback cb) {
    pending_ops_prio.emplace([=](SecureDht& dht) mutable {
        dht.shutdown(cb);
    });
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
 DhtRunner::join()
 {
    running = false;
-    cv.notify_all();
-    bootstrap_cv.notify_all();
+    uv_async_send(&uv_async_);
+    //bootstrap_cv.notify_all();
    if (dht_thread.joinable())
        dht_thread.join();
-    if (rcv_thread.joinable())
-        rcv_thread.join();
-    if (bootstrap_thread.joinable())
-        bootstrap_thread.join();
+    /*if (bootstrap_thread.joinable())
+        bootstrap_thread.join();*/

    {
        std::lock_guard<std::mutex> lck(storage_mtx);
@@ -145,10 +77,10 @@ DhtRunner::join()
    {
        std::lock_guard<std::mutex> lck(dht_mtx);
        dht_.reset();
-        status4 = NodeStatus::Disconnected;
+        /*status4 = NodeStatus::Disconnected;
        status6 = NodeStatus::Disconnected;
        bound4 = {};
-        bound6 = {};
+        bound6 = {};*/
    }
 }

@@ -175,6 +107,14 @@ DhtRunner::getNodeId() const
    return dht_->getNodeId();
 }

+void
+DhtRunner::setOnStatusChanged(StatusCallback&& cb)
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (not dht_)
+        throw std::runtime_error("dht is not running");
+    dht_->setOnStatusChanged(std::move(cb));
+}

 std::pair<size_t, size_t>
 DhtRunner::getStoreSize() const {
@@ -303,10 +243,15 @@ DhtRunner::getPublicAddressStr(sa_family_t af)
 {
    auto addrs = getPublicAddress(af);
    std::vector<std::string> ret(addrs.size());
-    std::transform(addrs.begin(), addrs.end(), ret.begin(), dht::printAddr);
+    std::transform(addrs.begin(), addrs.end(), ret.begin(), [](const SockAddr& a) { return a.toString(); });
    return ret;
 }

+SockAddr 
+DhtRunner::getBound() const {
+    return dht_->getBoundAddr();
+}
+
 void
 DhtRunner::registerCertificate(std::shared_ptr<crypto::Certificate> cert) {
    std::lock_guard<std::mutex> lck(dht_mtx);
@@ -318,42 +263,12 @@ DhtRunner::setLocalCertificateStore(CertificateStoreQuery&& query_method) {
    dht_->setLocalCertificateStore(std::forward<CertificateStoreQuery>(query_method));
 }

-time_point
+void
 DhtRunner::loop_()
 {
    if (!dht_)
-        return {};
-
-    decltype(pending_ops) ops {};
-    {
-        std::lock_guard<std::mutex> lck(storage_mtx);
-        auto s = getStatus();
-        ops = (pending_ops_prio.empty() && (s == NodeStatus::Connected or (s == NodeStatus::Disconnected and not bootstraping))) ?
-               std::move(pending_ops) : std::move(pending_ops_prio);
-    }
-    while (not ops.empty()) {
-        ops.front()(*dht_);
-        ops.pop();
-    }
-
-    time_point wakeup {};
-    decltype(rcv) received {};
-    {
-        std::lock_guard<std::mutex> lck(sock_mtx);
-        // move to stack
-        received = std::move(rcv);
-    }
-    if (not received.empty()) {
-        for (const auto& pck : received) {
-            auto& buf = pck.first;
-            auto& from = pck.second;
-            wakeup = dht_->periodic(buf.data(), buf.size()-1, from);
-        }
-        received.clear();
-    } else {
-        wakeup = dht_->periodic(nullptr, 0, nullptr, 0);
-    }
-
+        return;
+/*
    NodeStatus nstatus4 = dht_->getStatus(AF_INET);
    NodeStatus nstatus6 = dht_->getStatus(AF_INET6);
    if (nstatus4 != status4 || nstatus6 != status6) {
@@ -371,102 +286,24 @@ DhtRunner::loop_()
        if (statusCb)
            statusCb(status4, status6);
    }
-
-    return wakeup;
+*/
+    decltype(pending_ops) ops {};
+    {
+        std::lock_guard<std::mutex> lck(storage_mtx);
+        auto s = dht_->getStatus();
+        ops = (pending_ops_prio.empty() && (s == NodeStatus::Connected or (s == NodeStatus::Disconnected and not bootstraping))) ?
+               std::move(pending_ops) : std::move(pending_ops_prio);
+    }
+    while (not ops.empty()) {
+        ops.front()(*dht_);
+        ops.pop();
+    }
 }

 void
-DhtRunner::doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDht::Config config)
+DhtRunner::doRun(SecureDht::Config config)
 {
-    dht_.reset();
-
-    int s4 = -1,
-        s6 = -1;
-
-    bound4 = {};
-    if (sin4) {
-        s4 = socket(PF_INET, SOCK_DGRAM, 0);
-        if(s4 >= 0) {
-            int rc = bind(s4, (sockaddr*)sin4, sizeof(sockaddr_in));
-            if(rc < 0)
-                throw DhtException("Can't bind IPv4 socket on " + dht::print_addr((sockaddr*)sin4, sizeof(sockaddr_in)));
-            bound4.second = sizeof(bound4.first);
-            getsockname(s4, (sockaddr*)&bound4.first, &bound4.second);
-        }
-    }
-
-#if 1
-    bound6 = {};
-    if (sin6) {
-        s6 = socket(PF_INET6, SOCK_DGRAM, 0);
-        if(s6 >= 0) {
-            int val = 1;
-            int rc = setsockopt(s6, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&val, sizeof(val));
-            if(rc < 0)
-                throw DhtException("Can't set IPV6_V6ONLY");
-
-            rc = bind(s6, (sockaddr*)sin6, sizeof(sockaddr_in6));
-            if(rc < 0)
-                throw DhtException("Can't bind IPv6 socket on " + dht::print_addr((sockaddr*)sin6, sizeof(sockaddr_in6)));
-            bound6.second = sizeof(bound6.first);
-            getsockname(s6, (sockaddr*)&bound6.first, &bound6.second);
-        }
-    }
-#endif
-
-    dht_ = std::unique_ptr<SecureDht>(new SecureDht {s4, s6, config});
-
-    rcv_thread = std::thread([this,s4,s6]() {
-        try {
-            while (true) {
-                struct timeval tv {/*.tv_sec = */0, /*.tv_usec = */250000};
-                fd_set readfds;
-
-                FD_ZERO(&readfds);
-                if(s4 >= 0)
-                    FD_SET(s4, &readfds);
-                if(s6 >= 0)
-                    FD_SET(s6, &readfds);
-
-                int rc = select(s4 > s6 ? s4 + 1 : s6 + 1, &readfds, nullptr, nullptr, &tv);
-                if(rc < 0) {
-                    if(errno != EINTR) {
-                        perror("select");
-                        std::this_thread::sleep_for( std::chrono::seconds(1) );
-                    }
-                }
-
-                if(!running)
-                    break;
-
-                if(rc > 0) {
-                    std::array<uint8_t, 1024 * 64> buf;
-                    SockAddr from;
-                    from.second = sizeof(from.first);
-
-                    if(s4 >= 0 && FD_ISSET(s4, &readfds))
-                        rc = recvfrom(s4, (char*)buf.data(), buf.size(), 0, (struct sockaddr*)&from.first, &from.second);
-                    else if(s6 >= 0 && FD_ISSET(s6, &readfds))
-                        rc = recvfrom(s6, (char*)buf.data(), buf.size(), 0, (struct sockaddr*)&from.first, &from.second);
-                    else
-                        break;
-                    if (rc > 0) {
-                        {
-                            std::lock_guard<std::mutex> lck(sock_mtx);
-                            rcv.emplace_back(Blob {buf.begin(), buf.begin()+rc+1}, from);
-                        }
-                        cv.notify_all();
-                    }
-                }
-            }
-        } catch (const std::exception& e) {
-            std::cerr << "Error in DHT networking thread: " << e.what() << std::endl;
-        }
-        if (s4 >= 0)
-            close(s4);
-        if (s6 >= 0)
-            close(s6);
-    });
+    dht_ = std::unique_ptr<SecureDht>(new SecureDht {uv_loop_.get(), config});
 }

 void
@@ -475,10 +312,11 @@ DhtRunner::get(InfoHash hash, GetCallback vcb, DoneCallback dcb, Value::Filter f
    {
        std::lock_guard<std::mutex> lck(storage_mtx);
        pending_ops.emplace([=](SecureDht& dht) mutable {
+            std::cout << "DhtRunner dht.get " << hash << std::endl;
            dht.get(hash, vcb, dcb, std::move(f), std::move(w));
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -493,7 +331,7 @@ void DhtRunner::query(const InfoHash& hash, QueryCallback cb, DoneCallback done_
            dht.query(hash, cb, done_cb, std::move(q));
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 std::future<size_t>
@@ -506,7 +344,7 @@ DhtRunner::listen(InfoHash hash, GetCallback vcb, Value::Filter f, Where w)
            ret_token->set_value(dht.listen(hash, vcb, std::move(f), std::move(w)));
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
    return ret_token->get_future();
 }

@@ -525,7 +363,7 @@ DhtRunner::cancelListen(InfoHash h, size_t token)
            dht.cancelListen(h, token);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -538,7 +376,7 @@ DhtRunner::cancelListen(InfoHash h, std::shared_future<size_t> token)
            dht.cancelListen(h, tk);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -551,7 +389,7 @@ DhtRunner::put(InfoHash hash, Value&& value, DoneCallback cb, time_point created
            dht.put(hash, sv, cb, created, permanent);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -563,7 +401,7 @@ DhtRunner::put(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb, tim
            dht.put(hash, value, cb, created, permanent);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -581,7 +419,7 @@ DhtRunner::cancelPut(const InfoHash& h , const Value::Id& id)
            dht.cancelPut(h, id);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -593,7 +431,7 @@ DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback c
            dht.putSigned(hash, value, cb);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -617,7 +455,7 @@ DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value
            dht.putEncrypted(hash, to, value, cb);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -632,6 +470,7 @@ DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, Done
    putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), cb);
 }

+/*
 void
 DhtRunner::tryBootstrapContinuously()
 {
@@ -689,7 +528,7 @@ DhtRunner::tryBootstrapContinuously()
            }
        } while (bootstraping);
    });
-}
+}*/

 std::vector<std::pair<sockaddr_storage, socklen_t>>
 DhtRunner::getAddrInfo(const std::string& host, const std::string& service)
@@ -719,45 +558,60 @@ DhtRunner::getAddrInfo(const std::string& host, const std::string& service)
 void
 DhtRunner::bootstrap(const std::string& host, const std::string& service)
 {
-    std::lock_guard<std::mutex> lck(bootstrap_mtx);
+    /*std::lock_guard<std::mutex> lck(bootstrap_mtx);
    bootstrap_nodes_all.emplace_back(host, service);
    bootstrap_nodes.emplace_back(host, service);
-    tryBootstrapContinuously();
+    tryBootstrapContinuously();*/
+    pending_ops_prio.emplace([=](SecureDht& dht) mutable {
+        dht.bootstrap(host, service);
+    });
+    uv_async_send(&uv_async_);
 }

 void
 DhtRunner::clearBootstrap()
 {
-    std::lock_guard<std::mutex> lck(bootstrap_mtx);
-    bootstrap_nodes_all.clear();
+    //std::lock_guard<std::mutex> lck(bootstrap_mtx);
+    //bootstrap_nodes_all.clear();
+    pending_ops_prio.emplace([=](SecureDht& dht) mutable {
+        dht.clearBootstrap();
+    });
+    uv_async_send(&uv_async_);
 }

 void
-DhtRunner::bootstrap(const std::vector<std::pair<sockaddr_storage, socklen_t>>& nodes, DoneCallbackSimple&& cb)
+DhtRunner::ping(const std::vector<std::pair<sockaddr_storage, socklen_t>>& nodes, DoneCallback&& cb)
 {
    std::lock_guard<std::mutex> lck(storage_mtx);
    pending_ops_prio.emplace([=](SecureDht& dht) mutable {
-        auto rem = cb ? std::make_shared<std::pair<size_t, bool>>(nodes.size(), false) : nullptr;
+        struct GroupPing {
+            size_t remaining {0};
+            bool ok {false};
+            std::vector<Sp<Node>> nodes;
+            GroupPing(size_t s) : remaining(s) {}
+        };
+        Sp<GroupPing> rem = cb ? std::make_shared<GroupPing>(nodes.size()) : nullptr;
        for (auto& node : nodes)
-            dht.pingNode((sockaddr*)&node.first, node.second, cb ? [rem,cb](bool ok) {
+            dht.pingNode(SockAddr((sockaddr*)&node.first, node.second), cb ? [rem,cb](bool ok, std::vector<Sp<Node>>&& nodes) {
                auto& r = *rem;
-                r.first--;
-                r.second |= ok;
-                if (not r.first)
-                    cb(r.second);
-            } : DoneCallbackSimple{});
+                r.remaining--;
+                r.ok |= ok;
+                r.nodes.insert(r.nodes.end(), nodes.begin(), nodes.end());
+                if (r.remaining == 0)
+                    cb(r.ok, std::move(r.nodes));
+            } : DoneCallback{});
    });
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
-DhtRunner::bootstrap(const SockAddr& addr, DoneCallbackSimple&& cb)
+DhtRunner::ping(const SockAddr& addr, DoneCallback&& cb)
 {
    std::lock_guard<std::mutex> lck(storage_mtx);
    pending_ops_prio.emplace([addr,cb](SecureDht& dht) mutable {
-        dht.pingNode((const sockaddr*)&addr.first, addr.second, std::move(cb));
+        dht.pingNode(addr, std::move(cb));
    });
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -770,7 +624,7 @@ DhtRunner::bootstrap(const std::vector<NodeExport>& nodes)
                dht.insertNode(node);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -782,7 +636,7 @@ DhtRunner::connectivityChanged()
            dht.connectivityChanged();
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 void
@@ -793,7 +647,7 @@ DhtRunner::findCertificate(InfoHash hash, std::function<void(const std::shared_p
            dht.findCertificate(hash, cb);
        });
    }
-    cv.notify_all();
+    uv_async_send(&uv_async_);
 }

 }
@@ -20,6 +20,7 @@

 #include "node.h"
 #include "request.h"
+#include "rng.h"

 #include <sstream>

@@ -29,6 +30,14 @@ constexpr std::chrono::minutes Node::NODE_EXPIRE_TIME;
 constexpr std::chrono::minutes Node::NODE_GOOD_TIME;
 constexpr std::chrono::seconds Node::MAX_RESPONSE_TIME;

+
+Node::Node(const InfoHash& id, const SockAddr& addr, const Sp<TcpSocket>& s, bool client)
+: id(id), addr(addr), sock(s), is_client(client), sockets_()
+{
+    crypto::random_device rd;
+    transaction_id = std::uniform_int_distribution<SocketId>{1}(rd);
+}
+
 /* This is our definition of a known-good node. */
 bool
 Node::isGood(time_point now) const
@@ -41,11 +50,9 @@ Node::isGood(time_point now) const
 bool
 Node::isPendingMessage() const
 {
-    for (auto w : requests_) {
-        if (auto r = w.lock()) {
-            if (r->pending())
-                return true;
-        }
+    for (auto r : requests_) {
+        if (r.second->pending())
+            return true;
    }
    return false;
 }
@@ -54,44 +61,61 @@ size_t
 Node::getPendingMessageCount() const
 {
    size_t count {0};
-    for (auto w : requests_) {
-        if (auto r = w.lock()) {
-            if (r->pending())
-                count++;
-        }
+    for (auto r : requests_) {
+        if (r.second->pending())
+            count++;
    }
    return count;
 }

 void
-Node::update(const SockAddr& new_addr)
+Node::update(const SockAddr& new_addr, const Sp<TcpSocket>& s)
 {
    addr = new_addr;
+    if (not sock or (s and sock->isClosed() and not s->isClosed()))
+        sock = s;
 }

 /** To be called when a message was sent to the node */
 void
-Node::requested(std::shared_ptr<net::Request>& req)
+Node::requested(const Sp<net::Request>& req)
 {
-    requests_.emplace_back(req);
+    auto e = requests_.emplace(req->getTid(), req);
+    if (not e.second and req != e.first->second) {
+        // Should not happen !
+        // Try to handle this scenario as well as we can
+        e.first->second->setExpired();
+        e.first->second = req;
+    }
 }

 /** To be called when a message was received from the node.
 Req should be true if the message was an aswer to a request we made*/
 void
-Node::received(time_point now, std::shared_ptr<net::Request> req)
+Node::received(time_point now, const Sp<net::Request>& req)
 {
    time = now;
    expired_ = false;
    if (req) {
        reply_time = now;
-        for (auto it = requests_.begin(); it != requests_.end();) {
-            auto r = it->lock();
-            if (not r or r == req)
-                it = requests_.erase(it);
-            else
-                ++it;
-        }
+        requests_.erase(req->getTid());
+    }
+}
+
+Sp<net::Request>
+Node::getRequest(const net::TransId& tid)
+{
+    auto it = requests_.find(tid);
+    return it != requests_.end() ? it->second : nullptr;
+}
+
+void
+Node::cancelRequest(const Sp<net::Request>& req)
+{
+    if (req) {
+        req->cancel();
+        closeSocket(req->closeSocket());
+        requests_.erase(req->getTid());
    }
 }

@@ -99,13 +123,41 @@ void
 Node::setExpired()
 {
    expired_ = true;
-    for (auto w : requests_) {
-        if (auto r = w.lock())
-            r->setExpired();
+    for (auto r : requests_) {
+        r.second->setExpired();
    }
    requests_.clear();
+    sockets_.clear();
 }

+SocketId
+Node::openSocket(SocketCb&& cb)
+{
+    if (++transaction_id == 0)
+        transaction_id = 1;
+
+    auto sock = Socket(std::move(cb));
+    auto s = sockets_.emplace(transaction_id, std::move(sock));
+    if (not s.second)
+        s.first->second = std::move(sock);
+    return transaction_id;
+}
+
+Socket*
+Node::getSocket(SocketId id)
+{
+    auto it = sockets_.find(id);
+    return it == sockets_.end() ? nullptr : &it->second;
+}
+
+void
+Node::closeSocket(SocketId id)
+{
+    if (id) {
+        sockets_.erase(id);
+        //DHT_LOG.w("Closing socket (tid: %d), %lu remaining", socket->id, sockets_.size());
+    }
+}

 std::string
 Node::toString() const
@@ -20,44 +20,47 @@

 namespace dht {

-std::shared_ptr<Node>
+Sp<Node>
 NodeCache::getNode(const InfoHash& id, sa_family_t family) {
-    return (family == AF_INET ? cache_4 : cache_6).getNode(id);
+    return cache(family).getNode(id);
 }

-std::shared_ptr<Node>
-NodeCache::getNode(const InfoHash& id, const SockAddr& addr, time_point now, bool confirm) {
+Sp<Node>
+NodeCache::getNode(const InfoHash& id, const SockAddr& addr, const Sp<TcpSocket>& sock, time_point now, bool confirm, bool client) {
    if (id == zeroes)
        return std::make_shared<Node>(id, addr);
-    return (addr.getFamily() == AF_INET ? cache_4 : cache_6).getNode(id, addr, now, confirm);
+    return cache(addr.getFamily()).getNode(id, addr, sock, now, confirm, client);
 }

-std::vector<std::shared_ptr<Node>>
-NodeCache::getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count) {
-    const auto& c = (sa_f == AF_INET ? cache_4 : cache_6);
-    auto it_p = c.lower_bound(id),
-         it_n = it_p;
+std::vector<Sp<Node>>
+NodeCache::getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count) const
+{
+    const auto& c = cache(sa_f);

-    std::vector<std::shared_ptr<Node>> nodes;
+    std::vector<Sp<Node>> nodes;
    nodes.reserve(std::min(c.size(), count));
    NodeMap::const_iterator it;
+    auto dec_it = [&c](NodeMap::const_iterator& it) {
+        auto ret = it;
+        it = (it == c.cbegin()) ? c.cend() : std::prev(it);
+        return ret;
+    };

-    if (it_p != c.begin()) /* Create 2 separate iterator if we could */
-        --it_p;
+    auto it_p = c.lower_bound(id),
+        it_n = it_p;
+    if (not c.empty())
+        dec_it(it_p); /* Create 2 separate iterator if we could */

-    while (nodes.size() < count and (it_n != c.end() or it_p != c.end())) {
+    while (nodes.size() < count and (it_n != c.cend() or it_p != c.cend())) {
        /* If one of the iterator is at the end, then take the other one
           If they are both in middle of somewhere comapre both and take
           the closest to the id. */
-        if (it_p == c.end())       it = it_n++;
-        else if (it_n == c.end())  it = it_p--;
-        else                       it = id.xorCmp(it_p->first, it_n->first) < 0 ? it_p-- : it_n++;
-
-        if (it == c.begin())
-            it_p = c.end();
+        if (it_p == c.cend())       it = it_n++;
+        else if (it_n == c.cend())  it = dec_it(it_p);
+        else                        it = id.xorCmp(it_p->first, it_n->first) < 0 ? dec_it(it_p) : it_n++;

        if (auto n = it->second.lock())
-            if ( not n->isExpired() )
+            if ( not n->isExpired() and not n->isClient() )
                nodes.emplace_back(std::move(n));
    }

@@ -71,11 +74,22 @@ NodeCache::clearBadNodes(sa_family_t family)
        clearBadNodes(AF_INET);
        clearBadNodes(AF_INET6);
    } else {
-        (family == AF_INET ? cache_4 : cache_6).clearBadNodes();
+        cache(family).clearBadNodes();
    }
 }

-std::shared_ptr<Node>
+void
+NodeCache::closeAll(sa_family_t family)
+{
+    if (family == 0) {
+        closeAll(AF_INET);
+        closeAll(AF_INET6);
+    } else {
+        (family == AF_INET ? cache_4 : cache_6).closeAll();
+    }
+}
+
+Sp<Node>
 NodeCache::NodeMap::getNode(const InfoHash& id)
 {
    auto wn = find(id);
@@ -87,16 +101,16 @@ NodeCache::NodeMap::getNode(const InfoHash& id)
    return {};
 }

-std::shared_ptr<Node>
-NodeCache::NodeMap::getNode(const InfoHash& id, const SockAddr& addr, time_point now, bool confirm)
+Sp<Node>
+NodeCache::NodeMap::getNode(const InfoHash& id, const SockAddr& addr, const Sp<TcpSocket>& sock, time_point now, bool confirm, bool client)
 {
    auto it = emplace(id, std::weak_ptr<Node>{});
    auto node = it.first->second.lock();
    if (not node) {
-        node = std::make_shared<Node>(id, addr);
+        node = std::make_shared<Node>(id, addr, sock, client);
        it.first->second = node;
-    } else if (confirm || node->time < now - Node::NODE_EXPIRE_TIME) {
-        node->update(addr);
+    } else if (confirm or node->isOld(now)) {
+        node->update(addr, sock);
    }
    return node;
 }
@@ -113,4 +127,21 @@ NodeCache::NodeMap::clearBadNodes() {
    }
 }

+void
+NodeCache::NodeMap::closeAll()
+{
+    for (auto it = cbegin(); it != cend();) {
+        if (auto n = it->second.lock()) {
+            if (n->sock) {
+                n->sock->close();
+                n->sock.reset();
+            }
+            ++it;
+        } else {
+            erase(it++);
+        }
+    }
+}
+
+
 }
@@ -0,0 +1,309 @@
+/*
+ *  Copyright (C) 2017 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
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+ #pragma once
+
+#include "infohash.h"
+#include "sockaddr.h"
+#include "net.h"
+
+#include <map>
+
+namespace dht {
+namespace net {
+
+enum class MessageType {
+    Error = 0,
+    Reply,
+    Ping,
+    FindNode,
+    GetValues,
+    AnnounceValue,
+    Refresh,
+    Listen,
+    ValueData
+};
+
+struct ParsedMessage {
+    MessageType type;
+    /* Node ID of the sender */
+    InfoHash id;
+    /* Network id */
+    NetId network {0};
+    /** Is a client node */
+    bool is_client {false};
+    /* hash for which values are requested */
+    InfoHash info_hash;
+    /* target id around which to find nodes */
+    InfoHash target;
+    /* transaction id */
+    TransId tid;
+    /* tid for packets going through request socket */
+    TransId socket_id;
+    /* security token */
+    Blob token;
+    /* the value id (announce confirmation) */
+    Value::Id value_id;
+    /* time when value was first created */
+    time_point created { time_point::max() };
+    /* IPv4 nodes in response to a 'find' request */
+    Blob nodes4_raw, nodes6_raw;
+    std::vector<Sp<Node>> nodes4, nodes6;
+    /* values to store or retreive request */
+    std::vector<Sp<Value>> values;
+    /* index for fields values */
+    std::vector<Sp<FieldValueIndex>> fields;
+    /** When part of the message header: {index -> (total size, {})}
+     *  When part of partial value data: {index -> (offset, part_data)} */
+    std::map<unsigned, std::pair<unsigned, Blob>> value_parts;
+    /* query describing a filter to apply on values. */
+    Query query;
+    /* states if ipv4 or ipv6 request */
+    want_t want;
+    /* error code in case of error */
+    uint16_t error_code;
+    /* reported address by the distant node */
+    std::string ua;
+    SockAddr addr;
+    void msgpack_unpack(msgpack::object o);
+
+    bool append(const ParsedMessage& block);
+    bool complete();
+};
+
+bool
+ParsedMessage::append(const ParsedMessage& block)
+{
+    bool ret(false);
+    for (const auto& ve : block.value_parts) {
+        auto part_val = value_parts.find(ve.first);
+        if (part_val == value_parts.end()
+            || part_val->second.second.size() >= part_val->second.first)
+            continue;
+        // TODO: handle out-of-order packets
+        if (ve.second.first != part_val->second.second.size()) {
+            //std::cout << "skipping out-of-order packet" << std::endl;
+            continue;
+        }
+        ret = true;
+        part_val->second.second.insert(part_val->second.second.end(),
+                                       ve.second.second.begin(),
+                                       ve.second.second.end());
+    }
+    return ret;
+}
+
+bool
+ParsedMessage::complete()
+{
+    for (auto& e : value_parts) {
+        //std::cout << "part " << e.first << ": " << e.second.second.size() << "/" << e.second.first << std::endl;
+        if (e.second.first > e.second.second.size())
+            return false;
+    }
+    for (auto& e : value_parts) {
+        msgpack::unpacked msg;
+        msgpack::unpack(msg, (const char*)e.second.second.data(), e.second.second.size());
+        values.emplace_back(std::make_shared<Value>(msg.get()));
+    }
+    return true;
+}
+
+void
+ParsedMessage::msgpack_unpack(msgpack::object msg)
+{
+    auto y = findMapValue(msg, "y");
+    auto r = findMapValue(msg, "r");
+    auto e = findMapValue(msg, "e");
+    auto v = findMapValue(msg, "p");
+
+    if (auto t = findMapValue(msg, "t"))
+        tid = unpackTid(*t);
+
+    if (auto rv = findMapValue(msg, "v"))
+        ua = rv->as<std::string>();
+
+    if (auto netid = findMapValue(msg, "n"))
+        network = netid->as<NetId>();
+
+    if (auto is_client_v = findMapValue(msg, "s"))
+        is_client = is_client_v->as<bool>();
+
+    std::string q;
+    if (auto rq = findMapValue(msg, "q")) {
+        if (rq->type != msgpack::type::STR)
+            throw msgpack::type_error();
+        q = rq->as<std::string>();
+    }
+
+    if (e)
+        type = MessageType::Error;
+    else if (r)
+        type = MessageType::Reply;
+    else if (v)
+        type = MessageType::ValueData;
+    else if (y and y->as<std::string>() != "q")
+        throw msgpack::type_error();
+    else if (q == "ping")
+        type = MessageType::Ping;
+    else if (q == "find")
+        type = MessageType::FindNode;
+    else if (q == "get")
+        type = MessageType::GetValues;
+    else if (q == "listen")
+        type = MessageType::Listen;
+    else if (q == "put")
+        type = MessageType::AnnounceValue;
+    else if (q == "refresh")
+        type = MessageType::Refresh;
+    else
+        throw msgpack::type_error();
+
+    if (type == MessageType::ValueData) {
+        if (v->type != msgpack::type::MAP)
+            throw msgpack::type_error();
+        for (size_t i = 0; i < v->via.map.size; ++i) {
+            auto& vdat = v->via.map.ptr[i];
+            auto o = findMapValue(vdat.val, "o");
+            auto d = findMapValue(vdat.val, "d");
+            if (not o or not d)
+                continue;
+            value_parts.emplace(vdat.key.as<unsigned>(), std::pair<size_t, Blob>(o->as<size_t>(), unpackBlob(*d)));
+        }
+        return;
+    }
+
+    auto a = findMapValue(msg, "a");
+    if (!a && !r && !e)
+        throw msgpack::type_error();
+    auto& req = a ? *a : (r ? *r : *e);
+
+    if (e) {
+        if (e->type != msgpack::type::ARRAY)
+            throw msgpack::type_error();
+        error_code = e->via.array.ptr[0].as<uint16_t>();
+    }
+
+    if (auto t = findMapValue(req, "sid"))
+        socket_id = unpackTid(*t);
+
+    if (auto rid = findMapValue(req, "id"))
+        id = {*rid};
+
+    if (auto rh = findMapValue(req, "h"))
+        info_hash = {*rh};
+
+    if (auto rtarget = findMapValue(req, "target"))
+        target = {*rtarget};
+
+    if (auto rquery = findMapValue(req, "q"))
+        query.msgpack_unpack(*rquery);
+
+    if (auto otoken = findMapValue(req, "token"))
+        token = unpackBlob(*otoken);
+
+    if (auto vid = findMapValue(req, "vid"))
+        value_id = vid->as<Value::Id>();
+
+    if (auto rnodes4 = findMapValue(req, "n4"))
+        nodes4_raw = unpackBlob(*rnodes4);
+
+    if (auto rnodes6 = findMapValue(req, "n6"))
+        nodes6_raw = unpackBlob(*rnodes6);
+
+    if (auto sa = findMapValue(req, "sa")) {
+        if (sa->type != msgpack::type::BIN)
+            throw msgpack::type_error();
+        auto l = sa->via.bin.size;
+        if (l == sizeof(in_addr)) {
+            addr.setFamily(AF_INET);
+            auto& a = addr.getIPv4();
+            std::fill_n((uint8_t*)&a, sizeof(a), 0);
+            a.sin_port = 0;
+            std::copy_n(sa->via.bin.ptr, l, (char*)&a.sin_addr);
+        } else if (l == sizeof(in6_addr)) {
+            addr.setFamily(AF_INET6);
+            auto& a = addr.getIPv6();
+            std::fill_n((uint8_t*)&a, sizeof(a), 0);
+            a.sin6_port = 0;
+            std::copy_n(sa->via.bin.ptr, l, (char*)&a.sin6_addr);
+        }
+    } else
+        addr = {};
+
+    if (auto rcreated = findMapValue(req, "c"))
+        created = from_time_t(rcreated->as<std::time_t>());
+
+    if (auto rvalues = findMapValue(req, "values")) {
+        if (rvalues->type != msgpack::type::ARRAY)
+            throw msgpack::type_error();
+        for (size_t i = 0; i < rvalues->via.array.size; i++) {
+            auto& packed_v = rvalues->via.array.ptr[i];
+            if (packed_v.type == msgpack::type::POSITIVE_INTEGER) {
+                // Skip oversize values with a small margin for header overhead
+                if (packed_v.via.u64 > MAX_VALUE_SIZE + 32)
+                    continue;
+                value_parts.emplace(i, std::make_pair(packed_v.via.u64, Blob{}));
+            } else {
+                try {
+                    values.emplace_back(std::make_shared<Value>(rvalues->via.array.ptr[i]));
+                } catch (const std::exception& e) {
+                     //DHT_LOG_WARN("Error reading value: %s", e.what());
+                }
+            }
+        }
+    } else if (auto raw_fields = findMapValue(req, "fields")) {
+        if (auto rfields = findMapValue(*raw_fields, "f")) {
+            auto vfields = rfields->as<std::set<Value::Field>>();
+            if (auto rvalues = findMapValue(*raw_fields, "v")) {
+                if (rvalues->type != msgpack::type::ARRAY)
+                    throw msgpack::type_error();
+                size_t val_num = rvalues->via.array.size / vfields.size();
+                for (size_t i = 0; i < val_num; ++i) {
+                    try {
+                        auto v = std::make_shared<FieldValueIndex>();
+                        v->msgpack_unpack_fields(vfields, *rvalues, i*vfields.size());
+                        fields.emplace_back(std::move(v));
+                    } catch (const std::exception& e) { }
+                }
+            }
+        } else {
+            throw msgpack::type_error();
+        }
+    }
+
+    if (auto w = findMapValue(req, "w")) {
+        if (w->type != msgpack::type::ARRAY)
+            throw msgpack::type_error();
+        want = 0;
+        for (unsigned i=0; i<w->via.array.size; i++) {
+            auto& val = w->via.array.ptr[i];
+            try {
+                auto w = val.as<sa_family_t>();
+                if (w == AF_INET)
+                    want |= WANT4;
+                else if(w == AF_INET6)
+                    want |= WANT6;
+            } catch (const std::exception& e) {};
+        }
+    } else {
+        want = -1;
+    }
+}
+
+} /* namespace net  */
+} /* namespace dht */
@@ -20,34 +20,15 @@
 #pragma once

 #include "net.h"
+#include "value.h"

 namespace dht {
+struct Node;
 namespace net {

 class NetworkEngine;
 struct ParsedMessage;

-/*!
- * @class   Socket
- * @brief   Open route to a node for continous incoming packets.
- * @details
- * A socket lets a remote node send us continuous packets treated using a
- * given callback. This is intended to provide an easy management of
- * specific updates nodes can send. For e.g, this is used in the case of the
- * "listen" operation for treating updates a node has for a given storage.
- */
-struct Socket {
-    Socket() {}
-    Socket(std::shared_ptr<Node> node,
-           TransId id,
-           std::function<void(const std::shared_ptr<Node>&, ParsedMessage&&)> on_receive) :
-        node(node), id(id), on_receive(on_receive) {}
-
-    std::shared_ptr<Node> node;
-    TransId id;
-    std::function<void(const std::shared_ptr<Node>&, ParsedMessage&&)> on_receive {};
-};
-
 /*!
 * @class   Request
 * @brief   An atomic request destined to a node.
@@ -59,7 +40,7 @@ struct Socket {
 struct Request {
    friend class dht::net::NetworkEngine;

-    std::shared_ptr<Node> node {};             /* the node to whom the request is destined. */
+    Sp<Node> node {};             /* the node to whom the request is destined. */
    time_point reply_time {time_point::min()}; /* time when we received the response to the request. */

    enum class State
@@ -78,14 +59,19 @@ struct Request {
    State getState() const { return state_; }

    Request(State state = State::PENDING) : state_(state) {}
-    Request(TransId tid,
-            std::shared_ptr<Node> node,
+    Request(const TransId& tid,
+            Sp<Node> node,
            Blob&& msg,
            std::function<void(const Request&, ParsedMessage&&)> on_done,
            std::function<void(const Request&, bool)> on_expired,
-            std::shared_ptr<Socket> socket = {}) :
+            uint32_t socket = 0) :
        node(node), on_done(on_done), on_expired(on_expired), tid(tid), msg(std::move(msg)), socket(socket) { }

+    TransId getTid() const { return tid; }
+
+    uint32_t getSocket() { return socket; }
+    uint32_t closeSocket() { auto ret = socket; socket = 0; return ret; }
+
    void setExpired() {
        if (pending()) {
            state_ = Request::State::EXPIRED;
@@ -132,7 +118,7 @@ private:

    const TransId tid; /* the request id. */
    Blob msg {};                      /* the serialized message. */
-    std::shared_ptr<Socket> socket;   /* the socket used for further reponses. */
+    uint32_t socket;   /* the socket used for further reponses. */
 };

 } /* namespace net  */
@@ -1,4 +1,24 @@
+/*
+ *  Copyright (C) 2014-2017 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
+ *  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 "routing_table.h"
+
+#include "network_engine.h"
 #include "rng.h"

 #include <memory>
@@ -35,6 +55,15 @@ Bucket::randomNode()
    return nodes.back();
 }

+void Bucket::sendCachedPing(net::NetworkEngine& ne)
+{
+    if (not cached)
+        return;
+    //DHT_LOG.d(b.cached->id, "[node %s] sending ping to cached node", cached->toString().c_str());
+    ne.sendPing(cached, nullptr, nullptr);
+    cached = {};
+}
+
 InfoHash
 RoutingTable::randomId(const RoutingTable::const_iterator& it) const
 {
@@ -172,4 +201,66 @@ RoutingTable::split(const RoutingTable::iterator& b)
    return true;
 }

+bool
+RoutingTable::onNewNode(const Sp<Node>& node, int confirm, const time_point& now, const InfoHash& myid, net::NetworkEngine& ne) {
+    auto b = findBucket(node->id);
+    if (b == end()) return false;
+
+    if (confirm == 2)
+        b->time = now;
+
+    for (auto& n : b->nodes) {
+        if (n == node)
+            return false;
+    }
+
+    bool mybucket = contains(b, myid);
+    if (mybucket) {
+        grow_time = now;
+        //scheduler.edit(nextNodesConfirmation, now);
+    }
+
+    if (b->nodes.size() >= TARGET_NODES) {
+        /* Try to get rid of an expired node. */
+        for (auto& n : b->nodes)
+            if (n->isExpired()) {
+                n = node;
+                return true;
+            }
+        /* Bucket full.  Ping a dubious node */
+        bool dubious = false;
+        for (auto& n : b->nodes) {
+            /* Pick the first dubious node that we haven't pinged in the
+               last 9 seconds.  This gives nodes the time to reply, but
+               tends to concentrate on the same nodes, so that we get rid
+               of bad nodes fast. */
+            if (not n->isGood(now)) {
+                dubious = true;
+                if (not n->isPendingMessage()) {
+                    //DHT_LOG.d(n->id, "[node %s] sending ping to dubious node", n->toString().c_str());
+                    ne.sendPing(n, nullptr, nullptr);
+                    break;
+                }
+            }
+        }
+
+        if ((mybucket || (is_client and depth(b) < 6)) && (!dubious || size() == 1)) {
+            //DHT_LOG.d("Splitting from depth %u", depth(b));
+            b->sendCachedPing(ne);
+            split(b);
+            return onNewNode(node, confirm, now, myid, ne);
+        }
+
+        /* No space for this node.  Cache it away for later. */
+        if (confirm or not b->cached)
+            b->cached = node;
+    } else {
+        /* Create a new node. */
+        b->nodes.emplace_front(node);
+    }
+    return true;
+}
+
+
+
 }
@@ -76,7 +76,19 @@ struct Dht::SearchNode {
                                                      node is a new candidate for inclusion. */

    SearchNode() : node() {}
+    SearchNode(const SearchNode&) = delete;
+    SearchNode(SearchNode&&) = default;
+    SearchNode& operator=(const SearchNode&) = delete;
+    SearchNode& operator=(SearchNode&&) = default;
+
    SearchNode(const Sp<Node>& node) : node(node) {}
+    ~SearchNode() {
+        if (node) {
+            cancelGet();
+            cancelListen();
+            cancelAnnounce();
+        }
+    }

    /**
     * Can we use this node to listen/announce now ?
@@ -173,6 +185,15 @@ struct Dht::SearchNode {
        }
    }

+    void cancelGet() {
+        for (const auto& status : getStatus) {
+            if (status.second->pending()) {
+                node->cancelRequest(status.second);
+            }
+        }
+        getStatus.clear();
+    }
+
    /**
     * Tells if a request in the status map is expired.
     *
@@ -180,12 +201,12 @@ struct Dht::SearchNode {
     *
     * @return true if there exists an expired request, else false.
     */
-    bool expired(const SyncStatus& status) const {
+    /*static bool expired(const SyncStatus& status) const {
        return std::find_if(status.begin(), status.end(),
            [](const SyncStatus::value_type& r){
                return r.second and r.second->expired();
            }) != status.end();
-    }
+    }*/

    /**
     * Tells if a request in the status map is pending.
@@ -194,19 +215,30 @@ struct Dht::SearchNode {
     *
     * @return true if there exists an expired request, else false.
     */
-    bool pending(const SyncStatus& status) const {
+    static bool pending(const SyncStatus& status) {
        return std::find_if(status.begin(), status.end(),
            [](const SyncStatus::value_type& r){
                return r.second and r.second->pending();
            }) != status.end();
    }

+    bool pendingGet() const { return pending(getStatus); }
+
    bool isAnnounced(Value::Id vid) const {
        auto ack = acked.find(vid);
        if (ack == acked.end() or not ack->second.first)
            return false;
        return ack->second.first->completed();
    }
+    void cancelAnnounce() {
+        for (const auto& status : acked) {
+            const auto& req = status.second.first;
+            if (req and req->pending()) {
+                node->cancelRequest(req);
+            }
+        }
+        acked.clear();
+    }

    bool isListening(time_point now) const {
        auto ls = listenStatus.begin();
@@ -229,6 +261,18 @@ struct Dht::SearchNode {
            return false;
        return listen_status->second->reply_time + LISTEN_EXPIRE_TIME > now;
    }
+    void cancelListen() {
+        for (const auto& status : listenStatus)
+            node->cancelRequest(status.second);
+        listenStatus.clear();
+    }
+    void cancelListen(const Sp<Query>& query) {
+        auto it = listenStatus.find(query);
+        if (it != listenStatus.end()) {
+            node->cancelRequest(it->second);
+            listenStatus.erase(it);
+        }
+    }

    /**
     * Assumng the node is synced, should a "put" request be sent to this node now ?
@@ -276,7 +320,7 @@ struct Dht::Search {
    uint16_t tid;
    time_point refill_time {time_point::min()};
    time_point step_time {time_point::min()};           /* the time of the last search step */
-    Sp<Scheduler::Job> nextSearchStep {};
+    Sp<Job> nextSearchStep {};

    bool expired {false};              /* no node, or all nodes expired */
    bool done {false};                 /* search is over, cached for later */
@@ -319,7 +363,7 @@ struct Dht::Search {
    unsigned currentlySolicitedNodeCount() const {
        unsigned count = 0;
        for (const auto& n : nodes)
-            if (not n.isBad() and n.pending(n.getStatus))
+            if (not n.isBad() and n.pendingGet())
                count++;
        return count;
    }
@@ -382,6 +426,21 @@ struct Dht::Search {
    bool isAnnounced(Value::Id id) const;
    bool isListening(time_point now) const;

+    void cancelListen(size_t token) {
+        Sp<Query> query;
+        const auto& ll = listeners.find(token);
+        if (ll != listeners.cend()) {
+            query = ll->second.query;
+            listeners.erase(ll);
+        }
+        for (auto& sn : nodes) {
+            if (listeners.empty())
+                sn.cancelListen();
+            else if (query)
+                sn.cancelListen(query);
+        }
+    }
+
    /**
     * @return The number of non-good search nodes.
     */
@@ -430,10 +489,10 @@ struct Dht::Search {
     *
     * @return true if a node has been removed, else false.
     */
-    bool removeExpiredNode(time_point now) {
+    bool removeExpiredNode(const time_point& now) {
        for (auto e = nodes.cend(); e != nodes.cbegin();) {
            const Node& n = *(--e)->node;
-            if (n.isExpired() and n.time + Node::NODE_EXPIRE_TIME < now) {
+            if (n.isRemovable(now)) {
                //std::cout << "Removing expired node " << n.id << " from IPv" << (af==AF_INET?'4':'6') << " search " << id << std::endl;
                nodes.erase(e);
                return true;
@@ -585,7 +644,7 @@ Dht::Search::insertNode(const Sp<Node>& snode, time_point now, const Blob& token
            step_time = time_point::min();
        }
        n = nodes.insert(n, SearchNode(snode));
-        node.time = now;
+        node.setTime(now);
        new_search_node = true;
        if (node.isExpired()) {
            if (not expired)
@@ -672,7 +731,7 @@ Dht::Search::getUpdateTime(time_point now) const
    for (const auto& sn : nodes) {
        if (sn.node->isExpired() or (sn.candidate and t >= TARGET_NODES))
            continue;
-        auto pending = sn.pending(sn.getStatus);
+        auto pending = sn.pendingGet();
        if (sn.last_get_reply < std::max(now - Node::NODE_EXPIRE_TIME, last_get) or pending) {
            // not isSynced
            if (not pending and solicited_nodes < MAX_REQUESTED_SEARCH_NODES)
@@ -40,10 +40,10 @@ Config& getConfig(SecureDht::Config& conf)
    return c;
 }

-SecureDht::SecureDht(int s, int s6, SecureDht::Config conf)
-: Dht(s, s6, getConfig(conf)), key_(conf.id.first), certificate_(conf.id.second)
+SecureDht::SecureDht(uv_loop_t* loop, SecureDht::Config conf)
+: Dht(loop, getConfig(conf)), key_(conf.id.first), certificate_(conf.id.second)
 {
-    if (s < 0 && s6 < 0)
+    if (not loop)
        return;

    for (const auto& type : DEFAULT_TYPES)
@@ -76,7 +76,7 @@ SecureDht::~SecureDht()
 ValueType
 SecureDht::secureType(ValueType&& type)
 {
-    type.storePolicy = [this,type](InfoHash id, Sp<Value>& v, InfoHash nid, const sockaddr* a, socklen_t al) {
+    type.storePolicy = [this,type](InfoHash id, Sp<Value>& v, const InfoHash& nid, const SockAddr& a) {
        if (v->isSigned()) {
            if (!v->owner or !v->owner->checkSignature(v->getToSign(), v->signature)) {
                DHT_LOG.WARN("Signature verification failed");
@@ -85,11 +85,11 @@ SecureDht::secureType(ValueType&& type)
            else
                DHT_LOG.WARN("Signature verification succeeded");
        }
-        return type.storePolicy(id, v, nid, a, al);
+        return type.storePolicy(id, v, nid, a);
    };
-    type.editPolicy = [this,type](InfoHash id, const Sp<Value>& o, Sp<Value>& n, InfoHash nid, const sockaddr* a, socklen_t al) {
+    type.editPolicy = [this,type](InfoHash id, const Sp<Value>& o, Sp<Value>& n, const InfoHash& nid, const SockAddr& a) {
        if (!o->isSigned())
-            return type.editPolicy(id, o, n, nid, a, al);
+            return type.editPolicy(id, o, n, nid, a);
        if (o->owner != n->owner) {
            DHT_LOG.WARN("Edition forbidden: owner changed.");
            return false;
@@ -19,12 +19,16 @@
 #include "utils.h"
 #include "sockaddr.h"
 #include "default_types.h"
+#include "net.h"
+#include "uv_utils.h"

 /* An IPv4 equivalent to IN6_IS_ADDR_UNSPECIFIED */
 #ifndef IN_IS_ADDR_UNSPECIFIED
 #define IN_IS_ADDR_UNSPECIFIED(a) (((long int) (a)->s_addr) == 0x00000000)
 #endif /* IN_IS_ADDR_UNSPECIFIED */

+static constexpr std::array<uint8_t, 12> MAPPED_IPV4_PREFIX {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}};
+
 namespace dht {

 std::string
@@ -38,7 +42,7 @@ print_addr(const sockaddr* sa, socklen_t slen)
            out << "[" << hbuf << "]";
        else
            out << hbuf;
-        if (strcmp(sbuf, "0"))
+        if (std::strcmp(sbuf, "0"))
            out << ":" << sbuf;
    } else
        out << "[invalid address]";
@@ -51,11 +55,6 @@ print_addr(const sockaddr_storage& ss, socklen_t sslen)
    return print_addr((const sockaddr*)&ss, sslen);
 }

-std::string
-printAddr(const SockAddr& addr) {
-    return print_addr((const sockaddr*)&addr.first, addr.second);
-}
-
 bool
 SockAddr::isUnspecified() const
 {
@@ -116,6 +115,57 @@ SockAddr::isPrivate() const
    }
 }

+bool
+SockAddr::isMappedIPv4() const
+{
+    if (getFamily() != AF_INET6)
+        return false;
+    const uint8_t* addr6 = reinterpret_cast<const uint8_t*>(&getIPv6().sin6_addr);
+    return std::equal(MAPPED_IPV4_PREFIX.begin(), MAPPED_IPV4_PREFIX.end(), addr6);
+}
+
+SockAddr
+SockAddr::getMappedIPv4() const
+{
+    if (getFamily() != AF_INET6)
+        return *this;
+    SockAddr ret;
+    ret.setFamily(AF_INET);
+    ret.setPort(getPort());
+    auto addr6 = reinterpret_cast<const uint8_t*>(&getIPv6().sin6_addr);
+    auto addr4 = reinterpret_cast<uint8_t*>(&ret.getIPv4().sin_addr);
+    addr6 += MAPPED_IPV4_PREFIX.size();
+    std::copy_n(addr6, sizeof(in_addr), addr4);
+    return ret;
+}
+
+void get_addr_info_cb(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
+    if (auto cb = static_cast<GetAddrInfoCb*>(req->data)) {
+        size_t count {0};
+        for (auto addr = res; addr; addr = addr->ai_next)
+            count++;
+        std::vector<SockAddr> ret;
+        ret.reserve(count);
+        for (auto addr = res; addr; addr = addr->ai_next)
+            ret.emplace_back(addr->ai_addr, addr->ai_addrlen);
+        (*cb)(std::move(ret));
+        delete cb;
+    }
+    delete req;
+    uv_freeaddrinfo(res);
+}
+
+void getAddrInfo(uv_loop_t* loop, const char* node, const char* service, GetAddrInfoCb&& cb)
+{
+    auto req = new uv_getaddrinfo_t;
+    req->data = new GetAddrInfoCb(std::move(cb));
+    addrinfo hints {};
+    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_DGRAM;
+    uv_getaddrinfo(loop, req, get_addr_info_cb, node, service, &hints);
+}
+
 bool operator==(const SockAddr& a, const SockAddr& b) {
    return a.equals(b);
 }
@@ -165,4 +215,18 @@ findMapValue(msgpack::object& map, const std::string& key) {
    return nullptr;
 }

+namespace net {
+
+TransId
+unpackTid(msgpack::object& o) {
+    switch (o.type) {
+    case msgpack::type::POSITIVE_INTEGER:
+        return o.as<uint32_t>();
+    default:
+        return o.as<std::array<char, 4>>();
+    }
+}
+
+}
+
 }
@@ -35,6 +35,7 @@ Value::Filter bindFilterRaw(FilterRaw raw_filter, void* user_data) {

 std::ostream& operator<< (std::ostream& s, const Value& v)
 {
+    auto flags(s.flags());
    s << "Value[id:" << std::hex << v.id << std::dec << " ";
    if (v.isEncrypted())
        s << "encrypted ";
@@ -63,13 +64,14 @@ std::ostream& operator<< (std::ostream& s, const Value& v)
        }
    }
    s << "]";
+    s.flags(flags);
    return s;
 }

 const ValueType ValueType::USER_DATA = {0, "User Data"};

 bool
-ValueType::DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t)
+ValueType::DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, const InfoHash&, const SockAddr&)
 {
    return v->size() <= MAX_VALUE_SIZE;
 }
@@ -257,9 +259,12 @@ std::ostream& operator<<(std::ostream& os, const FieldValueIndex& fvi) {
    os << "Index[";
    for (auto v = fvi.index.begin(); v != fvi.index.end(); ++v) {
        switch (v->first) {
-            case Value::Field::Id:
+            case Value::Field::Id: {
+                auto flags(os.flags());
                os << "Id:" << std::hex << v->second.getInt();
+                os.flags(flags);
                break;
+            }
            case Value::Field::ValueType:
                os << "ValueType:" << v->second.getInt();
                break;
@@ -39,7 +39,7 @@ void print_id_req() {
 }

 void print_node_info(const std::shared_ptr<DhtRunner>& dht, const dht_params& params) {
-    std::cout << "OpenDht node " << dht->getNodeId() << " running on port " <<  dht->getBoundPort() << std::endl;
+    std::cout << "OpenDht node " << dht->getNodeId() << " running on port " <<  dht->getBound().toString() << std::endl;
    if (params.generate_identity)
        std::cout << "Public key ID " << dht->getId() << std::endl;
 }
@@ -370,6 +370,9 @@ main(int argc, char **argv)
        }

        dht->run(params.port, crt, true, params.network);
+        dht->setOnStatusChanged([](dht::NodeStatus status4, dht::NodeStatus status6){
+            std::cout << "Node status changed : IPv4:" << (unsigned)status4 << " IPv6:" << (unsigned)status6 << std::endl;
+        });

        if (params.log) {
            if (params.syslog or (params.daemonize and params.logfile.empty()))
Author	SHA1	Message	Date
Adrien Béraud	5593107dc4	uv	2017-10-17 19:00:53 +02:00
Adrien Béraud	679ac3badb	tcp	2017-10-17 19:00:53 +02:00
Adrien Beraud	419fc24f1f	wip	2017-10-17 19:00:53 +02:00
Adrien Beraud	2acdc1f1aa	wip	2017-10-17 19:00:52 +02:00
Adrien Béraud	631c5f91ec	libsodium	2017-10-17 19:00:13 +02:00
Adrien Béraud	81213d9d50	tcp	2017-10-17 19:00:13 +02:00
Adrien Béraud	5c87e81c42	allow to retrieve nodes from ping callback	2017-10-17 18:58:07 +02:00
Adrien Beraud	aa0fbbce76	infohash: use 256 bits and SHA256	2017-10-17 18:58:07 +02:00
Adrien Beraud	ac06dbe45f	expired	2017-10-17 18:58:07 +02:00
Adrien Béraud	4a97265b22	use libuv for networking and event scheduling	2017-10-17 18:58:07 +02:00
Adrien Béraud	5a75b54e04	SockAddr: add constructor from simple sockaddr*	2017-10-17 18:57:41 +02:00
Adrien Beraud	64185d74d1	secure_vector: use mlock to prevent swapping to disc	2017-10-17 18:57:41 +02:00
Adrien Beraud	c16b73b056	crypto: use SecureBlob	2017-10-17 18:57:41 +02:00
Adrien Béraud	775eb2e599	update to version 1.4.0 * improved Doxygen documentation * cmake: add support to build documentation * cmake: improve build on macOS * API change: storage policies, getPublicAddress now use SockAddr * NodeExport: added msgpack serialization * fixed issue that could cause occasional request failures * minor bug fixes * minor performance improvements	2017-10-17 18:37:08 +02:00
Adrien Béraud	376486e64f	node: use full range of socket IDs	2017-10-17 15:25:09 +02:00
Adrien Béraud	63013bf374	SearchNode: prevent copy, check request access	2017-10-17 03:17:52 +02:00
Adrien Béraud	488aa771a9	Node: don't expire existing requests	2017-10-16 17:12:33 +02:00
Adrien Béraud	6bc2f19a36	dht: log total number of nodes in onGetValuesDone	2017-10-16 17:12:33 +02:00
Adrien Beraud	2dd94fbfe8	cmake: use CMAKE_THREAD_LIBS_INIT as library	2017-10-16 01:26:40 +02:00
Adrien Béraud	be2b9fd7dc	NodeCache: handle end() lower_bound for non-empty map	2017-10-15 15:57:14 +02:00
Adrien Béraud	9d4e6e0984	rate limiter: use deterministic maintenance Using deterministic maintenance sets an upper bound to the size of the address map.	2017-10-15 01:18:32 +02:00
Adrien Beraud	4856a6b424	PublicKey: getId compatible with HASH_LEN = 32	2017-10-13 15:43:56 +02:00
Adrien Béraud	7df375fc75	NodeCache: fix invalid pointer access	2017-10-13 15:40:09 +02:00
Adrien Béraud	63e0c1266a	dht: use OpStatus in put Factorize shared pointers.	2017-10-13 02:07:14 +02:00
Adrien Béraud	1a54aff7bc	storage policies: use SockAddr API-breaking change to use const SockAddr& instead of sockaddr*.	2017-10-13 01:10:09 +02:00
Adrien Béraud	f2b9f8eeda	dht: move bucket time update to routing table	2017-10-13 01:10:09 +02:00
Adrien Béraud	e9f007025f	node: make most fields private	2017-10-13 01:10:09 +02:00
Adrien Béraud	6ce1531e1f	node: make id const	2017-10-12 15:44:34 +02:00
Adrien Béraud	84a45c4f91	dht: factorize shared pointer dereference	2017-10-12 15:44:14 +02:00
Adrien Béraud	e20ae56cab	dht: support client mode In client mode, a node won't store data and won't participate in routing.	2017-10-12 15:44:14 +02:00
Adrien Béraud	4ce0168916	network engine: move ParsedMessage to separate file	2017-10-11 23:51:44 +02:00
Adrien Béraud	024dd42e5a	dht: remove processMessage	2017-10-11 17:36:20 +02:00
Adrien Béraud	98ec789526	nertwork engine: move tid management to Node	2017-10-11 17:36:20 +02:00
Adrien Béraud	3bb5e7ee12	network engine: move transaction ownership to Node	2017-10-11 17:36:20 +02:00
Adrien Béraud	8c529b7d7f	request: add getTid(), getSocket()	2017-10-11 13:47:53 +02:00
Adrien Béraud	be7494961c	network engine: move socket management to Node	2017-10-11 02:23:56 +02:00
Adrien Béraud	bdb0bef0ee	network engine: move RequestAnswer out of class	2017-10-11 02:22:03 +02:00
Adrien Béraud	73f26e120d	doc: improve documentation	2017-10-10 18:16:33 +02:00
Adrien Béraud	9f4b16e4f5	cmake: add doxygen documentation support Automatically build documentation if doxygen is found.	2017-10-10 17:45:34 +02:00
Adrien Béraud	323ad774e5	value: restore stream state after change	2017-10-09 15:14:20 +02:00
Adrien Béraud	d0bcd39341	IpServiceAnnouncement: use SockAddr	2017-10-09 15:06:34 +02:00
Adrien Béraud	42125367d7	SockAddr: add documentation	2017-10-09 14:46:35 +02:00
Adrien Béraud	d87a4ef28c	InfoHash: add operator==	2017-10-07 11:35:56 +02:00
Adrien Béraud	a3f4388556	InfoHash: increase toFloat precision	2017-10-07 11:35:56 +02:00
Adrien Béraud	97ee4b6fea	dht: move onNewNode to RoutingTable	2017-10-07 11:35:56 +02:00
Adrien Béraud	0abd288958	SockAddr: factorize setters	2017-10-05 14:09:56 +02:00
Adrien Béraud	131073e211	SockAddr: cleanup	2017-09-27 11:36:42 +02:00
Adrien Béraud	078c4f064a	cmake: use Threads package	2017-09-26 16:42:33 +02:00
Adrien Béraud	f17a4e66f5	cmake: add flag to enable address sanitizer and stack protector	2017-09-26 16:35:38 +02:00
Adrien Béraud	dd13ebb6d1	cmake: use private linking for private dependencies Users of the OpenDHT shared library don't need to link against GnuTLS or Nettle.	2017-09-26 16:34:18 +02:00
Adrien Béraud	1c45f34262	SockAddr: use pointer to sockaddr Save memory and reduce copies by using a pointer to a sockaddr structure of the right size instead of using a full sockaddr_storage structure for every address.	2017-09-26 16:30:29 +02:00