crypto: make Certificate::isCA() more restrictive

Merge pull request #170 from sim590/dht-random-id
dht: randomize id in Dht layer
2026-11-11 13:57:04 +00:00 · 2017-02-07 16:51:16 -05:00 · 2017-02-07 22:08:57 +01:00 · 2017-02-07 15:58:04 -05:00 · 2017-01-25 11:57:42 -05:00 · 2017-01-24 23:38:31 -05:00
56 changed files with 2803 additions and 991 deletions
@@ -1,17 +1,18 @@
 cmake_minimum_required (VERSION 2.8.6)
 project (opendht)
 set (opendht_VERSION_MAJOR 1)
-set (opendht_VERSION_MINOR 2.0)
+set (opendht_VERSION_MINOR 3.0)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")

 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")

+include(GNUInstallDirs)
 set (prefix ${CMAKE_INSTALL_PREFIX})
 set (exec_prefix "\${prefix}")
-set (libdir "\${exec_prefix}/lib")
-set (includedir "\${prefix}/include")
+set (libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+set (includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")

 option (OPENDHT_STATIC "Build static library" ON)
 option (OPENDHT_SHARED "Build shared library" ON)
@@ -26,7 +27,7 @@ if (OPENDHT_TOOLS)
    find_package (Readline 6 REQUIRED)
 endif ()

-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -std=c++11 -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor -pedantic-errors")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -std=c++11 -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor -pedantic-errors -fvisibility=hidden")
 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)
@@ -67,9 +68,11 @@ list (APPEND opendht_SOURCES
    src/argon2/encoding.c
    src/argon2/ref.c
    src/indexation/pht.cpp
+    src/log.cpp
 )

 list (APPEND opendht_HEADERS
+    include/opendht/def.h
    include/opendht/utils.h
    include/opendht/sockaddr.h
    include/opendht/rng.h
@@ -83,6 +86,7 @@ list (APPEND opendht_HEADERS
    include/opendht/routing_table.h
    include/opendht/node_cache.h
    include/opendht/network_engine.h
+    include/opendht/net.h
    include/opendht/scheduler.h
    include/opendht/rate_limiter.h
    include/opendht/securedht.h
@@ -119,7 +123,7 @@ if (OPENDHT_STATIC)
        target_link_libraries(opendht-static -flto -fuse-linker-plugin)
    endif ()
    target_link_libraries(opendht-static gnutls nettle)
-    install (TARGETS opendht-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install (TARGETS opendht-static DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht)
 endif ()

 if (OPENDHT_SHARED)
@@ -129,11 +133,12 @@ if (OPENDHT_SHARED)
    )
    set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
    set_target_properties (opendht PROPERTIES SOVERSION ${opendht_VERSION_MAJOR} VERSION ${opendht_VERSION})
+    target_compile_definitions(opendht PRIVATE OPENDHT_BUILD)
    if (OPENDHT_LTO)
        target_link_libraries(opendht -flto -fuse-linker-plugin)
    endif ()
    target_link_libraries(opendht gnutls nettle)
-    install (TARGETS opendht DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install (TARGETS opendht DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht)
 endif ()

 if (OPENDHT_TOOLS)
@@ -145,5 +150,12 @@ if (OPENDHT_PYTHON)
    add_subdirectory(python)
 endif ()

+include(CMakePackageConfigHelpers)
+write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/opendhtConfigVersion.cmake"
+  VERSION ${opendht_VERSION}
+  COMPATIBILITY AnyNewerVersion
+)
 install (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
 install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendht.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+install (EXPORT opendht DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/opendht FILE opendhtConfig.cmake)
+install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendhtConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/opendht)
@@ -0,0 +1,221 @@
+--- /dev/null
+++ b/msgpack_vc8.vcxproj
+@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectName>MessagePack</ProjectName>
+    <ProjectGuid>{122A2EA4-B283-4241-9655-786DE78283B2}</ProjectGuid>
+    <RootNamespace>MessagePack</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>14.0.25123.0</_ProjectFileVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <OutDir>$(ProjectDir)..\</OutDir>
+    <IntDir>$(Configuration)\</IntDir>
+    <TargetName>msgpackd</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetName>msgpackd</TargetName>
+    <OutDir>$(ProjectDir)..\</OutDir>
+    <IntDir>$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <OutDir>$(ProjectDir)..\</OutDir>
+    <IntDir>$(Configuration)\</IntDir>
+    <TargetName>msgpack</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>msgpack</TargetName>
+    <OutDir>$(ProjectDir)..\</OutDir>
+    <IntDir>$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>.;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32_NATIVE;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>StackFrameRuntimeCheck</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader />
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x86\$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+
+mkdir $(OutDir)\include\msgpack
+
+copy include\*.h $(OutDir)\include\
+
+copy include\*.hpp $(OutDir)\include\
+xcopy /S /Y include\msgpack\*.h $(OutDir)\include\msgpack
+xcopy /S /Y include\msgpack\*.hpp $(OutDir)\include\msgpack
+</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>.;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32_NATIVE;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BasicRuntimeChecks>StackFrameRuntimeCheck</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x64\$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+
+mkdir $(OutDir)\include\msgpack
+
+copy include\*.h $(OutDir)\include\
+
+copy include\*.hpp $(OutDir)\include\
+xcopy /S /Y include\msgpack\*.h $(OutDir)\include\msgpack
+xcopy /S /Y include\msgpack\*.hpp $(OutDir)\include\msgpack
+</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>.;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32_NATIVE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader />
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <ProgramDataBaseFileName>$(OutDir)\lib\x86\$(TargetName).pdb</ProgramDataBaseFileName>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x86\$(TargetName)$(TargetExt)</OutputFile>
+      <LinkTimeCodeGeneration />
+    </Lib>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+
+mkdir $(OutDir)\include\msgpack
+
+copy include\*.h $(OutDir)\include\
+
+copy include\*.hpp $(OutDir)\include\
+xcopy /S /Y include\msgpack\*.h $(OutDir)\include\msgpack
+xcopy /S /Y include\msgpack\*.hpp $(OutDir)\include\msgpack
+</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>.;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>MSGPACK_USE_CPP03;WIN32_NATIVE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <ProgramDataBaseFileName>$(OutDir)\lib\x64\$(TargetName).pdb</ProgramDataBaseFileName>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x64\$(TargetName)$(TargetExt)</OutputFile>
+      <LinkTimeCodeGeneration />
+    </Lib>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+
+mkdir $(OutDir)\include\msgpack
+
+copy include\*.h $(OutDir)\include\
+
+copy include\*.hpp $(OutDir)\include\
+xcopy /S /Y include\msgpack\*.h $(OutDir)\include\msgpack
+xcopy /S /Y include\msgpack\*.hpp $(OutDir)\include\msgpack
+</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src\objectc.c" />
+    <ClCompile Include="src\unpack.c" />
+    <ClCompile Include="src\version.c" />
+    <ClCompile Include="src\vrefbuffer.c" />
+    <ClCompile Include="src\zone.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="include\msgpack.hpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
+\ No newline at end of file
+-- 
+2.8.1.windows.1
+
@@ -13,9 +13,9 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opendht", "opendht.vcxproj"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "dependencies", "dependencies", "{71A1A9EC-1104-4335-A87E-AF8749FD5B34}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgmp", "..\..\gmp\MSVC\libgmp.vcxproj", "{02B94302-23D6-43EF-8865-95CDE99D5DC2}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgmp", "..\..\gmp\SMP\libgmp.vcxproj", "{02B94302-23D6-43EF-8865-95CDE99D5DC2}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgnutls", "..\..\gnutls\MSVC\libgnutls.vcxproj", "{6F610EE8-7F59-4191-AB88-F63843267C02}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgnutls", "..\..\gnutls\SMP\libgnutls.vcxproj", "{6F610EE8-7F59-4191-AB88-F63843267C02}"
 	ProjectSection(ProjectDependencies) = postProject
 		{02B94302-23D6-43EF-8865-95CDE99D5DC2} = {02B94302-23D6-43EF-8865-95CDE99D5DC2}
 		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518} = {070FEF2B-0C3F-4F33-9D3C-53C7330BF518}
@@ -24,16 +24,16 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgnutls", "..\..\gnutls\M
 		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B} = {CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libiconv", "..\..\libiconv\MSVC\libiconv.vcxproj", "{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libiconv", "..\..\libiconv\SMP\libiconv.vcxproj", "{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libhogweed", "..\..\nettle\MSVC\libhogweed.vcxproj", "{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libhogweed", "..\..\nettle\SMP\libhogweed.vcxproj", "{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}"
 	ProjectSection(ProjectDependencies) = postProject
 		{02B94302-23D6-43EF-8865-95CDE99D5DC2} = {02B94302-23D6-43EF-8865-95CDE99D5DC2}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libnettle", "..\..\nettle\MSVC\libnettle.vcxproj", "{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libnettle", "..\..\nettle\SMP\libnettle.vcxproj", "{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libzlib", "..\..\zlib\MSVC\libzlib.vcxproj", "{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libzlib", "..\..\zlib\SMP\libzlib.vcxproj", "{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MessagePack", "..\..\msgpack-c\msgpack_vc8.vcxproj", "{122A2EA4-B283-4241-9655-786DE78283B2}"
 EndProject
@@ -1,12 +1,11 @@
@ECHO OFF
 SETLOCAL EnableDelayedExpansion

-SET UPSTREAMURL=https://github.com/atraczyk
+SET UPSTREAMURL=https://github.com/ShiftMediaProject
 SET DEPENDENCIES=( ^
 gmp, ^
 gnutls, ^
-nettle, ^
-msgpack-c ^
+nettle ^
 )

 SET PASSDEPENDENCIES=%~1
@@ -24,6 +23,15 @@ IF %ERRORLEVEL% EQU 128 (
 SET CURRDIR=%~dp1

 cd ..\..
+set MSGPACK_VERSION=1df97bc37b363a340c5ad06c5cbcc53310aaff80
+set MSGPACK_URL="https://github.com/msgpack/msgpack-c.git"
+ECHO Cloning msgpack-c...
+git clone %MSGPACK_URL% --quiet
+cd msgpack-c
+git checkout %MSGPACK_VERSION%
+git apply --reject --whitespace=fix ..\opendht\MSVC\msgpack-msvc.patch
+cd ..
+
 FOR %%I IN %DEPENDENCIES% DO (
    ECHO !PASSDEPENDENCIES! | FINDSTR /C:"%%I" >NUL 2>&1 || (
        CALL :cloneOrUpdateRepo "%%I" )
@@ -46,10 +54,10 @@ IF NOT EXIST "%REPONAME%" (

 SET PASSDEPENDENCIES=%PASSDEPENDENCIES% %REPONAME%

-IF EXIST "%REPONAME%\MSVC\project_get_dependencies.bat" (
+IF EXIST "%REPONAME%\SMP\project_get_dependencies.bat" (
    ECHO %REPONAME%: Found additional dependencies...
    ECHO.
-    cd %REPONAME%\MSVC
+    cd %REPONAME%\SMP
    project_get_dependencies.bat "!PASSDEPENDENCIES!" || GOTO exitOnError
    cd ..\..
 )
@@ -99,7 +99,7 @@ for r in results:
 IRC: join us on Freenode at [`#opendht`](https://webchat.freenode.net/?channels=%23opendht).

 ## Licence
-Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+Copyright (C) 2014-2017 Savoir-faire Linux Inc.

 OpenDHT is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

@@ -1,6 +1,6 @@
 dnl define macros
 m4_define([opendht_major_version], 1)
-m4_define([opendht_minor_version], 2)
+m4_define([opendht_minor_version], 3)
 m4_define([opendht_patch_version], 0)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])
@@ -45,8 +45,8 @@ AC_ARG_ENABLE([python], [AS_HELP_STRING([--disable-python], [Disble python bindi
 AS_IF([test "x$enable_python" != "xno"], [
       AM_PATH_PYTHON([3.3],, [:])
       AS_IF([test -n "$PYTHON"],[
-              AC_CHECK_PROGS([CYTHON], [cython3])
-              AS_IF([test -z "$CYTHON"],[AC_MSG_WARN([Cython not found - continuing without python support])])
+              echo 'import Cython' | $PYTHON
+              AS_IF([test $? == 0],[CYTHON=yes],[AC_MSG_WARN([Cython not found - continuing without python support])])
              AC_CHECK_PROGS([PIP], [pip3])
              AS_IF([test -z "$PIP"],[AC_MSG_WARN([pip not found - continuing without python uninstall support])])
              ])
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -1,6 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *           Simon Désaulniers <simon.desaulniers@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
@@ -39,14 +40,24 @@ enum class NodeStatus {
    Connected     // 1+ good nodes
 };

+struct OPENDHT_PUBLIC NodeStats {
+    unsigned good_nodes,
+             dubious_nodes,
+             cached_nodes,
+             incoming_nodes;
+    unsigned table_depth;
+    unsigned getKnownNodes() const { return good_nodes + dubious_nodes; }
+    std::string toString() const;
+};
+
 /**
 * Dht configuration.
 */
-struct Config {
+struct OPENDHT_PUBLIC Config {
    /** DHT node ID */
    InfoHash node_id;

-    /** 
+    /**
     * DHT network ID. A node will only talk with other nodes having
     * the same network ID.
     * Network ID 0 (default) represents the main public network.
@@ -55,12 +66,15 @@ struct Config {

    /** For testing purposes only, enables bootstrap mode */
    bool is_bootstrap;
+
+    /** Makes the DHT responsible to maintain its stored values. Consumes more ressources. */
+    bool maintain_storage;
 };

 /**
 * SecureDht configuration.
 */
-struct SecureDhtConfig
+struct OPENDHT_PUBLIC SecureDhtConfig
 {
    Config node_config;
    crypto::Identity id;
@@ -79,8 +93,8 @@ using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::

 typedef bool (*GetCallbackRaw)(std::shared_ptr<Value>, void *user_data);

-GetCallbackSimple bindGetCb(GetCallbackRaw raw_cb, void* user_data);
-GetCallback bindGetCb(GetCallbackSimple cb);
+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)>;
 typedef void (*DoneCallbackRaw)(bool, std::vector<std::shared_ptr<Node>>*, void *user_data);
@@ -89,9 +103,9 @@ typedef void (*DoneCallbackSimpleRaw)(bool, void *user_data);

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

-ShutdownCallback bindShutdownCb(ShutdownCallbackRaw shutdown_cb_raw, void* user_data);
-DoneCallback bindDoneCb(DoneCallbackSimple donecb);
-DoneCallback bindDoneCb(DoneCallbackRaw raw_cb, void* user_data);
-DoneCallbackSimple bindDoneCbSimple(DoneCallbackSimpleRaw raw_cb, void* user_data);
+OPENDHT_PUBLIC ShutdownCallback bindShutdownCb(ShutdownCallbackRaw shutdown_cb_raw, void* user_data);
+OPENDHT_PUBLIC DoneCallback bindDoneCb(DoneCallbackSimple donecb);
+OPENDHT_PUBLIC DoneCallback bindDoneCb(DoneCallbackRaw raw_cb, void* user_data);
+OPENDHT_PUBLIC DoneCallbackSimple bindDoneCbSimple(DoneCallbackSimpleRaw raw_cb, void* user_data);

 }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -38,7 +38,7 @@ extern "C" {
 namespace dht {
 namespace crypto {

-class CryptoException : public std::runtime_error {
+class OPENDHT_PUBLIC CryptoException : public std::runtime_error {
    public:
        CryptoException(const std::string& str) : std::runtime_error(str) {};
 };
@@ -46,20 +46,21 @@ class CryptoException : public std::runtime_error {
 /**
 * Exception thrown when a decryption error happened.
 */
-class DecryptError : public CryptoException {
+class OPENDHT_PUBLIC DecryptError : public CryptoException {
    public:
        DecryptError(const std::string& str = "") : CryptoException(str) {};
 };

 struct PrivateKey;
 struct Certificate;
+class RevocationList;

 using Identity = std::pair<std::shared_ptr<PrivateKey>, std::shared_ptr<Certificate>>;

 /**
 * A public key.
 */
-struct PublicKey
+struct OPENDHT_PUBLIC PublicKey
 {
    PublicKey() {}

@@ -82,6 +83,7 @@ struct PublicKey
    PublicKey& operator=(PublicKey&& o) noexcept;

    InfoHash getId() const;
+    PkId getLongId() const;
    bool checkSignature(const Blob& data, const Blob& signature) const;
    Blob encrypt(const Blob&) const;

@@ -109,7 +111,7 @@ private:
 /**
 * A private key, including the corresponding public key.
 */
-struct PrivateKey
+struct OPENDHT_PUBLIC PrivateKey
 {
    PrivateKey();
    //PrivateKey(gnutls_privkey_t k) : key(k) {}
@@ -148,6 +150,7 @@ struct PrivateKey
     *      Recommended values: 4096, 8192
     */
    static PrivateKey generate(unsigned key_length = 4096);
+    static PrivateKey generateEC();

    gnutls_privkey_t key {};
    gnutls_x509_privkey_t x509_key {};
@@ -159,7 +162,77 @@ private:
    //friend dht::crypto::Identity dht::crypto::generateIdentity(const std::string&, dht::crypto::Identity, unsigned key_length);
 };

-struct Certificate {
+
+class OPENDHT_PUBLIC RevocationList
+{
+    using clock = std::chrono::system_clock;
+    using time_point = clock::time_point;
+    using duration = clock::duration;
+public:
+    RevocationList();
+    RevocationList(const Blob& b);
+    RevocationList(RevocationList&& o) : crl(o.crl) { o.crl = nullptr; }
+    ~RevocationList();
+
+    RevocationList& operator=(RevocationList&& o) { crl = o.crl; o.crl = nullptr; return *this; }
+
+    void pack(Blob& b) const;
+    void unpack(const uint8_t* dat, size_t dat_size);
+    Blob getPacked() const {
+        Blob b;
+        pack(b);
+        return b;
+    }
+
+    template <typename Packer>
+    void msgpack_pack(Packer& p) const
+    {
+        Blob b = getPacked();
+        p.pack_bin(b.size());
+        p.pack_bin_body((const char*)b.data(), b.size());
+    }
+
+    void msgpack_unpack(msgpack::object o);
+
+    void revoke(const Certificate& crt, time_point t = time_point::min());
+
+    bool isRevoked(const Certificate& crt) const;
+
+    /**
+     * Sign this revocation list using provided key and certificate.
+     * Validity_period sets the duration until next update (default to no next update).
+     */
+    void sign(const PrivateKey&, const Certificate&, duration validity_period = {});
+    void sign(const Identity& id) { sign(*id.first, *id.second); }
+
+    bool isSignedBy(const Certificate& issuer) const;
+
+    std::string toString() const;
+
+    /**
+     * Read the CRL number extension field.
+     */
+    Blob getNumber() const;
+
+    /** Read CRL issuer Common Name (CN) */
+    std::string getIssuerName() const;
+
+    /** Read CRL issuer User ID (UID) */
+    std::string getIssuerUID() const;
+
+    time_point getUpdateTime() const;
+    time_point getNextUpdateTime() const;
+
+    gnutls_x509_crl_t get() { return crl; }
+
+private:
+    gnutls_x509_crl_t crl {};
+    RevocationList(const RevocationList&) = delete;
+    RevocationList& operator=(const RevocationList&) = delete;
+};
+
+
+struct OPENDHT_PUBLIC Certificate {
    Certificate() {}

    /**
@@ -278,6 +351,7 @@ struct Certificate {

    /** Same as getPublicKey().getId() */
    InfoHash getId() const;
+    PkId getLongId() const;

    /** Read certificate Common Name (CN) */
    std::string getName() const;
@@ -296,8 +370,11 @@ struct Certificate {
    /** Read certificate alternative names */
    std::vector<std::pair<NameType, std::string>> getAltNames() const;

+    std::chrono::system_clock::time_point getExpiration() const;
+
    /**
-     * Returns true if the certificate is marked as a Certificate Authority.
+     * Returns true if the certificate is marked as a Certificate Authority
+     * and has necessary key usage flags to sign certificates.
     */
    bool isCA() const;

@@ -307,6 +384,13 @@ struct Certificate {
     */
    std::string toString(bool chain = true) const;

+    std::string print() const;
+
+    void revoke(const PrivateKey&, const Certificate&);
+    std::vector<std::shared_ptr<RevocationList>> getRevocationLists() const;
+    void addRevocationList(RevocationList&&);
+    void addRevocationList(std::shared_ptr<RevocationList>);
+
    static Certificate generate(const PrivateKey& key, const std::string& name = "dhtnode", Identity ca = {}, bool is_ca = false);

    gnutls_x509_crt_t cert {};
@@ -314,6 +398,14 @@ struct Certificate {
 private:
    Certificate(const Certificate&) = delete;
    Certificate& operator=(const Certificate&) = delete;
+
+    struct crlNumberCmp {
+        bool operator() (const std::shared_ptr<RevocationList>& lhs, const std::shared_ptr<RevocationList>& rhs) const {
+            return lhs->getNumber() < rhs->getNumber();
+        }
+    };
+
+    std::set<std::shared_ptr<RevocationList>, crlNumberCmp> revocation_lists;
 };


@@ -324,8 +416,8 @@ private:
 *           If not set, the generated certificate will be a self-signed CA.
 * @param key_length stength of the generated private key (bits).
 */
-Identity generateIdentity(const std::string& name, Identity ca, unsigned key_length, bool is_ca);
-Identity generateIdentity(const std::string& name = "dhtnode", Identity ca = {}, unsigned key_length = 4096);
+OPENDHT_PUBLIC Identity generateIdentity(const std::string& name, Identity ca, unsigned key_length, bool is_ca);
+OPENDHT_PUBLIC Identity generateIdentity(const std::string& name = "dhtnode", Identity ca = {}, unsigned key_length = 4096);


 /**
@@ -336,7 +428,7 @@ Identity generateIdentity(const std::string& name = "dhtnode", Identity ca = {},
 * will use SHA256 for hash_length up to 32 bytes,
 * will use SHA512 for hash_length of 33 bytes and more.
 */
-Blob hash(const Blob& data, size_t hash_length = 512/8);
+OPENDHT_PUBLIC Blob hash(const Blob& data, size_t hash_length = 512/8);

 /**
 * Generates an encryption key from a text password,
@@ -345,19 +437,19 @@ 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).
 */
-Blob stretchKey(const std::string& password, Blob& salt, size_t key_length = 512/8);
+OPENDHT_PUBLIC Blob stretchKey(const std::string& password, Blob& salt, size_t key_length = 512/8);

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

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

 }
 }
@@ -0,0 +1,28 @@
+#pragma once
+
+// Generic helper definitions for shared library support
+#if defined _WIN32 || defined __CYGWIN__
+  #define OPENDTH_IMPORT __declspec(dllimport)
+  #define OPENDHT_EXPORT __declspec(dllexport)
+  #define OPENDHT_HIDDEN
+#else
+  #define OPENDTH_IMPORT __attribute__ ((visibility ("default")))
+  #define OPENDHT_EXPORT __attribute__ ((visibility ("default")))
+  #define OPENDHT_HIDDEN __attribute__ ((visibility ("hidden")))
+#endif
+
+// Now we use the generic helper definitions above to define OPENDHT_PUBLIC and OPENDHT_LOCAL.
+// OPENDHT_PUBLIC is used for the public API symbols. It either DLL imports or DLL exports (or does nothing for static build)
+// OPENDHT_LOCAL is used for non-api symbols.
+
+#ifdef opendht_EXPORTS // defined if OpenDHT is compiled as a shared library
+  #ifdef OPENDHT_BUILD // defined if we are building the OpenDHT shared library (instead of using it)
+    #define OPENDHT_PUBLIC OPENDHT_EXPORT
+  #else
+    #define OPENDHT_PUBLIC OPENDTH_IMPORT
+  #endif // OPENDHT_BUILD
+  #define OPENDHT_LOCAL OPENDHT_HIDDEN
+#else // opendht_EXPORTS is not defined: this means OpenDHT is a static lib.
+  #define OPENDHT_PUBLIC
+  #define OPENDHT_LOCAL
+#endif // opendht_EXPORTS
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -35,7 +35,7 @@ MSGPACK_ADD_ENUM(dht::ImStatus)

 namespace dht {

-class DhtMessage : public Value::Serializable<DhtMessage>
+class OPENDHT_PUBLIC DhtMessage : public Value::Serializable<DhtMessage>
 {
 public:
    static const ValueType TYPE;
@@ -61,7 +61,7 @@ public:
 };

 template <typename T>
-class SignedValue : public Value::Serializable<T>
+class OPENDHT_PUBLIC SignedValue : public Value::Serializable<T>
 {
 private:
    using BaseClass = Value::Serializable<T>;
@@ -81,7 +81,7 @@ public:
 };

 template <typename T>
-class EncryptedValue : public SignedValue<T>
+class OPENDHT_PUBLIC EncryptedValue : public SignedValue<T>
 {
 public:
    using BaseClass = SignedValue<T>;
@@ -105,7 +105,7 @@ public:



-class ImMessage : public SignedValue<ImMessage>
+class OPENDHT_PUBLIC ImMessage : public SignedValue<ImMessage>
 {
 private:
    using BaseClass = SignedValue<ImMessage>;
@@ -131,7 +131,7 @@ public:
    MSGPACK_DEFINE_MAP(id, msg, date, status)
 };

-class TrustRequest : public EncryptedValue<TrustRequest>
+class OPENDHT_PUBLIC TrustRequest : public EncryptedValue<TrustRequest>
 {
 private:
    using BaseClass = EncryptedValue<TrustRequest>;
@@ -149,10 +149,11 @@ public:

    std::string service;
    Blob payload;
-    MSGPACK_DEFINE(service, payload)
+    bool confirm {false};
+    MSGPACK_DEFINE_MAP(service, payload, confirm)
 };

-class IceCandidates : public EncryptedValue<IceCandidates>
+class OPENDHT_PUBLIC IceCandidates : public EncryptedValue<IceCandidates>
 {
 private:
    using BaseClass = EncryptedValue<IceCandidates>;
@@ -198,7 +199,7 @@ public:

 /* "Peer" announcement
 */
-class IpServiceAnnouncement : public Value::Serializable<IpServiceAnnouncement>
+class OPENDHT_PUBLIC IpServiceAnnouncement : public Value::Serializable<IpServiceAnnouncement>
 {
 private:
    using BaseClass = Value::Serializable<IpServiceAnnouncement>;
@@ -273,8 +274,8 @@ private:
 };


-extern const std::array<std::reference_wrapper<const ValueType>, 5> DEFAULT_TYPES;
+OPENDHT_PUBLIC extern const std::array<std::reference_wrapper<const ValueType>, 5> DEFAULT_TYPES;

-extern const std::array<std::reference_wrapper<const ValueType>, 1> DEFAULT_INSECURE_TYPES;
+OPENDHT_PUBLIC extern const std::array<std::reference_wrapper<const ValueType>, 1> DEFAULT_INSECURE_TYPES;

 }
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -41,7 +41,9 @@

 namespace dht {

+namespace net {
 struct Request;
+} /* namespace net */

 /**
 * Main Dht class.
@@ -50,7 +52,7 @@ struct Request;
 * Must be given open UDP sockets and ::periodic must be
 * called regularly.
 */
-class Dht {
+class OPENDHT_PUBLIC Dht {
 public:

    // [[deprecated]]
@@ -173,12 +175,12 @@ public:
    /**
     * Get locally stored data for the given hash.
     */
-    std::vector<std::shared_ptr<Value>> getLocal(const InfoHash& key, Value::Filter f = Value::AllFilter()) const;
+    std::vector<Sp<Value>> getLocal(const InfoHash& key, Value::Filter f = Value::AllFilter()) const;

    /**
     * Get locally stored data for the given key and value id.
     */
-    std::shared_ptr<Value> getLocalById(const InfoHash& key, Value::Id vid) const;
+    Sp<Value> getLocalById(const InfoHash& key, Value::Id vid) const;

    /**
     * Announce a value on all available protocols (IPv4, IPv6).
@@ -187,12 +189,12 @@ public:
     * The done callback will be called once, when the first announce succeeds, or fails.
     */
    void put(const InfoHash& key,
-            std::shared_ptr<Value>,
+            Sp<Value>,
            DoneCallback cb=nullptr,
            time_point created=time_point::max(),
            bool permanent = false);
    void put(const InfoHash& key,
-            const std::shared_ptr<Value>& v,
+            const Sp<Value>& v,
            DoneCallbackSimple cb,
            time_point created=time_point::max(),
            bool permanent = false)
@@ -220,12 +222,12 @@ public:
    /**
     * Get data currently being put at the given hash.
     */
-    std::vector<std::shared_ptr<Value>> getPut(const InfoHash&);
+    std::vector<Sp<Value>> getPut(const InfoHash&);

    /**
     * Get data currently being put at the given hash with the given id.
     */
-    std::shared_ptr<Value> getPut(const InfoHash&, const Value::Id&);
+    Sp<Value> getPut(const InfoHash&, const Value::Id&);

    /**
     * Stop any put/announce operation at the given location,
@@ -268,8 +270,8 @@ public:
    std::vector<ValuesExport> exportValues() const;
    void importValues(const std::vector<ValuesExport>&);

-    unsigned getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return,
-            unsigned *incoming_return) const;
+    NodeStats getNodesStats(sa_family_t af) const;
+
    std::string getStorageLog() const;
    std::string getStorageLog(const InfoHash&) const;

@@ -344,9 +346,9 @@ private:
    /* Timeout for listen */
    static constexpr std::chrono::seconds LISTEN_EXPIRE_TIME {30};

-    static constexpr std::chrono::seconds REANNOUNCE_MARGIN {5};
+    static constexpr std::chrono::seconds REANNOUNCE_MARGIN {10};

-    static constexpr size_t TOKEN_SIZE {64};
+    static constexpr size_t TOKEN_SIZE {32};

    // internal structures
    struct SearchNode;
@@ -355,6 +357,7 @@ private:
    struct LocalListener;
    struct Search;
    struct ValueStorage;
+    class StorageBucket;
    struct Listener;
    struct Storage;

@@ -375,17 +378,19 @@ private:
    //       Only nodes running only as bootstrap nodes should
    //       be put in bootstrap mode.
    const bool is_bootstrap {false};
+    const bool maintain_storage {false};

    // the stuff
    RoutingTable buckets4 {};
    RoutingTable buckets6 {};

    std::map<InfoHash, Storage> store;
+    std::map<SockAddr, StorageBucket, SockAddr::ipCmp> store_quota;
    size_t total_values {0};
    size_t total_store_size {0};
    size_t max_store_size {DEFAULT_STORAGE_LIMIT};

-    using SearchMap = std::map<InfoHash, std::shared_ptr<Search>>;
+    using SearchMap = std::map<InfoHash, Sp<Search>>;
    SearchMap searches4 {};
    SearchMap searches6 {};
    uint16_t search_id {0};
@@ -397,11 +402,11 @@ private:

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

-    NetworkEngine network_engine;
+    net::NetworkEngine network_engine;
    unsigned pending_pings4 {0};
    unsigned pending_pings6 {0};

@@ -416,11 +421,15 @@ private:
    void reportedAddr(const SockAddr&);

    // Storage
-    void storageAddListener(const InfoHash& id, const std::shared_ptr<Node>& node, size_t tid, Query&& = {});
-    bool storageStore(const InfoHash& id, const std::shared_ptr<Value>& value, time_point created);
-    void expireStorage();
+    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);
+    void expireStore();
+    void expireStorage(InfoHash h);
+    void expireStore(decltype(store)::iterator);
+
    void storageChanged(const InfoHash& id, Storage& st, ValueStorage&);
    std::string printStorageLog(const decltype(store)::value_type&) const;
+    void printStorageQuota(std::ostream& out, const decltype(store_quota)::value_type& ip) const;

    /**
     * For a given storage, if values don't belong there anymore because this
@@ -456,10 +465,10 @@ private:
    void dumpBucket(const Bucket& b, std::ostream& out) const;

    // Nodes
-    void onNewNode(const std::shared_ptr<Node>& node, int confirm);
-    std::shared_ptr<Node> findNode(const InfoHash& id, sa_family_t af);
-    const std::shared_ptr<Node> findNode(const InfoHash& id, sa_family_t af) const;
-    bool trySearchInsert(const std::shared_ptr<Node>& node);
+    void onNewNode(const Sp<Node>& node, int confirm);
+    Sp<Node> findNode(const InfoHash& id, sa_family_t af);
+    const Sp<Node> findNode(const InfoHash& id, sa_family_t af) const;
+    bool trySearchInsert(const Sp<Node>& node);

    // Searches

@@ -470,10 +479,10 @@ private:
     * Low-level method that will perform a search on the DHT for the specified
     * infohash (id), using the specified IP version (IPv4 or IPv6).
     */
-    std::shared_ptr<Search> search(const InfoHash& id, sa_family_t af, GetCallback = {}, QueryCallback = {}, DoneCallback = {}, Value::Filter = {}, Query q = {});
+    Sp<Search> search(const InfoHash& id, sa_family_t af, GetCallback = {}, QueryCallback = {}, DoneCallback = {}, Value::Filter = {}, Query q = {});

-    void announce(const InfoHash& id, sa_family_t af, std::shared_ptr<Value> value, DoneCallback callback, time_point created=time_point::max(), bool permanent = false);
-    size_t listenTo(const InfoHash& id, sa_family_t af, GetCallback cb, Value::Filter f = Value::AllFilter(), const std::shared_ptr<Query>& q = {});
+    void announce(const InfoHash& id, sa_family_t af, Sp<Value> value, DoneCallback callback, time_point created=time_point::max(), bool permanent = false);
+    size_t listenTo(const InfoHash& id, sa_family_t af, GetCallback cb, Value::Filter f = Value::AllFilter(), const Sp<Query>& q = {});

    /**
     * Refill the search with good nodes if possible.
@@ -483,8 +492,6 @@ private:
     * @return the number inserted nodes.
     */
    unsigned refill(Search& sr);
-
-    Search *findSearch(unsigned short tid, sa_family_t af);
    void expireSearches();

    void confirmNodes();
@@ -498,10 +505,10 @@ private:
     * @param ws      A weak pointer to the search concerned by the request.
     * @param query   The query sent to the node.
     */
-    void searchNodeGetDone(const Request& status,
-            NetworkEngine::RequestAnswer&& answer,
+    void searchNodeGetDone(const net::Request& status,
+            net::NetworkEngine::RequestAnswer&& answer,
            std::weak_ptr<Search> ws,
-            std::shared_ptr<Query> query);
+            Sp<Query> query);

    /**
     * Generic function to execute when a 'get' request expires.
@@ -512,7 +519,7 @@ private:
     * @param ws      A weak pointer to the search concerned by the request.
     * @param query   The query sent to the node.
     */
-    void searchNodeGetExpired(const Request& status, bool over, std::weak_ptr<Search> ws, std::shared_ptr<Query> query);
+    void searchNodeGetExpired(const net::Request& status, bool over, std::weak_ptr<Search> ws, Sp<Query> query);

    /**
     * This method recovers sends individual request for values per id.
@@ -521,12 +528,12 @@ private:
     * @param query  The initial query passed through the API.
     * @param n      The node to which send the requests.
     */
-    void paginate(std::weak_ptr<Search> ws, std::shared_ptr<Query> query, SearchNode* n);
+    void paginate(std::weak_ptr<Search> ws, Sp<Query> query, SearchNode* n);

    /**
     * If update is true, this method will also send message to synced but non-updated search nodes.
     */
-    SearchNode* searchSendGetValues(std::shared_ptr<Search> sr, SearchNode *n = nullptr, bool update = true);
+    SearchNode* searchSendGetValues(Sp<Search> sr, SearchNode *n = nullptr, bool update = true);

    /**
     * Forwards an 'announce' request for a list of nodes to the network engine.
@@ -534,7 +541,7 @@ private:
     * @param sr  The search for which we want to announce a value.
     * @param announce  The 'announce' structure.
     */
-    void searchSendAnnounceValue(const std::shared_ptr<Search>& sr);
+    void searchSendAnnounceValue(const Sp<Search>& sr);

    /**
     * Main process of a Search's operations. This function will demand the
@@ -543,51 +550,54 @@ private:
     *
     * @param sr  The search to execute its operations.
     */
-    void searchStep(std::shared_ptr<Search> sr);
+    void searchStep(Sp<Search> sr);
    void dumpSearch(const Search& sr, std::ostream& out) const;

    bool neighbourhoodMaintenance(RoutingTable&);

    void processMessage(const uint8_t *buf, size_t buflen, const SockAddr&);

-    void onError(std::shared_ptr<Request> node, DhtProtocolException e);
+    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 */
-    NetworkEngine::RequestAnswer onPing(std::shared_ptr<Node> node);
+    net::NetworkEngine::RequestAnswer onPing(Sp<Node> node);
    /* when we receive a "find node" request */
-    NetworkEngine::RequestAnswer onFindNode(std::shared_ptr<Node> node, const InfoHash& hash, want_t want);
-    void onFindNodeDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search> sr);
+    net::NetworkEngine::RequestAnswer onFindNode(Sp<Node> node, const InfoHash& hash, want_t want);
+    void onFindNodeDone(const Sp<Node>& status,
+            net::NetworkEngine::RequestAnswer& a,
+            Sp<Search> sr);
    /* when we receive a "get values" request */
-    NetworkEngine::RequestAnswer onGetValues(std::shared_ptr<Node> node,
+    net::NetworkEngine::RequestAnswer onGetValues(Sp<Node> node,
            const InfoHash& hash,
            want_t want,
            const Query& q);
-    void onGetValuesDone(const Request& status,
-            NetworkEngine::RequestAnswer& a,
-            std::shared_ptr<Search>& sr,
-            const std::shared_ptr<Query>& orig_query);
+    void onGetValuesDone(const Sp<Node>& status,
+            net::NetworkEngine::RequestAnswer& a,
+            Sp<Search>& sr,
+            const Sp<Query>& orig_query);
    /* when we receive a listen request */
-    NetworkEngine::RequestAnswer onListen(std::shared_ptr<Node> node,
+    net::NetworkEngine::RequestAnswer onListen(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
-            size_t rid,
+            size_t socket_id,
            const Query& query);
-    void onListenDone(const Request& status,
-            NetworkEngine::RequestAnswer& a,
-            std::shared_ptr<Search>& sr,
-            const std::shared_ptr<Query>& orig_query);
+    void onListenDone(const Sp<Node>& status,
+            net::NetworkEngine::RequestAnswer& a,
+            Sp<Search>& sr);
    /* when we receive an announce request */
-    NetworkEngine::RequestAnswer onAnnounce(std::shared_ptr<Node> node,
+    net::NetworkEngine::RequestAnswer onAnnounce(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
-            const std::vector<std::shared_ptr<Value>>& v,
+            const std::vector<Sp<Value>>& v,
            const time_point& created);
-    NetworkEngine::RequestAnswer onRefresh(std::shared_ptr<Node> node,
+    net::NetworkEngine::RequestAnswer onRefresh(Sp<Node> node,
            const InfoHash& hash,
            const Blob& token,
            const Value::Id& vid);
-    void onAnnounceDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search>& sr);
+    void onAnnounceDone(const Sp<Node>& status,
+            net::NetworkEngine::RequestAnswer& a,
+            Sp<Search>& sr);
 };

 }
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -26,6 +26,7 @@
 #include "callbacks.h"
 #include "sockaddr.h"
 #include "log_enable.h"
+#include "def.h"

 #include <thread>
 #include <mutex>
@@ -48,7 +49,7 @@ struct SecureDhtConfig;
 * either wait for (expectedly frequent) calls to ::loop() or start an internal
 * thread that will update the DHT when appropriate.
 */
-class DhtRunner {
+class OPENDHT_PUBLIC DhtRunner {

 public:
    typedef std::function<void(NodeStatus, NodeStatus)> StatusCallback;
@@ -275,14 +276,15 @@ public:
        return running;
    }

-    int getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return, unsigned *incoming_return) const;
+    NodeStats getNodesStats(sa_family_t af) const;
+    unsigned getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return, unsigned *incoming_return) const;

    std::vector<unsigned> getNodeMessageStats(bool in = false) const;
    std::string getStorageLog() const;
    std::string getStorageLog(const InfoHash&) const;
    std::string getRoutingTablesLog(sa_family_t af) const;
    std::string getSearchesLog(sa_family_t af = AF_UNSPEC) const;
-    std::string getSearchLog(const InfoHash&, sa_family_t af = AF_UNSPEC) const;    
+    std::string getSearchLog(const InfoHash&, sa_family_t af = AF_UNSPEC) const;
    std::vector<SockAddr> getPublicAddress(sa_family_t af = AF_UNSPEC);
    std::vector<std::string> getPublicAddressStr(sa_family_t af = AF_UNSPEC);

@@ -309,7 +311,8 @@ public:
                /*.node_config = */{
                    /*.node_id = */{},
                    /*.network = */network,
-                    /*.is_bootstrap = */false
+                    /*.is_bootstrap = */false,
+                    /*.maintain_storage*/false
                },
                /*.id = */identity
            },
@@ -368,7 +371,7 @@ private:
     * nodes so that the DHT node can recover quickly from losing connection
     * with the network.
     */
-    void tryBootstrapCoutinuously();
+    void tryBootstrapContinuously();

    void doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDhtConfig config);
    time_point loop_();
@@ -1,3 +1,23 @@
+/*
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
+ *              Nicolas Reynaud <nicolas.reynaud@savoirfairelinux.com>
+ *
+ *  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 <http://www.gnu.org/licenses/>.
+ */
+
 #pragma once

 #include <string>
@@ -26,7 +46,7 @@ namespace indexation {
 * the node in question is a leaf, *the label is a prefix of all the keys
 * contained in the leaf*.
 */
-struct Prefix {
+struct OPENDHT_PUBLIC Prefix {
    Prefix() {}
    Prefix(InfoHash h) : size_(h.size() * 8), content_(h.begin(), h.end()) { }
    Prefix(const Blob& d, const Blob& f={}) : size_(d.size()*8), flags_(f), content_(d) { }
@@ -245,7 +265,7 @@ private:
 };

 using Value = std::pair<InfoHash, dht::Value::Id>;
-struct IndexEntry : public dht::Value::Serializable<IndexEntry> {
+struct OPENDHT_PUBLIC IndexEntry : public dht::Value::Serializable<IndexEntry> {
    static const ValueType TYPE;

    virtual void unpackValue(const dht::Value& v) {
@@ -265,7 +285,7 @@ struct IndexEntry : public dht::Value::Serializable<IndexEntry> {
    MSGPACK_DEFINE_MAP(prefix, value)
 };

-class Pht {
+class OPENDHT_PUBLIC Pht {
    static constexpr const char* INVALID_KEY = "Key does not match the PHT key spec.";

    /* Prefixes the user_type for all dht values put on the DHT */
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -19,6 +19,8 @@

 #pragma once

+#include "def.h"
+
 #include <msgpack.hpp>

 #ifndef _WIN32
@@ -40,6 +42,7 @@ typedef uint16_t in_port_t;
 #include <vector>
 #include <algorithm>
 #include <stdexcept>
+#include <sstream>
 #include <cstring>


@@ -48,12 +51,93 @@ typedef uint16_t in_port_t;

 namespace dht {

+using byte = uint8_t;
+
+template <size_t N>
+class OPENDHT_PUBLIC Hash
+{
+public:
+    Hash() {
+        data_.fill(0);
+    }
+    Hash(const msgpack::object& o) {
+        msgpack_unpack(o);
+    }
+    byte* data() {
+        return data_.data();
+    }
+    const byte* data() const {
+        return data_.data();
+    }
+    constexpr size_t size() const { return data_.size(); }
+    explicit operator bool() const { return std::any_of(data_.begin(), data_.end(), [](byte _b) { return _b != 0; }); }
+    bool operator==(Hash const& _c) const { return data_ == _c.data_; }
+    bool operator!=(Hash const& _c) const { return data_ != _c.data_; }
+    bool operator<(Hash const& _c) const { for (unsigned i = 0; i < N; ++i) if (data_[i] < _c.data_[i]) return true; else if (data_[i] > _c.data_[i]) return false; return false; }
+    bool operator>=(Hash const& _c) const { return !operator<(_c); }
+    bool operator<=(Hash const& _c) const { return operator==(_c) || operator<(_c); }
+    bool operator>(Hash const& _c) const { return !operator<=(_c); }
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_bin(N);
+        pk.pack_bin_body((char*)data_.data(), N);
+    }
+    void msgpack_unpack(msgpack::object o) {
+        if (o.type != msgpack::type::BIN or o.via.bin.size != N)
+            throw msgpack::type_error();
+        std::copy_n(o.via.bin.ptr, N, data_.data());
+    }
+
+    template <size_t M>
+    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const Hash<M>& h);
+
+    template <size_t M>
+    OPENDHT_PUBLIC friend std::istream& operator>> (std::istream& s, Hash<M>& h);
+
+    std::string toString() const {
+        std::stringstream ss;
+        ss << *this;
+        return ss.str();
+    }
+
+private:
+    std::array<byte, N> data_;
+};
+
+template <size_t N>
+std::ostream& operator<< (std::ostream& s, const Hash<N>& h)
+{
+    s << std::hex;
+    for (unsigned i=0; i<h.size(); i++)
+        s << std::setfill('0') << std::setw(2) << (unsigned)h.data_[i];
+    s << std::dec;
+    return s;
+}
+
+template <size_t N>
+std::istream& operator>> (std::istream& s, Hash<N>& h)
+{
+    std::array<char, h.size()*2> dat;
+    s.exceptions(std::istream::eofbit | std::istream::failbit);
+    s.read(&(*dat.begin()), dat.size());
+    for (size_t i = 0; i < h.size(); i++) {
+        unsigned res = 0;
+        sscanf(dat.data() + 2*i, "%02x", &res);
+        h[i] = res;
+    }
+    return s;
+}
+
+using h256 = Hash<32>;
+using PkId = h256;
+
 /**
 * Represents an InfoHash.
 * An InfoHash is a byte array of HASH_LEN bytes.
 * InfoHashes identify nodes and values in the Dht.
 */
-class InfoHash final : public std::array<uint8_t, HASH_LEN> {
+class OPENDHT_PUBLIC InfoHash final : public std::array<uint8_t, HASH_LEN> {
 public:
    constexpr InfoHash() : std::array<uint8_t, HASH_LEN>() {}
    constexpr InfoHash(const std::array<uint8_t, HASH_LEN>& h) : std::array<uint8_t, HASH_LEN>(h) {}
@@ -96,11 +180,7 @@ public:
     * Forget about the ``XOR-metric''.  An id is just a path from the
     * root of the tree, so bits are numbered from the start.
     */
-#ifdef WIN32_NATIVE
-    static inline int cmp(const InfoHash& __restrict id1, const InfoHash& __restrict id2) {
-#else
-    static inline int cmp(const InfoHash& __restrict__ id1, const InfoHash& __restrict__ id2) {
-#endif
+    static inline int cmp(const InfoHash& id1, const InfoHash& id2) {
        return std::memcmp(id1.data(), id2.data(), HASH_LEN);
    }

@@ -196,8 +276,8 @@ public:

    static InfoHash getRandom();

-    friend std::ostream& operator<< (std::ostream& s, const InfoHash& h);
-    friend std::istream& operator>> (std::istream& s, InfoHash& h);
+    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const InfoHash& h);
+    OPENDHT_PUBLIC friend std::istream& operator>> (std::istream& s, InfoHash& h);

    std::string toString() const;

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -62,58 +62,17 @@ constexpr const Color::Modifier yellow(Color::FG_YELLOW);
 /**
 * Print va_list to std::ostream (used for logging).
 */
-void
-printLog(std::ostream& s, char const* m, va_list args) {
-    // print log to buffer
-    std::array<char, 8192> buffer;
-    int ret = vsnprintf(buffer.data(), buffer.size(), m, args);
-    if (ret < 0)
-        return;
+OPENDHT_PUBLIC void
+printLog(std::ostream &s, char const *m, va_list args);

-    // write timestamp
-    using namespace std::chrono;
-    using log_precision = microseconds;
-    constexpr auto den = log_precision::period::den;
-    auto micro = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
-    s << "[" << std::setfill('0') << std::setw(6) << micro / den << "." 
-             << std::setfill('0') << std::setw(6) << micro % den << "]" << " ";
+OPENDHT_PUBLIC void
+enableLogging(dht::DhtRunner &dht);

-    // write log
-    s.write(buffer.data(), std::min((size_t)ret, buffer.size()));
-    if ((size_t)ret >= buffer.size())
-        s << "[[TRUNCATED]]";
-    s.put('\n');
-}
+OPENDHT_PUBLIC void
+enableFileLogging(dht::DhtRunner &dht, const std::string &path);

-void
-enableLogging(dht::DhtRunner& dht)
-{
-    dht.setLoggers(
-        [](char const* m, va_list args){ std::cerr << red; printLog(std::cerr, m, args); std::cerr << def; },
-        [](char const* m, va_list args){ std::cout << yellow; printLog(std::cout, m, args); std::cout << def; },
-        [](char const* m, va_list args){ printLog(std::cout, m, args); }
-    );
-}
-
-void
-enableFileLogging(dht::DhtRunner& dht, const std::string& path)
-{
-    auto logfile = std::make_shared<std::fstream>();
-    logfile->open(path, std::ios::out);
-
-    dht.setLoggers(
-        [=](char const* m, va_list args){ printLog(*logfile, m, args); },
-        [=](char const* m, va_list args){ printLog(*logfile, m, args); },
-        [=](char const* m, va_list args){ printLog(*logfile, m, args); }
-    );
-}
-
-void
-disableLogging(dht::DhtRunner& dht)
-{
-    dht.setLoggers(dht::NOLOG, dht::NOLOG, dht::NOLOG);
-}
+OPENDHT_PUBLIC void
+disableLogging(dht::DhtRunner &dht);

 } /* log */
 } /* dht  */
-
@@ -0,0 +1,82 @@
+/*
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <simon.desaulniers@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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+namespace dht {
+namespace net {
+
+struct TransPrefix : public std::array<uint8_t, 2> {
+    TransPrefix(const std::string& str) : std::array<uint8_t, 2>({{(uint8_t)str[0], (uint8_t)str[1]}}) {}
+    static const TransPrefix PING;
+    static const TransPrefix FIND_NODE;
+    static const TransPrefix GET_VALUES;
+    static const TransPrefix ANNOUNCE_VALUES;
+    static const TransPrefix REFRESH;
+    static const TransPrefix LISTEN;
+};
+
+/* Transaction-ids are 4-bytes long, with the first two bytes identifying
+ * the kind of request, and the remaining two a sequence number in
+ * host order.
+ */
+struct TransId final : public std::array<uint8_t, 4> {
+    static const constexpr uint16_t INVALID {0};
+
+    TransId() { std::fill_n(begin(), 4, 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]);
+    }
+
+    uint32_t toInt() const {
+        return *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;
+    }
+
+    unsigned length {4};
+};
+
+} /* namespace net */
+} /* dht */
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -27,6 +27,7 @@
 #include "utils.h"
 #include "rng.h"
 #include "rate_limiter.h"
+#include "net.h"

 #include <vector>
 #include <string>
@@ -37,6 +38,10 @@
 #include <queue>

 namespace dht {
+namespace net {
+
+struct Request;
+struct Socket;

 #ifndef MSG_CONFIRM
 #define MSG_CONFIRM 0
@@ -96,56 +101,7 @@ struct ParsedMessage;
 */
 class NetworkEngine final
 {
-    struct TransPrefix : public  std::array<uint8_t, 2>  {
-        TransPrefix(const std::string& str) : std::array<uint8_t, 2>({{(uint8_t)str[0], (uint8_t)str[1]}}) {}
-        static const TransPrefix PING;
-        static const TransPrefix FIND_NODE;
-        static const TransPrefix GET_VALUES;
-        static const TransPrefix ANNOUNCE_VALUES;
-        static const TransPrefix REFRESH;
-        static const TransPrefix LISTEN;
-    };
 public:
-
-    /* Transaction-ids are 4-bytes long, with the first two bytes identifying
-     * the kind of request, and the remaining two a sequence number in
-     * host order.
-     */
-    struct TransId final : public std::array<uint8_t, 4> {
-        static const constexpr uint16_t INVALID {0};
-
-        TransId() {}
-        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]);
-        }
-
-        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;
-        }
-
-        unsigned length {4};
-    };
-
    /*!
     * @class   RequestAnswer
     * @brief   Answer for a request.
@@ -156,121 +112,101 @@ public:
    struct RequestAnswer {
        Blob ntoken {};
        Value::Id vid {};
-        std::vector<std::shared_ptr<Value>> values {};
-        std::vector<std::shared_ptr<FieldValueIndex>> fields {};
-        std::vector<std::shared_ptr<Node>> nodes4 {};
-        std::vector<std::shared_ptr<Node>> nodes6 {};
+        std::vector<Sp<Value>> values {};
+        std::vector<Sp<FieldValueIndex>> fields {};
+        std::vector<Sp<Node>> nodes4 {};
+        std::vector<Sp<Node>> nodes6 {};
        RequestAnswer() {}
        RequestAnswer(ParsedMessage&& msg);
    };


-    /**
-     * Cancel a request. Setting req->cancelled = true is not enough in the case
-     * a request is "persistent".
-     */
-    void cancelRequest(std::shared_ptr<Request>& req);
-
-    void connectivityChanged(sa_family_t);
-
 private:
+    /**
+     * Called when we receive an error message.
+     */
+    std::function<void(Sp<Request>, DhtProtocolException)> onError;

    /**
-     * @brief when we receive an error message.
-     *
-     * @param node (type: std::shared_ptr<Request>) the associated request for
-     *             which we got an error;
-     */
-    std::function<void(std::shared_ptr<Request>, DhtProtocolException)> onError;
-    /**
-     * @brief when a new node happens.
-     *
     * Called for every packets received for handling new nodes contacting us.
     *
-     * @param id (type: InfoHash) id of the node.
-     * @param saddr (type: sockaddr*) sockaddr* pointer containing address ip information.
-     * @param saddr_len (type: socklen_t) lenght of the sockaddr struct.
-     * @param confirm (type: int) 1 if the node sent a message, 2 if it sent us a reply.
+     * @param node: the node
+     * @param confirm: 1 if the node sent a message, 2 if it sent us a reply.
     */
-    std::function<void(const std::shared_ptr<Node>&, int)> onNewNode;
+    std::function<void(const Sp<Node>&, int)> onNewNode;
    /**
-     * @brief when an addres is reported from a distant node.
+     * Called when an addres is reported from a requested node.
     *
-     * @param id (type: InfoHash) id of the node.
-     * @param saddr (type: sockaddr*) sockaddr* pointer containing address ip information.
+     * @param h: id 
     * @param saddr_len (type: socklen_t) lenght of the sockaddr struct.
     */
    std::function<void(const InfoHash&, const SockAddr&)> onReportedAddr;
    /**
-     * @brief on ping request callback.
+     * Called on ping reception.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     * @param node (type: Sp<Node>) the requesting node.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>)> onPing {};
+    std::function<RequestAnswer(Sp<Node>)> onPing {};
    /**
-     * @brief on find node request callback.
+     * Called on find node request.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
-     * @param vhash (type: InfoHash) hash of the value of interest.
+     * @param node (type: Sp<Node>) the requesting node.
+     * @param h (type: InfoHash) hash of the value of interest.
     * @param want (type: want_t) states if nodes sent in the response are ipv4
     *             or ipv6.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>,
-            const InfoHash&,
-            want_t)> onFindNode {};
+    std::function<RequestAnswer(Sp<Node>, const InfoHash&, want_t)> onFindNode {};
    /**
-     * @brief on "get values" request callback.
+     * Called on "get values" request.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
-     * @param vhash (type: InfoHash) hash of the value of interest.
+     * @param node (type: Sp<Node>) the requesting node.
+     * @param h (type: InfoHash) hash of the value of interest.
     * @param want (type: want_t) states if nodes sent in the response are ipv4
     *             or ipv6.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>,
-            const InfoHash&,
-            want_t,
-            const Query&)> onGetValues {};
+    std::function<RequestAnswer(Sp<Node>, const InfoHash&, want_t, const Query&)> onGetValues {};
    /**
-     * @brief on listen request callback.
+     * Called on listen request.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
-     * @param vhash (type: InfoHash) hash of the value of interest.
+     * @param node (type: Sp<Node>) the requesting node.
+     * @param h (type: InfoHash) hash of the value of interest.
     * @param token (type: Blob) security token.
     * @param rid (type: uint16_t) request id.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>,
+    std::function<RequestAnswer(Sp<Node>,
            const InfoHash&,
            const Blob&,
-            uint16_t,
+            uint32_t,
            const Query&)> onListen {};
    /**
-     * @brief on announce request callback.
+     * Called on announce request.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
-     * @param vhash (type: InfoHash) hash of the value of interest.
+     * @param node (type: Sp<Node>) the requesting node.
+     * @param h (type: InfoHash) hash of the value of interest.
     * @param token (type: Blob) security token.
-     * @param values (type: std::vector<std::shared_ptr<Value>>) values to store.
+     * @param values (type: std::vector<Sp<Value>>) values to store.
     * @param created (type: time_point) time when the value was created.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>,
+    std::function<RequestAnswer(Sp<Node>,
            const InfoHash&,
            const Blob&,
-            const std::vector<std::shared_ptr<Value>>&,
+            const std::vector<Sp<Value>>&,
            const time_point&)> onAnnounce {};
    /**
-     * @brief on refresh request callback.
+     * Called on refresh request.
     *
-     * @param node (type: std::shared_ptr<Node>) the requesting node.
-     * @param vhash (type: InfoHash) hash of the value of interest.
+     * @param node (type: Sp<Node>) the requesting node.
+     * @param h (type: InfoHash) hash of the value of interest.
     * @param token (type: Blob) security token.
     * @param vid (type: Value::id) the value id.
     */
-    std::function<RequestAnswer(std::shared_ptr<Node>,
+    std::function<RequestAnswer(Sp<Node>,
            const InfoHash&,
            const Blob&,
            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)>;

@@ -293,67 +229,186 @@ public:
    /**
     * Sends values (with closest nodes) to a listenner.
     *
-     * @param sa  The address of the listenner.
-     * @param sslen  The length of the sockaddr structure.
-     * @param rid  The request id of the initial listen request.
-     * @param hash  The hash key of the value.
-     * @param want  Wether to send ipv4 and/or ipv6 nodes.
-     * @param ntoken  Listen security token.
-     * @param nodes  The ipv4 closest nodes.
-     * @param nodes6  The ipv6 closest nodes.
-     * @param values  The values to send.
+     * @param sa          The address of the listenner.
+     * @param sslen       The length of the sockaddr structure.
+     * @param socket_id  The tid to use to write to the request socket.
+     * @param hash        The hash key of the value.
+     * @param want        Wether to send ipv4 and/or ipv6 nodes.
+     * @param ntoken      Listen security token.
+     * @param nodes       The ipv4 closest nodes.
+     * @param nodes6      The ipv6 closest nodes.
+     * @param values      The values to send.
     */
-    void tellListener(std::shared_ptr<Node> n, uint16_t rid, const InfoHash& hash, want_t want, const Blob& ntoken,
-            std::vector<std::shared_ptr<Node>>&& nodes, std::vector<std::shared_ptr<Node>>&& nodes6,
-            std::vector<std::shared_ptr<Value>>&& values, const Query& q);
+    void tellListener(Sp<Node> n, uint32_t socket_id, const InfoHash& hash, want_t want, const Blob& ntoken,
+            std::vector<Sp<Node>>&& nodes, std::vector<Sp<Node>>&& nodes6,
+            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);
+
+    void connectivityChanged(sa_family_t);
+
    /**************
     *  Requests  *
     **************/
-    std::shared_ptr<Request>
-        sendPing(std::shared_ptr<Node> n, RequestCb on_done, RequestExpiredCb on_expired);
-    std::shared_ptr<Request>
-        sendPing(const sockaddr* sa, socklen_t salen, RequestCb on_done, RequestExpiredCb on_expired) {
-            return sendPing(std::make_shared<Node>(zeroes, sa, salen), on_done, on_expired);
+
+    /**
+     * Send a "ping" request to a given node.
+     *
+     * @param n           The node.
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request>
+        sendPing(Sp<Node> n, RequestCb&& on_done, RequestExpiredCb&& on_expired);
+    /**
+     * Send a "ping" request to a given node.
+     *
+     * @param sa          The node's ip sockaddr info.
+     * @param salen       The associated sockaddr struct length.
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @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),
+                    std::forward<RequestCb>(on_done),
+                    std::forward<RequestExpiredCb>(on_expired));
        }
-    std::shared_ptr<Request>
-        sendFindNode(std::shared_ptr<Node> n,
-                const InfoHash& target,
-                want_t want,
-                RequestCb on_done,
-                RequestExpiredCb on_expired);
-    std::shared_ptr<Request>
-        sendGetValues(std::shared_ptr<Node> n,
-                const InfoHash& info_hash,
-                const Query& query,
-                want_t want,
-                RequestCb on_done,
-                RequestExpiredCb on_expired);
-    std::shared_ptr<Request>
-        sendListen(std::shared_ptr<Node> n,
-                const InfoHash& infohash,
-                const Query& query,
-                const Blob& token,
-                RequestCb on_done,
-                RequestExpiredCb on_expired);
-    std::shared_ptr<Request>
-        sendAnnounceValue(std::shared_ptr<Node> n,
-                const InfoHash& infohash,
-                const std::shared_ptr<Value>& v,
-                time_point created,
-                const Blob& token,
-                RequestCb on_done,
-                RequestExpiredCb on_expired);
-    std::shared_ptr<Request>
-        sendRefreshValue(std::shared_ptr<Node> n,
-                const InfoHash& infohash,
-                const Value::Id& vid,
-                const Blob& token,
-                RequestCb on_done,
-                RequestExpiredCb on_expired);
+    /**
+     * Send a "find node" request to a given node.
+     *
+     * @param n           The node.
+     * @param target      The target hash.
+     * @param want        Indicating wether IPv4 or IPv6 are wanted in response.
+     *                    Use NetworkEngine::want()
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request> sendFindNode(Sp<Node> n,
+                             const InfoHash& hash,
+                             want_t want,
+                             RequestCb&& on_done,
+                             RequestExpiredCb&& on_expired);
+    /**
+     * Send a "get" request to a given node.
+     *
+     * @param n           The node.
+     * @param hash        The target hash.
+     * @param query       The query describing filters.
+     * @param token       A security token.
+     * @param want        Indicating wether IPv4 or IPv6 are wanted in response.
+     *                    Use NetworkEngine::want()
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request> sendGetValues(Sp<Node> n,
+                              const InfoHash& hash,
+                              const Query& query,
+                              want_t want,
+                              RequestCb&& on_done,
+                              RequestExpiredCb&& on_expired);
+    /**
+     * Send a "listen" request to a given node.
+     *
+     * @param n           The node.
+     * @param hash        The storage's hash.
+     * @param query       The query describing filters.
+     * @param token       A security token.
+     * @param previous    The previous request "listen" sent to this node.
+     * @param socket      **UNUSED** The socket for further response.
+     *
+     *                    For backward compatibility purpose, sendListen has to
+     *                    handle creation of the socket. Therefor, you cannot
+     *                    use openSocket yourself. TODO: Once we don't support
+     *                    the old "listen" negociation, sendListen shall not
+     *                    create the socket itself.
+     *
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     * @param socket_cb   Callback to execute each time new updates arrive on
+     *                    the socket.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request> sendListen(Sp<Node> n,
+                           const InfoHash& hash,
+                           const Query& query,
+                           const Blob& token,
+                           Sp<Request> previous,
+                           RequestCb&& on_done,
+                           RequestExpiredCb&& on_expired,
+                           SocketCb&& socket_cb);
+    /**
+     * Send a "announce" request to a given node.
+     *
+     * @param n           The node.
+     * @param hash        The target hash.
+     * @param created     The time when the value was created (avoiding extended
+     *                    value lifetime)
+     * @param token       A security token.
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request> sendAnnounceValue(Sp<Node> n,
+                                  const InfoHash& hash,
+                                  const Sp<Value>& v,
+                                  time_point created,
+                                  const Blob& token,
+                                  RequestCb&& on_done,
+                                  RequestExpiredCb&& on_expired);
+    /**
+     * Send a "refresh" request to a given node. Asks a node to keep the
+     * associated value Value.type.expiration more minutes in its storage.
+     *
+     * @param n           The node.
+     * @param hash        The target hash.
+     * @param vid         The value id.
+     * @param token       A security token.
+     * @param on_done     Request callback when the request is completed.
+     * @param on_expired  Request callback when the request expires.
+     *
+     * @return the request with information concerning its success.
+     */
+    Sp<Request> sendRefreshValue(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.
@@ -366,7 +421,7 @@ public:
     */
    void processMessage(const uint8_t *buf, size_t buflen, const SockAddr& addr);

-    std::shared_ptr<Node> insertNode(const InfoHash& myid, const SockAddr& addr) {
+    Sp<Node> insertNode(const InfoHash& myid, const SockAddr& addr) {
        auto n = cache.getNode(myid, addr, scheduler.time(), 0);
        onNewNode(n, 0);
        return n;
@@ -379,9 +434,9 @@ public:
        return stats;
    }

-    void blacklistNode(const std::shared_ptr<Node>& n);
+    void blacklistNode(const Sp<Node>& n);

-    std::vector<std::shared_ptr<Node>> getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count) {
+    std::vector<Sp<Node>> getCachedNodes(const InfoHash& id, sa_family_t sa_f, size_t count) {
        return cache.getCachedNodes(id, sa_f, count);
    }

@@ -421,13 +476,13 @@ private:
    static bool isMartian(const SockAddr& addr);
    bool isNodeBlacklisted(const SockAddr& addr) const;

-    void requestStep(std::shared_ptr<Request> req);
+    void requestStep(Sp<Request> req);

    /**
     * Sends a request to a node. Request::MAX_ATTEMPT_COUNT attempts will
     * be made before the request expires.
     */
-    void sendRequest(std::shared_ptr<Request>& request);
+    void sendRequest(Sp<Request>& request);

    /**
     * Generates a new request id, skipping the invalid id.
@@ -440,11 +495,11 @@ private:
    }

    struct MessageStats {
-        unsigned ping {0};
-        unsigned find {0};
-        unsigned get {0};
-        unsigned put {0};
-        unsigned listen {0};
+        unsigned ping    {0};
+        unsigned find    {0};
+        unsigned get     {0};
+        unsigned put     {0};
+        unsigned listen  {0};
        unsigned refresh {0};
    };

@@ -453,7 +508,7 @@ private:
    int send(const char *buf, size_t len, int flags, const SockAddr& addr);

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

    /*************
@@ -466,16 +521,16 @@ private:
            TransId tid,
            const Blob& nodes,
            const Blob& nodes6,
-            const std::vector<std::shared_ptr<Value>>& st,
+            const std::vector<Sp<Value>>& st,
            const Query& query,
            const Blob& token);
-    Blob bufferNodes(sa_family_t af, const InfoHash& id, std::vector<std::shared_ptr<Node>>& nodes);
+    Blob bufferNodes(sa_family_t af, const InfoHash& id, std::vector<Sp<Node>>& nodes);

    std::pair<Blob, Blob> bufferNodes(sa_family_t af,
            const InfoHash& id,
            want_t want,
-            std::vector<std::shared_ptr<Node>>& nodes,
-            std::vector<std::shared_ptr<Node>>& nodes6);
+            std::vector<Sp<Node>>& nodes,
+            std::vector<Sp<Node>>& nodes6);
    /* answer to a listen request */
    void sendListenConfirmation(const SockAddr& addr, TransId tid);
    /* answer to put request */
@@ -528,18 +583,21 @@ private:
    };
    // 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, cmpSockAddr>;
+    using IpLimiterMap = std::map<SockAddr, IpLimiter, SockAddr::ipCmp>;
    IpLimiterMap address_rate_limiter {};
    RateLimiter<MAX_REQUESTS_PER_SEC> rate_limiter {};

    // requests handling
    uint16_t transaction_id {1};
-    std::map<uint16_t, std::shared_ptr<Request>> requests {};
+    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 {};

    Scheduler& scheduler;
 };

-}
+} /* namespace net  */
+} /* namespace dht */
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -28,7 +28,9 @@

 namespace dht {

+namespace net {
 struct Request;
+} /* namespace net */

 struct Node {
    InfoHash id;
@@ -72,8 +74,8 @@ struct Node {

    void update(const SockAddr&);

-    void requested(std::shared_ptr<Request>& req);
-    void received(time_point now, std::shared_ptr<Request> req);
+    void requested(std::shared_ptr<net::Request>& req);
+    void received(time_point now, std::shared_ptr<net::Request> req);

    void setExpired();

@@ -84,7 +86,7 @@ struct Node {

    std::string toString() const;

-    friend std::ostream& operator<< (std::ostream& s, const Node& h);
+    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const Node& h);

    static constexpr const std::chrono::minutes NODE_GOOD_TIME {120};

@@ -98,12 +100,12 @@ private:
    /* Number of times we accept authentication errors from this node. */
    static const constexpr unsigned MAX_AUTH_ERRORS {3};

-    std::list<std::weak_ptr<Request>> requests_ {};
+    std::list<std::weak_ptr<net::Request>> requests_ {};
    unsigned auth_errors {0};
    bool expired_ {false};

    void clearPendingQueue() {
-        requests_.remove_if([](std::weak_ptr<Request>& w) {
+        requests_.remove_if([](std::weak_ptr<net::Request>& w) {
            return w.expired();
        });
    }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  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
@@ -1,7 +1,7 @@
 /*
 *  Copyright (C) 2016 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -18,11 +18,37 @@
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
 */

+#pragma once
+
+#include "net.h"
+
 namespace dht {
+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.
@@ -32,7 +58,8 @@ struct ParsedMessage;
 * request is done.
 */
 struct Request {
-    friend class dht::NetworkEngine;
+    friend class dht::net::NetworkEngine;
+
    std::shared_ptr<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. */

@@ -52,13 +79,13 @@ struct Request {
    State getState() const { return state_; }

    Request() {}
-    Request(uint16_t tid,
+    Request(TransId tid,
            std::shared_ptr<Node> node,
            Blob&& msg,
-            std::function<void(const Request& req_status, ParsedMessage&&)> on_done,
-            std::function<void(const Request& req_status, bool)> on_expired,
-            bool persistent = false) :
-        node(node), on_done(on_done), on_expired(on_expired), tid(tid), msg(std::move(msg)), persistent(persistent) { }
+            std::function<void(const Request&, ParsedMessage&&)> on_done,
+            std::function<void(const Request&, bool)> on_expired,
+            std::shared_ptr<Socket> socket = {}) :
+        node(node), on_done(on_done), on_expired(on_expired), tid(tid), msg(std::move(msg)), socket(socket) { }

    void setExpired() {
        if (pending()) {
@@ -68,11 +95,10 @@ struct Request {
        }
    }
    void setDone(ParsedMessage&& msg) {
-        if (pending() or persistent) {
+        if (pending()) {
            state_ = Request::State::COMPLETED;
            on_done(*this, std::forward<ParsedMessage>(msg));
-            if (not persistent)
-                clear();
+            clear();
        }
    }

@@ -102,12 +128,13 @@ private:
    time_point start {time_point::min()};      /* time when the request is created. */
    time_point last_try {time_point::min()};   /* time of the last attempt to process the request. */

-    std::function<void(const Request& req_status, ParsedMessage&&)> on_done {};
-    std::function<void(const Request& req_status, bool)> on_expired {};
+    std::function<void(const Request&, ParsedMessage&&)> on_done {};
+    std::function<void(const Request&, bool)> on_expired {};

-    const uint16_t tid {0};                   /* the request id. */
-    Blob msg {};                              /* the serialized message. */
-    const bool persistent {false};            /* the request is not erased upon completion. */
+    const TransId tid; /* the request id. */
+    Blob msg {};                      /* the serialized message. */
+    std::shared_ptr<Socket> socket;   /* the socket used for further reponses. */
 };

+} /* namespace net  */
 }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -1,6 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -31,12 +32,12 @@ struct Bucket {
        : af(af), first(f), time(t), cached() {}
    sa_family_t af {0};
    InfoHash first {};
-    time_point time {time_point::min()};             /* time of last reply in this bucket */
-    std::list<std::shared_ptr<Node>> nodes {};
-    std::shared_ptr<Node> cached;                    /* the address of a likely candidate */
+    time_point time {time_point::min()}; /* time of last reply in this bucket */
+    std::list<Sp<Node>> nodes {};
+    Sp<Node> cached;                    /* the address of a likely candidate */

    /** Return a random node in a bucket. */
-    std::shared_ptr<Node> randomNode();
+    Sp<Node> randomNode();
 };

 class RoutingTable : public std::list<Bucket> {
@@ -45,7 +46,7 @@ public:

    InfoHash middle(const RoutingTable::const_iterator&) const;

-    std::vector<std::shared_ptr<Node>> findClosestNodes(const InfoHash id, time_point now, size_t count = TARGET_NODES) const;
+    std::vector<Sp<Node>> findClosestNodes(const InfoHash id, time_point now, size_t count = TARGET_NODES) const;

    RoutingTable::iterator findBucket(const InfoHash& id);
    RoutingTable::const_iterator findBucket(const InfoHash& id) const;
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -52,7 +52,7 @@ public:
     *
     * @return pointer to the newly scheduled job.
     */
-    std::shared_ptr<Scheduler::Job> add(time_point t, std::function<void()>&& job_func) {
+    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);
@@ -67,7 +67,7 @@ public:
     *
     * @return pointer to the newly scheduled job.
     */
-    void edit(std::shared_ptr<Scheduler::Job>& job, time_point t) {
+    void edit(Sp<Scheduler::Job>& job, time_point t) {
        if (not job) {
            DHT_LOG.ERR("editing an empty job");
            return;
@@ -118,7 +118,7 @@ public:

 private:
    time_point now {clock::now()};
-    std::multimap<time_point, std::shared_ptr<Job>> timers {}; /* the jobs ordered by time */
+    std::multimap<time_point, Sp<Job>> timers {}; /* the jobs ordered by time */
    const Logger& DHT_LOG;
 };

@@ -1,6 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *           Simon Désaulniers <simon.desaulniers@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
@@ -40,7 +41,7 @@

 namespace dht {

-class SecureDht : public Dht {
+class OPENDHT_PUBLIC SecureDht : public Dht {
 public:

    typedef std::function<void(bool)> SignatureCheckCallback;
@@ -62,6 +63,9 @@ public:
    InfoHash getId() const {
        return key_ ? key_->getPublicKey().getId() : InfoHash();
    }
+    PkId getLongId() const {
+        return key_ ? key_->getPublicKey().getLongId() : PkId();
+    }

    ValueType secureType(ValueType&& type);

@@ -101,7 +105,7 @@ public:
    /**
     * Will take ownership of the value, sign it using our private key and put it in the DHT.
     */
-    void putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallback callback, bool permanent = false);
+    void putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback, bool permanent = false);
    void putSigned(const InfoHash& hash, Value&& v, DoneCallback callback, bool permanent = false) {
        putSigned(hash, std::make_shared<Value>(std::move(v)), callback, permanent);
    }
@@ -111,7 +115,7 @@ public:
     * and put it in the DHT.
     * The operation will be immediate if the recipient' public key is known (otherwise it will be retrived first).
     */
-    void putEncrypted(const InfoHash& hash, const InfoHash& to, std::shared_ptr<Value> val, DoneCallback callback, bool permanent = false);
+    void putEncrypted(const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent = false);
    void putEncrypted(const InfoHash& hash, const InfoHash& to, Value&& v, DoneCallback callback, bool permanent = false) {
        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
    }
@@ -125,14 +129,14 @@ public:

    Value decrypt(const Value& v);

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

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

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

    /**
     * Allows to set a custom callback called by the library to find a locally-stored certificate.
@@ -150,23 +154,23 @@ private:

    GetCallback getCallbackFilter(GetCallback, Value::Filter&&);

-    std::shared_ptr<crypto::PrivateKey> key_ {};
-    std::shared_ptr<crypto::Certificate> certificate_ {};
+    Sp<crypto::PrivateKey> key_ {};
+    Sp<crypto::Certificate> certificate_ {};

    // method to query the local certificate store
    CertificateStoreQuery localQueryMethod_ {};

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

    std::uniform_int_distribution<Value::Id> rand_id {};
 };

 const ValueType CERTIFICATE_TYPE = {
    8, "Certificate", std::chrono::hours(24 * 7),
-    // A certificate can only be stored at it's public key ID.
-    [](InfoHash id, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t) {
+    // A certificate can only be stored at its public key ID.
+    [](InfoHash id, Sp<Value>& v, InfoHash, const sockaddr*, socklen_t) {
        try {
            crypto::Certificate crt(v->data);
            // TODO check certificate signature
@@ -174,7 +178,7 @@ const ValueType CERTIFICATE_TYPE = {
        } catch (const std::exception& e) {}
        return false;
    },
-    [](InfoHash, const std::shared_ptr<Value>& o, std::shared_ptr<Value>& n, InfoHash, const sockaddr*, socklen_t) {
+    [](InfoHash, const Sp<Value>& o, Sp<Value>& n, InfoHash, const sockaddr*, socklen_t) {
        try {
            return crypto::Certificate(o->data).getPublicKey().getId() == crypto::Certificate(n->data).getPublicKey().getId();
        } catch (const std::exception& e) {}
@@ -18,6 +18,8 @@

 #pragma once

+#include "def.h"
+
 #ifndef _WIN32
 #include <sys/socket.h>
 #else
@@ -30,10 +32,10 @@ typedef uint16_t in_port_t;

 namespace dht {

-std::string print_addr(const sockaddr* sa, socklen_t slen);
-std::string print_addr(const sockaddr_storage& ss, socklen_t sslen);
+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 SockAddr : public std::pair<sockaddr_storage, socklen_t> {
+struct OPENDHT_PUBLIC SockAddr : public std::pair<sockaddr_storage, socklen_t> {
 public:
    SockAddr() : pair<sockaddr_storage, socklen_t>::pair({},0) {}
    SockAddr(const SockAddr& o) : pair<sockaddr_storage, socklen_t>::pair({},o.second) {
@@ -66,10 +68,40 @@ public:
        return print_addr(first, second);
    }
    sa_family_t getFamily() const { return second > sizeof(sa_family_t) ? first.ss_family : AF_UNSPEC; }
+
+    /**
+     * 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;
+            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;
+            }
+
+            return std::memcmp((uint8_t*)&a.first+start, (uint8_t*)&b.first+start, len) < 0;
+        }
+    };
+
 };

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

-std::string printAddr(const SockAddr& addr);
+OPENDHT_PUBLIC std::string printAddr(const SockAddr& addr);

 }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -18,8 +18,7 @@

 #pragma once

-#define WANT4 1
-#define WANT6 2
+#include "def.h"

 #include <msgpack.hpp>

@@ -30,11 +29,18 @@

 #include <cstdarg>

+#define WANT4 1
+#define WANT6 2
+
 namespace dht {

 using NetId = uint32_t;
 using want_t = int_fast8_t;

+// shortcut for std::shared_ptr
+template<class T>
+using Sp = std::shared_ptr<T>;
+
 template <typename Key, typename Item, typename Condition>
 void erase_if(std::map<Key, Item>& map, const Condition& condition)
 {
@@ -45,13 +51,12 @@ void erase_if(std::map<Key, Item>& map, const Condition& condition)
    }
 }

-class DhtException : public std::runtime_error {
+class OPENDHT_PUBLIC DhtException : public std::runtime_error {
    public:
        DhtException(const std::string &str = "") :
            std::runtime_error("DhtException occurred: " + str) {}
 };

-
 // Time related definitions and utility functions

 using clock = std::chrono::steady_clock;
@@ -70,9 +75,6 @@ print_dt(DT d) {
    return std::chrono::duration_cast<std::chrono::duration<double>>(d).count();
 }

-static /*constexpr*/ const time_point TIME_INVALID = {time_point::min()};
-static /*constexpr*/ const time_point TIME_MAX {time_point::max()};
-
 template <typename Duration = duration>
 class uniform_duration_distribution : public std::uniform_int_distribution<typename Duration::rep> {
    using Base = std::uniform_int_distribution<typename Duration::rep>;
@@ -96,7 +98,7 @@ using Blob = std::vector<uint8_t>;
 /**
 * Provides backward compatibility with msgpack 1.0
 */
-Blob unpackBlob(msgpack::object& o);
+OPENDHT_PUBLIC Blob unpackBlob(msgpack::object& o);

 template <typename Type>
 Blob
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -72,7 +72,7 @@ using EditPolicy = std::function<bool(InfoHash key, const std::shared_ptr<Value>

 static constexpr const size_t MAX_VALUE_SIZE {1024 * 64};

-struct ValueType {
+struct OPENDHT_PUBLIC ValueType {
    typedef uint16_t Id;

    static bool DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t);
@@ -114,7 +114,7 @@ struct ValueType {
 * Values are stored at a given InfoHash in the Dht, but also have a
 * unique ID to distinguish between values stored at the same location.
 */
-struct Value
+struct OPENDHT_PUBLIC Value
 {
    enum class Field : int {
        None = 0,
@@ -409,7 +409,7 @@ struct Value
    }

    /** print value for debugging */
-    friend std::ostream& operator<< (std::ostream& s, const Value& v);
+    OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const Value& v);

    std::string toString() const {
        std::stringstream ss;
@@ -553,7 +553,7 @@ using ValuesExport = std::pair<InfoHash, Blob>;
 * This structure holds the value for a specified field. It's type can either be
 * uint64_t, InfoHash or Blob.
 */
-struct FieldValue
+struct OPENDHT_PUBLIC FieldValue
 {
    FieldValue() {}
    FieldValue(Value::Field f, uint64_t int_value) : field(f), intValue(int_value) {}
@@ -638,7 +638,7 @@ private:
 * This is meant to narrow data to a set of specified fields. This structure is
 * used to construct a Select structure.
 */
-struct FieldSelectorDescription
+struct OPENDHT_PUBLIC FieldSelectorDescription
 {
    FieldSelectorDescription() {}
    FieldSelectorDescription(Value::Field f) : field(f) {}
@@ -661,7 +661,7 @@ private:
 * This is a container for a list of FieldSelectorDescription instances. It
 * describes a complete SELECT query for dht::Value.
 */
-struct Select
+struct OPENDHT_PUBLIC Select
 {
    Select() { }
    Select(const std::string& q_str);
@@ -700,7 +700,7 @@ struct Select
        fieldSelection_ = o.as<decltype(fieldSelection_)>();
    }

-    friend std::ostream& operator<<(std::ostream& s, const dht::Select& q);
+    OPENDHT_PUBLIC friend std::ostream& operator<<(std::ostream& s, const dht::Select& q);
 private:
    std::vector<FieldSelectorDescription> fieldSelection_ {};
 };
@@ -712,7 +712,7 @@ private:
 * This is container for a list of FieldValue instances. It describes a
 * complete WHERE query for dht::Value.
 */
-struct Where
+struct OPENDHT_PUBLIC Where
 {
    Where() { }
    Where(const std::string& q_str);
@@ -802,7 +802,7 @@ struct Where
        filters_ = o.as<decltype(filters_)>();
    }

-    friend std::ostream& operator<<(std::ostream& s, const dht::Where& q);
+    OPENDHT_PUBLIC friend std::ostream& operator<<(std::ostream& s, const dht::Where& q);

 private:
    std::vector<FieldValue> filters_;
@@ -816,7 +816,7 @@ private:
 * itselves to include in the peer response to a GET operation. See
 * FieldValue.
 */
-struct Query
+struct OPENDHT_PUBLIC Query
 {
    static const std::string QUERY_PARSE_ERROR;

@@ -864,7 +864,7 @@ struct Query
        return ss.str();
    }

-    friend std::ostream& operator<<(std::ostream& s, const dht::Query& q) {
+    OPENDHT_PUBLIC friend std::ostream& operator<<(std::ostream& s, const dht::Query& q) {
        return s << "Query[" << q.select << " " << q.where << "]";
    }

@@ -880,7 +880,7 @@ struct Query
 * This structures is meant to manipulate a subset of fields normally contained
 * in Value.
 */
-struct FieldValueIndex {
+struct OPENDHT_PUBLIC FieldValueIndex {
    FieldValueIndex() {}
    FieldValueIndex(const Value& v, Select s = {});
    /**
@@ -891,7 +891,7 @@ struct FieldValueIndex {
     */
    bool containedIn(const FieldValueIndex& other) const;

-    friend std::ostream& operator<<(std::ostream& os, const FieldValueIndex& fvi);
+    OPENDHT_PUBLIC friend std::ostream& operator<<(std::ostream& os, const FieldValueIndex& fvi);

    void msgpack_unpack_fields(const std::set<Value::Field>& fields,
            const msgpack::object& o,
@@ -269,6 +269,10 @@ cdef class DhtConfig(object):
        self._config.dht_config.node_config.is_bootstrap = bootstrap
    def setNodeId(self, InfoHash id):
        self._config.dht_config.node_config.node_id = id._infohash
+    def setNetwork(self, unsigned netid):
+        self._config.dht_config.node_config.network = netid
+    def setMaintainStorage(self, bool maintain_storage):
+        self._config.dht_config.node_config.maintain_storage = maintain_storage

 cdef class DhtRunner(_WithID):
    cdef cpp.shared_ptr[cpp.DhtRunner] thisptr
@@ -280,8 +284,11 @@ cdef class DhtRunner(_WithID):
        return h
    def getNodeId(self):
        return self.thisptr.get().getNodeId().toString()
-    def bootstrap(self, str host, str port):
-        self.thisptr.get().bootstrap(host.encode(), port.encode())
+    def bootstrap(self, str host, str port=None):
+        if port:
+            self.thisptr.get().bootstrap(host.encode(), port.encode())
+        else:
+            self.thisptr.get().bootstrap(host.encode(), b'4222')
    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)
@@ -302,7 +309,7 @@ cdef class DhtRunner(_WithID):
    def disableLogging(self):
        cpp.disableLogging(self.thisptr.get()[0])
    def enableFileLogging(self, str path):
-        cpp.enableFileLogging(self.thisptr.get()[0], path)
+        cpp.enableFileLogging(self.thisptr.get()[0], path.encode())
    def isRunning(self):
        return self.thisptr.get().isRunning()
    def getStorageLog(self):
@@ -123,7 +123,9 @@ cdef extern from "opendht/callbacks.h" namespace "dht":

    cppclass Config:
        InfoHash node_id
+        uint32_t network
        bool is_bootstrap
+        bool maintain_storage
    cppclass SecureDhtConfig:
        Config node_config
        Identity id
@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2016 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 <http://www.gnu.org/licenses/>.
+
+import os, sys, time, cmd
+import subprocess
+import signal
+import argparse
+import threading
+
+import opendht as dht
+
+class NodeCluster(object):
+    nodes = []
+    node_uid = 0
+
+    @staticmethod
+    def run_node(ip4, ip6, p, bootstrap=None, is_bootstrap=False, logfile=None):
+        print("run_node", ip4, ip6, p, bootstrap, logfile)
+        n = dht.DhtRunner()
+        n.run(ipv4=ip4 if ip4 else "", ipv6=ip6 if ip6 else "", port=p, is_bootstrap=is_bootstrap)
+        if logfile:
+            n.enableFileLogging(logfile)
+        if bootstrap:
+            n.bootstrap(bootstrap[0], bootstrap[1])
+        time.sleep(.01)
+        return ((ip4, ip6, p), n, id)
+
+    @staticmethod
+    def find_ip(iface):
+        if not iface or iface == 'any':
+            return ('0.0.0.0','')
+
+        if_ip4 = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr']
+        if_ip6 = netifaces.ifaddresses(iface)[netifaces.AF_INET6][0]['addr']
+        return (if_ip4, if_ip6)
+
+    def __init__(self, iface=None, ip4=None, ip6=None, port=4000, bootstrap=None, first_bootstrap=False, logfile=None):
+        NodeCluster.iface = iface
+        self.port = port
+        ips = NodeCluster.find_ip(iface)
+        self.logfile = logfile
+        self.ip4 = ip4 if ip4 else ips[0]
+        self.ip6 = ip6 if ip6 else ips[1]
+        self.bootstrap = bootstrap
+        if bootstrap:
+            self.bootstrap = (bootstrap.hostname, str(bootstrap.port) if bootstrap.port else "4222")
+        else:
+            print("Using fallback bootstrap", self.ip4, self.port)
+            self.bootstrap = ((self.ip4, str(self.port)))
+        if first_bootstrap:
+            print("Starting bootstrap node")
+            self.nodes.append(NodeCluster.run_node(self.ip4, self.ip6, self.port, self.bootstrap, is_bootstrap=True))
+            self.bootstrap = ((self.ip4, str(self.port)))
+            self.port += 1
+        #print(self.ip4, self.ip6, self.port)
+
+    def front(self):
+        if len(self.nodes) == 0:
+            return None
+        return self.nodes[0][1]
+
+    def get(self, i=None):
+        if not self.nodes:
+            return None
+
+        if i is None:
+            l = list(self.nodes)
+            random.shuffle(l)
+            return l[0][1]
+        else:
+            return self.nodes[i][1]
+
+    def getNodeInfoById(self, id=None):
+        if id:
+            for n in self.nodes:
+                if n[1].getNodeId() == id:
+                    return n
+        return None
+
+    def launch_node(self):
+        node_logfile = (self.logfile + str(self.node_uid) + '.log') if self.logfile else None
+        n = NodeCluster.run_node(self.ip4, self.ip6, self.port, self.bootstrap, logfile=node_logfile)
+        self.nodes.append(n)
+        self.port += 1
+        self.node_uid += 1
+        return n
+
+    def end_node(self, id=None, shutdown=False, last_msg_stats=None):
+        """
+        Ends a running node.
+
+        @param id: The 40 hex chars id of the node.
+        @type  id: bytes
+
+        @return: If a node was deleted or not.
+        @rtype : boolean
+        """
+        lock = threading.Condition()
+        def shutdown_cb():
+            nonlocal lock
+            NodeCluster.Log.log('Done.')
+            with lock:
+                lock.notify()
+
+        if not self.nodes:
+            return
+        elif id:
+            n = self.getNodeInfoById(id)
+            if n:
+                if shutdown:
+                    with lock:
+                        print('Waiting for node to shutdown... ')
+                        n[1].shutdown(shutdown_cb)
+                        lock.wait()
+                    if last_msg_stats:
+                        last_msg_stats.append(self.getMessageStats())
+                n[1].join()
+                self.nodes.remove(n)
+                print(id, 'deleted !')
+                return True
+            else:
+                return False
+        else:
+            n = self.nodes.pop()
+            n[1].join()
+            return True
+
+    def replace_node(self, id=None, shutdown=False, last_msg_stats=None):
+        random.shuffle(self.nodes)
+        deleted = self.end_node(id=id, shutdown=shutdown, last_msg_stats=last_msg_stats)
+        if deleted:
+            self.launch_node()
+
+    def resize(self, n):
+        n = min(n, 500)
+        l = len(self.nodes)
+        if n == l:
+            return
+        if n > l:
+            print("Launching", n-l, "nodes", self.ip4, self.ip6)
+            for i in range(l, n):
+                self.launch_node()
+        else:
+            print("Ending", l-n, "nodes", self.ip4, self.ip6)
+            #random.shuffle(self.nodes)
+            for i in range(n, l):
+                self.end_node()
+
+    def close(self):
+    	self.resize(0)
+
+    def getMessageStats(self):
+        stats = np.array([0,0,0,0,0])
+        for n in self.nodes:
+            stats +=  np.array(n[1].getNodeMessageStats())
+        stats_list = [len(self.nodes)]
+        stats_list.extend(stats.tolist())
+        return stats_list
+
+class ClusterShell(cmd.Cmd):
+    intro = 'Welcome to the OpenDHT node cluster control. Type help or ? to list commands.\n'
+    prompt = '>> '
+    net = None
+    node = None
+    log = False
+    def __init__(self, network):
+        super(ClusterShell, self).__init__()
+        self.net = network
+    def setNode(self, node=None, num=0):
+        if node == self.node:
+            return
+        if self.node:
+            self.node.disableLogging()
+        self.node = node
+        if self.node:
+            self.prompt = '('+str(num)+') >> '
+            if self.log:
+                self.node.enableLogging()
+        else:
+            self.prompt = '>> '
+    def do_exit(self, arg):
+        self.close()
+        return True
+    def do_node(self, arg):
+        if not arg:
+            setNode()
+        else:
+            nodenum = int(arg)
+            if nodenum > len(self.net.nodes) or nodenum < 1:
+                print("Invalid node number:", nodenum, " (accepted: 1-", len(self.net.nodes), ")")
+            else:
+                self.setNode(self.net.nodes[nodenum-1][1], nodenum)
+    def do_ll(self, arg):
+        if self.node:
+            print('Node', self.node.getNodeId().decode())
+        else:
+            print(len(self.net.nodes), 'nodes running.')
+    def do_ls(self, arg):
+        if self.node:
+            print(self.node.getSearchesLog(0))
+        else:
+            print('No node selected.')
+    def do_log(self, arg):
+        if self.node:
+            self.log = not self.log
+            if self.log:
+                self.node.enableLogging()
+            else:
+                self.node.disableLogging()
+    def do_EOF(self, line):
+        self.close()
+        return True
+    def close(self):
+        if self.net:
+            self.net.close()
+            self.net = None
+
+if __name__ == '__main__':
+    import argparse
+    from urllib.parse import urlparse
+    net = None
+    try:
+        parser = argparse.ArgumentParser(description='Create a dht network of -n nodes')
+        parser.add_argument('-n', '--node-num', help='number of dht nodes to run', type=int, default=32)
+        parser.add_argument('-I', '--iface', help='local interface to bind', default='any')
+        parser.add_argument('-p', '--port', help='start of port range (port, port+node_num)', type=int, default=4000)
+        parser.add_argument('-b', '--bootstrap', help='bootstrap address')
+        parser.add_argument('-d', '--daemonize', help='daemonize process', action='store_true')
+        parser.add_argument('-l', '--log', help='log file prefix')
+        args = parser.parse_args()
+
+        if args.bootstrap:
+            args.bootstrap = urlparse('dht://'+args.bootstrap)
+
+        net = NodeCluster(iface=args.iface, port=args.port, bootstrap=args.bootstrap, logfile=args.log)
+        net.resize(args.node_num)
+        if args.daemonize:
+            import daemon, lockfile
+            #pidfile=lockfile.FileLock('/var/run/dhtcluster.'+str(args.port))
+            with daemon.DaemonContext():
+                while True:
+                    time.sleep(2)
+        else:
+            ClusterShell(net).cmdloop()
+    except Exception as e:
+        traceback.print_tb(e.__traceback__)
+        print(type(e).__name__+':', e, file=sys.stderr)
+    finally:
+        if net:
+            net.resize(0)
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 Savoir-faire Linux Inc.
+# Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; If not, see <http://www.gnu.org/licenses/>.
+
+from twisted.web import server, resource
+from twisted.internet import reactor, endpoints
+from urllib.parse import urlparse
+
+import opendht as dht
+import base64, json
+
+class DhtServer(resource.Resource):
+    isLeaf = True
+    node = dht.DhtRunner()
+
+    def __init__(self, port, bootstrap):
+        self.node.run(port=port)
+        b_url = urlparse('//'+bootstrap)
+        self.node.bootstrap(b_url.hostname, str(b_url.port) if b_url.port else '4222')
+
+    def render_GET(self, req):
+        uri = req.uri[1:]
+        h = dht.InfoHash(uri) if len(uri) == 40 else dht.InfoHash.get(uri.decode())
+        print('GET', '"'+uri.decode()+'"', h)
+        res = self.node.get(h)
+        req.setHeader(b"content-type", b"application/json")
+        return json.dumps({'{:x}'.format(v.id):{'base64':base64.b64encode(v.data).decode()} for v in res}).encode()
+
+    def render_POST(self, req):
+        uri = req.uri[1:]
+        data = req.args[b'data'][0] if b'data' in req.args else None
+        if not data and b'base64' in req.args:
+            data = base64.b64decode(req.args[b'base64'][0])
+        h = dht.InfoHash(uri) if len(uri) == 40 else dht.InfoHash.get(uri.decode())
+        print('POST', h, data)
+        req.setHeader(b"content-type", b"application/json")
+        if data:
+            self.node.put(h, dht.Value(data))
+            return json.dumps({'success':True}).encode()
+        else:
+            req.setResponseCode(400)
+            return json.dumps({'success':False, 'error':'no data parameter'}).encode()
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser(description='Launch an OpenDHT node with an HTTP control interface')
+    parser.add_argument('-p', '--port', help='OpenDHT port to bind', type=int, default=4222)
+    parser.add_argument('-hp', '--http-port', help='HTTP port to bind', type=int, default=8080)
+    parser.add_argument('-b', '--bootstrap', help='bootstrap address', default="bootstrap.ring.cx:4222")
+    args = parser.parse_args()
+    endpoints.serverFromString(reactor, "tcp:"+str(args.http_port)).listen(server.Site(DhtServer(args.port, args.bootstrap)))
+    reactor.run()
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2016 Savoir-faire Linux Inc.
+# Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; If not, see <http://www.gnu.org/licenses/>.
+
+import time
+import argparse
+import time
+import asyncio
+from datetime import datetime
+
+import opendht as dht
+
+parser = argparse.ArgumentParser(description='Create a dht network of -n nodes')
+parser.add_argument('-b', '--bootstrap', help='bootstrap address', default='bootstrap.ring.cx')
+parser.add_argument('-n', '--num-ops', help='number of concurrent operations on the DHT', type=int, default=8)
+parser.add_argument('-p', '--period', help='duration between each test (seconds)', type=int, default=60)
+parser.add_argument('-t', '--timeout', help='timeout for a test to complete (seconds)', type=float, default=15)
+args = parser.parse_args()
+
+node1 = dht.DhtRunner()
+node1.run()
+
+node2 = dht.DhtRunner()
+node2.run()
+
+node1.bootstrap(args.bootstrap)
+node2.bootstrap(args.bootstrap)
+loop = asyncio.get_event_loop()
+
+pending_tests = {}
+keys = [dht.InfoHash.getRandom() for _ in range(args.num_ops)]
+
+def listen_cb(key, val):
+    global pending_tests
+    kstr = str(key)
+    if kstr in pending_tests:
+        if pending_tests[kstr]['v'].id == val.id:
+            pending_tests.pop(kstr, None)
+        else:
+            print("Expected vid", val.id, "got", pending_tests[kstr]['v'].id)
+    return True
+
+def listen(key):
+    node1.listen(key, lambda v: loop.call_soon_threadsafe(listen_cb, key, v))
+
+for key in keys:
+    listen(key)
+
+next_test = time.time()
+while True:
+    start = time.time()
+    #print(datetime.fromtimestamp(start).strftime('%Y-%m-%d %H:%M:%S'), 'Test started')
+    for key in keys:
+        val = dht.Value(str(dht.InfoHash.getRandom()).encode())
+        pending_tests[str(key)] = {'v':val, 'c':0}
+        node2.put(key, val, lambda ok, nodes: ok)
+    while len(pending_tests):
+        loop.stop()
+        loop.run_forever()
+        time.sleep(1)
+        if time.time()-start > args.timeout:
+            print('Test timeout !')
+            exit(1)
+
+    end = time.time()
+    print(datetime.fromtimestamp(end).strftime('%Y-%m-%d %H:%M:%S'),
+          'Test completed successfully in', end-start)
+    next_test += args.period
+    if next_test > end:
+        time.sleep(next_test-end)
@@ -17,6 +17,7 @@

 import opendht as dht
 import time
+import asyncio

 ping_node = dht.DhtRunner()
 ping_node.run(port = 5632)
@@ -35,19 +36,28 @@ loc_pong = dht.InfoHash.get(str(loc_ping))
 i = 0
 MAX = 8192

-def pong(node, h):
+loop = asyncio.get_event_loop()
+
+def done(h, ok):
+	print(h, "over", ok)
+
+def ping(node, h):
 	global i
-	print("got ping", h, i)
-	time.sleep(0.0075)
+	time.sleep(0.0075) 
 	i += 1
 	if i < MAX:
-		node.put(h, dht.Value(b"hey"), lambda ok, nodes: print("over", ok))
+		node.put(h, dht.Value(b"hey"), lambda ok, nodes: done(node.getNodeId().decode(), ok))
+	else:
+		loop.stop()
+
+def pong(node, h):
+	print(node.getNodeId().decode(), "got ping", h, i)
+	loop.call_soon_threadsafe(ping, node, h);
 	return True

 ping_node.listen(loc_ping, lambda v: pong(pong_node, loc_pong))
 pong_node.listen(loc_pong, lambda v: pong(ping_node, loc_ping))

-pong_node.put(loc_pong, dht.Value(b"hey"), lambda ok, nodes: print("i over", ok))
+ping(pong_node, loc_ping)

-while (i < MAX):
-	time.sleep(1)
+loop.run_forever()
@@ -18,7 +18,7 @@
 import time, sys, os
 from pprint import pprint
 from math import cos, sin, pi
-from urllib import request
+import urllib3
 import gzip
 import asyncio

@@ -35,6 +35,8 @@ from mpl_toolkits.basemap import Basemap

 import GeoIP

+http = urllib3.PoolManager()
+
 done = 0
 all_nodes = NodeSet()

@@ -72,7 +74,7 @@ def check_dl(fname, url):
    if os.path.isfile(fname):
        return
    print('downloading', url)
-    ghandle = gzip.GzipFile(fileobj=request.urlopen(url))
+    ghandle = gzip.GzipFile(fileobj=http.request('GET', url, headers={'User-Agent': 'Mozilla/5.0'}, preload_content=False))
    with open(fname, 'wb') as out:
        for line in ghandle:
            out.write(line)
@@ -21,7 +21,8 @@ libopendht_la_SOURCES = \
        securedht.cpp \
        dhtrunner.cpp \
        default_types.cpp \
-        indexation/pht.cpp
+        indexation/pht.cpp \
+        log.cpp

 if WIN32
 libopendht_la_SOURCES += rng.cpp
@@ -29,11 +30,13 @@ endif

 nobase_include_HEADERS = \
        ../include/opendht.h \
+        ../include/opendht/def.h \
        ../include/opendht/dht.h \
        ../include/opendht/callbacks.h \
        ../include/opendht/node_cache.h \
        ../include/opendht/routing_table.h \
        ../include/opendht/network_engine.h \
+        ../include/opendht/net.h \
        ../include/opendht/scheduler.h \
        ../include/opendht/rate_limiter.h \
        ../include/opendht/utils.h \
@@ -55,4 +55,17 @@ bindDoneCbSimple(DoneCallbackSimpleRaw raw_cb, void* user_data) {
    };
 }

-}
+std::string
+NodeStats::toString() const
+{
+    std::stringstream ss;
+    ss << "Known nodes: " << good_nodes << " good, " << dubious_nodes << " dubious, " << incoming_nodes << " incoming." << std::endl;
+    if (table_depth > 1) {
+        ss << "Routing table depth: " << table_depth << std::endl;
+        unsigned long tot_nodes = 8 * std::exp2(table_depth);
+        ss << "Network size estimation: " << tot_nodes << " nodes" << std::endl;
+    }
+    return ss.str();
+}
+
+}
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -517,6 +517,16 @@ PublicKey::getId() const
    return id;
 }

+PkId
+PublicKey::getLongId() const
+{
+    PkId h;
+    size_t sz = h.size();
+    if (gnutls_pubkey_get_key_id(pk, GNUTLS_KEYID_USE_SHA256, h.data(), &sz) != GNUTLS_E_SUCCESS || sz != h.size())
+        return {};
+    return h;
+}
+
 Certificate::Certificate(const Blob& certData) : cert(nullptr)
 {
    unpack(certData.data(), certData.size());
@@ -621,6 +631,18 @@ Certificate::getId() const
    return id;
 }

+PkId
+Certificate::getLongId() const
+{
+    if (not cert)
+        return {};
+    PkId id;
+    size_t sz = id.size();
+    if (gnutls_x509_crt_get_key_id(cert, GNUTLS_KEYID_USE_SHA256, id.data(), &sz) != GNUTLS_E_SUCCESS || sz != id.size())
+        throw CryptoException("Can't get certificate public key ID.");
+    return id;
+}
+
 static std::string
 getDN(gnutls_x509_crt_t cert, const char* oid, bool issuer = false)
 {
@@ -700,7 +722,20 @@ bool
 Certificate::isCA() const
 {
    unsigned critical;
-    return gnutls_x509_crt_get_ca_status(cert, &critical) > 0;
+    bool ca_flag = gnutls_x509_crt_get_ca_status(cert, &critical) > 0;
+    if (ca_flag) {
+        unsigned usage;
+        auto ret = gnutls_x509_crt_get_key_usage(cert, &usage, &critical);
+        /* Conforming CAs MUST include this extension in certificates that
+           contain public keys that are used to validate digital signatures on
+           other public key certificates or CRLs. */
+        if (ret < 0)
+            return false;
+        if (not critical)
+            return true;
+        return usage & GNUTLS_KEY_KEY_CERT_SIGN;
+    }
+    return false;
 }

 std::string
@@ -725,6 +760,51 @@ Certificate::toString(bool chain) const
    return ss.str();
 }

+std::string
+Certificate::print() const
+{
+    gnutls_datum_t out;
+    gnutls_x509_crt_print(cert, GNUTLS_CRT_PRINT_FULL, &out);
+    std::string ret(out.data, out.data+out.size);
+    gnutls_free(out.data);
+    return ret;
+}
+
+void
+Certificate::revoke(const PrivateKey& key, const Certificate& to_revoke)
+{
+    if (revocation_lists.empty())
+        revocation_lists.emplace(std::make_shared<RevocationList>());
+    auto& list = *(*revocation_lists.begin());
+    list.revoke(to_revoke);
+    list.sign(key, *this);
+}
+
+void
+Certificate::addRevocationList(RevocationList&& list)
+{
+    addRevocationList(std::make_shared<RevocationList>(std::forward<RevocationList>(list)));
+}
+
+void
+Certificate::addRevocationList(std::shared_ptr<RevocationList> list)
+{
+    if (revocation_lists.find(list) != revocation_lists.end())
+        return; // Already in the list
+    if (not list->isSignedBy(*this))
+        throw CryptoException("CRL is not signed by this certificate");
+    revocation_lists.emplace(std::move(list));
+}
+
+std::chrono::system_clock::time_point
+Certificate::getExpiration() const
+{
+    auto t = gnutls_x509_crt_get_expiration_time(cert);
+    if (t == (time_t)-1)
+        return std::chrono::system_clock::time_point::min();
+    return std::chrono::system_clock::from_time_t(t);
+}
+
 PrivateKey
 PrivateKey::generate(unsigned key_length)
 {
@@ -739,6 +819,20 @@ PrivateKey::generate(unsigned key_length)
    return PrivateKey{key};
 }

+PrivateKey
+PrivateKey::generateEC()
+{
+    gnutls_x509_privkey_t key;
+    if (gnutls_x509_privkey_init(&key) != GNUTLS_E_SUCCESS)
+        throw CryptoException("Can't initialize private key.");
+    int err = gnutls_x509_privkey_generate(key, GNUTLS_PK_EC, gnutls_sec_param_to_pk_bits(GNUTLS_PK_EC, GNUTLS_SEC_PARAM_ULTRA), 0);
+    if (err != GNUTLS_E_SUCCESS) {
+        gnutls_x509_privkey_deinit(key);
+        throw CryptoException(std::string("Can't generate EC key pair: ") + gnutls_strerror(err));
+    }
+    return PrivateKey{key};
+}
+
 Identity
 generateIdentity(const std::string& name, crypto::Identity ca, unsigned key_length, bool is_ca)
 {
@@ -795,6 +889,10 @@ Certificate::generate(const PrivateKey& key, const std::string& name, Identity c
    gnutls_x509_crt_set_key_usage(cert, key_usage);

    if (ca.first && ca.second) {
+        if (not ca.second->isCA()) {
+            // Signing certificate must be CA.
+            return {};
+        }
        //if (gnutls_x509_crt_sign2(cert, ca.second->cert, ca.first->x509_key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
        if (gnutls_x509_crt_privkey_sign(cert, ca.second->cert, ca.first->key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
            std::cerr << "Error when signing certificate" << std::endl;
@@ -812,5 +910,231 @@ Certificate::generate(const PrivateKey& key, const std::string& name, Identity c
    return ret;
 }

+std::vector<std::shared_ptr<RevocationList>>
+Certificate::getRevocationLists() const
+{
+    std::vector<std::shared_ptr<RevocationList>> ret;
+    ret.reserve(revocation_lists.size());
+    for (const auto& crl : revocation_lists)
+        ret.emplace_back(crl);
+    return ret;
+}
+
+RevocationList::RevocationList()
+{
+    gnutls_x509_crl_init(&crl);
+}
+
+RevocationList::RevocationList(const Blob& b)
+{
+    gnutls_x509_crl_init(&crl);
+    try {
+        unpack(b.data(), b.size());
+    } catch (const std::exception& e) {
+        gnutls_x509_crl_deinit(crl);
+        crl = nullptr;
+        throw e;
+    }
+}
+
+RevocationList::~RevocationList()
+{
+    if (crl) {
+        gnutls_x509_crl_deinit(crl);
+        crl = nullptr;
+    }
+}
+
+void
+RevocationList::pack(Blob& b) const
+{
+    gnutls_datum_t gdat {nullptr, 0};
+    if (auto err = gnutls_x509_crl_export2(crl, GNUTLS_X509_FMT_DER, &gdat)) {
+        throw CryptoException(std::string("Can't export CRL: ") + gnutls_strerror(err));
+    }
+    b.insert(b.end(), gdat.data, gdat.data + gdat.size);
+}
+
+void
+RevocationList::unpack(const uint8_t* dat, size_t dat_size)
+{
+    if (std::numeric_limits<unsigned>::max() < dat_size)
+        throw CryptoException("Can't load CRL: too large!");
+    const gnutls_datum_t gdat {(uint8_t*)dat, (unsigned)dat_size};
+    if (auto err_pem = gnutls_x509_crl_import(crl, &gdat, GNUTLS_X509_FMT_PEM))
+        if (auto err_der = gnutls_x509_crl_import(crl, &gdat, GNUTLS_X509_FMT_DER)) {
+            throw CryptoException(std::string("Can't load CRL: PEM: ") + gnutls_strerror(err_pem)
+                                                           + " DER: "  + gnutls_strerror(err_der));
+        }
+}
+
+void
+RevocationList::msgpack_unpack(msgpack::object o)
+{
+    try {
+        if (o.type == msgpack::type::BIN)
+            unpack((const uint8_t*)o.via.bin.ptr, o.via.bin.size);
+        else {
+            Blob dat = unpackBlob(o);
+            unpack(dat.data(), dat.size());
+        }
+    } catch (...) {
+        throw msgpack::type_error();
+    }
+}
+
+bool
+RevocationList::isRevoked(const Certificate& crt) const
+{
+    auto ret = gnutls_x509_crt_check_revocation(crt.cert, &crl, 1);
+    if (ret < 0)
+        throw CryptoException(std::string("Can't check certificate revocation status: ") + gnutls_strerror(ret));
+    return ret != 0;
+}
+
+void
+RevocationList::revoke(const Certificate& crt, std::chrono::system_clock::time_point t)
+{
+    if (t == time_point::min())
+        t = clock::now();
+    if (auto err = gnutls_x509_crl_set_crt(crl, crt.cert, std::chrono::system_clock::to_time_t(t)))
+        throw CryptoException(std::string("Can't revoke certificate: ") + gnutls_strerror(err));
+}
+
+static std::string
+getCRLIssuerDN(gnutls_x509_crl_t cert, const char* oid)
+{
+    std::string dn;
+    dn.resize(512);
+    size_t dn_sz = dn.size();
+    int ret = gnutls_x509_crl_get_issuer_dn_by_oid(cert, oid, 0, 0, &(*dn.begin()), &dn_sz);
+    if (ret != GNUTLS_E_SUCCESS)
+        return {};  
+    dn.resize(dn_sz);
+    return dn;
+}
+
+std::string
+RevocationList::getIssuerName() const
+{
+    return getCRLIssuerDN(crl, GNUTLS_OID_X520_COMMON_NAME);
+}
+
+/** Read CRL issuer User ID (UID) */
+std::string
+RevocationList::getIssuerUID() const
+{
+    return getCRLIssuerDN(crl, GNUTLS_OID_LDAP_UID);
+}
+
+RevocationList::time_point
+RevocationList::getNextUpdateTime() const
+{
+    auto t = gnutls_x509_crl_get_next_update(crl);
+    if (t == (time_t)-1)
+        return std::chrono::system_clock::time_point::min();
+    return std::chrono::system_clock::from_time_t(t);
+}
+
+RevocationList::time_point
+RevocationList::getUpdateTime() const
+{
+    auto t = gnutls_x509_crl_get_this_update(crl);
+    if (t == (time_t)-1)
+        return std::chrono::system_clock::time_point::min();
+    return std::chrono::system_clock::from_time_t(t);
+}
+
+enum class Endian : uint32_t
+{
+    LITTLE = 0,
+    BIG = 1
+};
+
+template <typename T>
+T endian(T w, Endian endian = Endian::BIG)
+{
+    // this gets optimized out into if (endian == host_endian) return w;
+    union { uint64_t quad; uint32_t islittle; } t;
+    t.quad = 1;
+    if (t.islittle ^ (uint32_t)endian) return w;
+    T r = 0;
+
+    // decent compilers will unroll this (gcc)
+    // or even convert straight into single bswap (clang)
+    for (size_t i = 0; i < sizeof(r); i++) {
+        r <<= 8;
+        r |= w & 0xff;
+        w >>= 8;
+    }
+    return r;
+}
+
+void
+RevocationList::sign(const PrivateKey& key, const Certificate& ca, duration validity)
+{
+    if (auto err = gnutls_x509_crl_set_version(crl, 2))
+        throw CryptoException(std::string("Can't set CRL version: ") + gnutls_strerror(err));
+    auto now = std::chrono::system_clock::now();
+    auto next_update = (validity == duration{}) ? ca.getExpiration() : now + validity;
+    if (auto err = gnutls_x509_crl_set_this_update(crl, std::chrono::system_clock::to_time_t(now)))
+        throw CryptoException(std::string("Can't set CRL update time: ") + gnutls_strerror(err));
+    if (auto err = gnutls_x509_crl_set_next_update(crl, std::chrono::system_clock::to_time_t(next_update)))
+        throw CryptoException(std::string("Can't set CRL next update time: ") + gnutls_strerror(err));
+    uint64_t number {0};
+    size_t number_sz {sizeof(number)};
+    unsigned critical {0};
+    gnutls_x509_crl_get_number(crl, &number, &number_sz, &critical);
+    if (number == 0) {
+        // initialize to a random number
+        number_sz = sizeof(number);
+        random_device rdev;
+        std::generate_n((uint8_t*)&number, sizeof(number), std::bind(rand_byte, std::ref(rdev)));
+    } else
+        number = endian(endian(number) + 1);
+    if (auto err = gnutls_x509_crl_set_number(crl, &number, sizeof(number)))
+        throw CryptoException(std::string("Can't set CRL update time: ") + gnutls_strerror(err));   
+    if (auto err = gnutls_x509_crl_sign2(crl, ca.cert, key.x509_key, GNUTLS_DIG_SHA512, 0))
+        throw CryptoException(std::string("Can't sign certificate revocation list: ") + gnutls_strerror(err));
+    // to be able to actually use the CRL we need to serialize/deserialize it
+    auto packed = getPacked();
+    unpack(packed.data(), packed.size());
+}
+
+bool
+RevocationList::isSignedBy(const Certificate& issuer) const
+{
+    unsigned result {0};
+    auto err = gnutls_x509_crl_verify(crl, &issuer.cert, 1, 0, &result);
+    if (err < 0) {
+        //std::cout << "Can't verify CRL: " << err << " " << result << " " << gnutls_strerror(err) << std::endl;
+        return false;
+    }
+    return result == 0;
+}
+
+
+Blob
+RevocationList::getNumber() const
+{
+    Blob number(20);
+    size_t number_sz {number.size()};
+    unsigned critical {0};
+    gnutls_x509_crl_get_number(crl, number.data(), &number_sz, &critical);
+    if (number_sz != number.size())
+        number.resize(number_sz);
+    return number;
+}
+
+std::string
+RevocationList::toString() const
+{
+    gnutls_datum_t out;
+    gnutls_x509_crl_print(crl, GNUTLS_CRT_PRINT_FULL, &out);
+    std::string ret(out.data, out.data+out.size);
+    gnutls_free(out.data);
+    return ret;
+}
+
 }
 }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -233,11 +233,27 @@ DhtRunner::importValues(const std::vector<ValuesExport>& values) {
    dht_->importValues(values);
 }

-int
+unsigned
 DhtRunner::getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return, unsigned *incoming_return) const
 {
    std::lock_guard<std::mutex> lck(dht_mtx);
-    return dht_->getNodesStats(af, good_return, dubious_return, cached_return, incoming_return);
+    const auto stats = dht_->getNodesStats(af);
+    if (good_return)
+        *good_return = stats.good_nodes;
+    if (dubious_return)
+        *dubious_return = stats.dubious_nodes;
+    if (cached_return)
+        *cached_return = stats.cached_nodes;
+    if (incoming_return)
+        *incoming_return = stats.incoming_nodes;
+    return stats.good_nodes + stats.dubious_nodes;
+}
+
+NodeStats
+DhtRunner::getNodesStats(sa_family_t af) const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getNodesStats(af);
 }

 std::vector<unsigned>
@@ -348,7 +364,7 @@ DhtRunner::loop_()
            // We have lost connection with the DHT.  Try to recover using bootstrap nodes.
            std::unique_lock<std::mutex> lck(bootstrap_mtx);
            bootstrap_nodes = bootstrap_nodes_all;
-            tryBootstrapCoutinuously();
+            tryBootstrapContinuously();
        } else {
            std::unique_lock<std::mutex> lck(bootstrap_mtx);
            bootstrap_nodes.clear();
@@ -618,7 +634,7 @@ DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, Done
 }

 void
-DhtRunner::tryBootstrapCoutinuously()
+DhtRunner::tryBootstrapContinuously()
 {
    if (bootstrap_thread.joinable()) {
        if (bootstraping)
@@ -707,7 +723,7 @@ DhtRunner::bootstrap(const std::string& host, const std::string& service)
    std::lock_guard<std::mutex> lck(bootstrap_mtx);
    bootstrap_nodes_all.emplace_back(host, service);
    bootstrap_nodes.emplace_back(host, service);
-    tryBootstrapCoutinuously();
+    tryBootstrapContinuously();
 }

 void
@@ -1,3 +1,23 @@
+/*
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <simon.desaulniers@savoirfairelinux.com>
+ *              Nicolas Reynaud <nicolas.reynaud@savoirfairelinux.com>
+ *
+ *  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 <http://www.gnu.org/licenses/>.
+ */
+
 #include "indexation/pht.h"
 #include "rng.h"

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -0,0 +1,87 @@
+/*
+ *  Copyright (C) 2014-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
+ *  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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#include "log.h"
+
+namespace dht {
+namespace log {
+
+/**
+ * Print va_list to std::ostream (used for logging).
+ */
+void
+printLog(std::ostream& s, char const *m, va_list args) {
+    // print log to buffer
+    std::array<char, 8192> buffer;
+    int ret = vsnprintf(buffer.data(), buffer.size(), m, args);
+    if (ret < 0)
+        return;
+
+    // write timestamp
+    using namespace std::chrono;
+    using log_precision = microseconds;
+    constexpr auto den = log_precision::period::den;
+    auto micro = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
+    s << "[" << std::setfill('0') << std::setw(6) << micro / den << "."
+      << std::setfill('0') << std::setw(6) << micro % den << "]" << " ";
+
+    // write log
+    s.write(buffer.data(), std::min((size_t) ret, buffer.size()));
+    if ((size_t) ret >= buffer.size())
+        s << "[[TRUNCATED]]";
+    s << std::endl;
+}
+
+void
+enableLogging(dht::DhtRunner &dht) {
+    dht.setLoggers(
+        [](char const *m, va_list args) {
+            std::cerr << red;
+            printLog(std::cerr, m, args);
+            std::cerr << def;
+        },
+        [](char const *m, va_list args) {
+            std::cout << yellow;
+            printLog(std::cout, m, args);
+            std::cout << def;
+        },
+        [](char const *m, va_list args) { printLog(std::cout, m, args); }
+    );
+}
+
+void
+enableFileLogging(dht::DhtRunner &dht, const std::string &path) {
+    auto logfile = std::make_shared<std::fstream>();
+    logfile->open(path, std::ios::out);
+
+    dht.setLoggers(
+        [=](char const *m, va_list args) { printLog(*logfile, m, args); },
+        [=](char const *m, va_list args) { printLog(*logfile, m, args); },
+        [=](char const *m, va_list args) { printLog(*logfile, m, args); }
+    );
+}
+
+void
+disableLogging(dht::DhtRunner &dht) {
+    dht.setLoggers(dht::NOLOG, dht::NOLOG, dht::NOLOG);
+}
+
+}
+}
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -26,6 +26,7 @@
 #include <msgpack.hpp>

 namespace dht {
+namespace net {

 const std::string DhtProtocolException::GET_NO_INFOHASH {"Get_values with no info_hash"};
 const std::string DhtProtocolException::LISTEN_NO_INFOHASH {"Listen with no info_hash"};
@@ -40,15 +41,15 @@ constexpr std::chrono::seconds NetworkEngine::RX_MAX_PACKET_TIME;
 constexpr std::chrono::seconds NetworkEngine::RX_TIMEOUT;

 const std::string NetworkEngine::my_v {"RNG1"};
-const constexpr uint16_t NetworkEngine::TransId::INVALID;
+const constexpr uint16_t TransId::INVALID;
 std::mt19937 NetworkEngine::rd_device {dht::crypto::random_device{}()};

-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::PING = {"pn"};
-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::FIND_NODE = {"fn"};
-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::GET_VALUES = {"gt"};
-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::ANNOUNCE_VALUES = {"pt"};
-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::REFRESH = {"rf"};
-const NetworkEngine::TransPrefix NetworkEngine::TransPrefix::LISTEN = {"lt"};
+const TransPrefix TransPrefix::PING = {"pn"};
+const TransPrefix TransPrefix::FIND_NODE = {"fn"};
+const TransPrefix TransPrefix::GET_VALUES = {"gt"};
+const TransPrefix TransPrefix::ANNOUNCE_VALUES = {"pt"};
+const TransPrefix TransPrefix::REFRESH = {"rf"};
+const TransPrefix TransPrefix::LISTEN = {"lt"};
 constexpr long unsigned NetworkEngine::MAX_REQUESTS_PER_SEC;

 static const uint8_t v4prefix[16] = {
@@ -80,7 +81,9 @@ struct ParsedMessage {
    /* target id around which to find nodes */
    InfoHash target;
    /* transaction id */
-    NetworkEngine::TransId tid;
+    TransId tid;
+    /* tid for packets going through request socket */
+    TransId socket_id;
    /* security token */
    Blob token;
    /* the value id (announce confirmation) */
@@ -89,11 +92,11 @@ struct ParsedMessage {
    time_point created { time_point::max() };
    /* IPv4 nodes in response to a 'find' request */
    Blob nodes4_raw, nodes6_raw;
-    std::vector<std::shared_ptr<Node>> nodes4, nodes6;
+    std::vector<Sp<Node>> nodes4, nodes6;
    /* values to store or retreive request */
-    std::vector<std::shared_ptr<Value>> values;
+    std::vector<Sp<Value>> values;
    /* index for fields values */
-    std::vector<std::shared_ptr<FieldValueIndex>> fields;
+    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;
@@ -120,7 +123,7 @@ struct NetworkEngine::PartialMessage {
 };

 std::vector<Blob>
-serializeValues(const std::vector<std::shared_ptr<Value>>& st)
+serializeValues(const std::vector<Sp<Value>>& st)
 {
    std::vector<Blob> svals;
    svals.reserve(st.size());
@@ -156,15 +159,14 @@ NetworkEngine::~NetworkEngine() {
 }

 void
-NetworkEngine::tellListener(std::shared_ptr<Node> node, uint16_t rid, const InfoHash& hash, want_t want,
-        const Blob& ntoken, std::vector<std::shared_ptr<Node>>&& nodes,
-        std::vector<std::shared_ptr<Node>>&& nodes6, std::vector<std::shared_ptr<Value>>&& values,
+NetworkEngine::tellListener(Sp<Node> node, uint32_t socket_id, const InfoHash& hash, want_t want,
+        const Blob& ntoken, std::vector<Sp<Node>>&& nodes,
+        std::vector<Sp<Node>>&& nodes6, std::vector<Sp<Value>>&& values,
        const Query& query)
 {
    auto nnodes = bufferNodes(node->getFamily(), hash, want, nodes, nodes6);
    try {
-        sendNodesValues(node->addr, TransId {TransPrefix::GET_VALUES, (uint16_t)rid}, nnodes.first, nnodes.second,
-                values, query, ntoken);
+        sendNodesValues(node->addr, TransId((char*)&socket_id, 4), nnodes.first, nnodes.second, values, query, ntoken);
    } catch (const std::overflow_error& e) {
        DHT_LOG.e("Can't send value: buffer not large enough !");
    }
@@ -185,11 +187,29 @@ NetworkEngine::isRunning(sa_family_t af) const
    }
 }

+Sp<Socket>
+NetworkEngine::openSocket(const Sp<Node>& node, TransPrefix tp, SocketCb&& cb)
+{
+    auto tid = TransId {tp, getNewTid()};
+    auto s = opened_sockets.emplace(tid, std::make_shared<Socket>(node, tid, cb));
+    if (not s.second)
+        DHT_LOG.e(node->id, "[node %s] socket (tid: %d) already opened!", node->id.toString().c_str(), tid.toInt());
+    return s.first->second;
+}
+
 void
-NetworkEngine::cancelRequest(std::shared_ptr<Request>& req)
+NetworkEngine::closeSocket(Sp<Socket> socket)
+{
+    if (socket)
+        opened_sockets.erase(socket->id);
+}
+
+void
+NetworkEngine::cancelRequest(Sp<Request>& req)
 {
    if (req) {
        req->cancel();
+        closeSocket(req->socket);
        requests.erase(req->tid);
    }
 }
@@ -209,7 +229,7 @@ NetworkEngine::connectivityChanged(sa_family_t af)
 }

 void
-NetworkEngine::requestStep(std::shared_ptr<Request> sreq)
+NetworkEngine::requestStep(Sp<Request> sreq)
 {
    auto& req = *sreq;
    if (not req.pending()) {
@@ -246,7 +266,7 @@ NetworkEngine::requestStep(std::shared_ptr<Request> sreq)
 * be made before the request expires.
 */
 void
-NetworkEngine::sendRequest(std::shared_ptr<Request>& request)
+NetworkEngine::sendRequest(Sp<Request>& request)
 {
    request->start = scheduler.time();
    auto e = requests.emplace(request->tid, request);
@@ -255,7 +275,7 @@ NetworkEngine::sendRequest(std::shared_ptr<Request>& request)
        // Try to handle this scenario as well as we can
        e.first->second->setExpired();
        e.first->second = request;
-        DHT_LOG.e(request->node->id, "Request already existed (tid: %d)!", request->tid);
+        DHT_LOG.e(request->node->id, "Request already existed (tid: %d)!", request->tid.getTid());
    }
    request->node->requested(request);
    requestStep(request);
@@ -321,7 +341,7 @@ NetworkEngine::isMartian(const SockAddr& addr)
 /* The internal blacklist is an LRU cache of nodes that have sent
   incorrect messages. */
 void
-NetworkEngine::blacklistNode(const std::shared_ptr<Node>& n)
+NetworkEngine::blacklistNode(const Sp<Node>& n)
 {
    n->setExpired();
    for (auto rit = requests.begin(); rit != requests.end();) {
@@ -435,19 +455,22 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
    const auto& now = scheduler.time();

    if (msg->type == MessageType::Error or msg->type == MessageType::Reply) {
-        auto reqp = requests.find(msg->tid.getTid());
-        if (reqp == requests.end()) {
+        /* either response for a request or data for an opened socket */
+        auto req_it = requests.find(msg->tid);
+        auto rsocket_it = opened_sockets.end();
+        if (req_it == requests.end())
+            rsocket_it = opened_sockets.find(msg->tid);
+        if (req_it == requests.end() and rsocket_it == opened_sockets.end())
            throw DhtProtocolException {DhtProtocolException::UNKNOWN_TID, "Can't find transaction", msg->id};
-        }
-        auto req = reqp->second;
-        auto node = req->node;
+
+        auto req = req_it != requests.end() ? req_it->second : nullptr;
+        auto rsocket = rsocket_it != opened_sockets.end() ? rsocket_it->second : nullptr;
+
+        auto& node = req ? req->node : rsocket->node;
        if (node->id != msg->id) {
-            bool unknown_node = node->id == zeroes;
-            node = cache.getNode(msg->id, from, now, true);
-            if (unknown_node) {
-                // received reply to a message sent when we didn't know the node ID.
-                req->node = node;
-            } else {
+            if (node->id == zeroes) // received reply to a message sent when we didn't know the node ID.
+                node = cache.getNode(msg->id, from, now, true);
+            else {
                // received reply from unexpected node
                node->received(now, req);
                onNewNode(node, 2);
@@ -456,14 +479,15 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
            }
        } else
            node->update(from);
+
        node->received(now, req);

        onNewNode(node, 2);
        onReportedAddr(msg->id, msg->addr);

-        if (req->cancelled() or req->expired() or (req->completed() and not req->persistent)) {
+        if (req and (req->cancelled() or req->expired() or req->completed())) {
            DHT_LOG.w(node->id, "[node %s] response to expired, cancelled or completed request", node->toString().c_str());
-            requests.erase(reqp);
+            requests.erase(req_it);
            return;
        }

@@ -474,8 +498,8 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
                (msg->error_code == DhtProtocolException::UNAUTHORIZED and (msg->tid.matches(TransPrefix::ANNOUNCE_VALUES)
                                                                         or msg->tid.matches(TransPrefix::LISTEN)))))
            {
-                req->last_try = TIME_INVALID;
-                req->reply_time = TIME_INVALID;
+                req->last_try = time_point::min();
+                req->reply_time = time_point::min();
                onError(req, DhtProtocolException {msg->error_code});
            } else {
                DHT_LOG.w(msg->id, "[node %s %s] received unknown error message %u",
@@ -484,17 +508,21 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
            break;
        }
        case MessageType::Reply:
-            if (msg->type == MessageType::AnnounceValue or msg->type == MessageType::Listen)
-                req->node->authSuccess();
+         if (req) { /* request reply */
+             if (msg->type == MessageType::AnnounceValue or msg->type == MessageType::Listen)
+                 req->node->authSuccess();

-            // erase before calling callback to make sure iterator is still valid
-            if (not req->persistent)
-                requests.erase(reqp);
-            req->reply_time = scheduler.time();
+             // erase before calling callback to make sure iterator is still valid
+             requests.erase(req_it);
+             req->reply_time = scheduler.time();

-            deserializeNodes(*msg);
-            req->setDone(std::move(*msg));
-            break;
+             deserializeNodes(*msg);
+             req->setDone(std::move(*msg));
+             break;
+         } else { /* request socket data */
+             deserializeNodes(*msg);
+             rsocket->on_receive(rsocket->node, std::move(*msg));
+         }
        default:
            break;
        }
@@ -548,7 +576,9 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
            case MessageType::Listen: {
                DHT_LOG.d(msg->info_hash, node->id, "[node %s] got 'listen' request for %s", node->toString().c_str(), msg->info_hash.toString().c_str());
                ++in_stats.listen;
-                RequestAnswer answer = onListen(node, msg->info_hash, msg->token, msg->tid.getTid(), std::move(msg->query));
+                /* TODO: backward compatibility check to remove in a few versions (see ::sendListen doc) */
+                auto socket_id = msg->socket_id.getTid() ? msg->socket_id : TransId { TransPrefix::GET_VALUES, msg->tid.getTid() };
+                RequestAnswer answer = onListen(node, msg->info_hash, msg->token, socket_id.toInt(), std::move(msg->query));
                sendListenConfirmation(from, msg->tid);
                break;
            }
@@ -564,7 +594,7 @@ NetworkEngine::process(std::unique_ptr<ParsedMessage>&& msg, const SockAddr& fro
 }

 void
-packToken(msgpack::packer<msgpack::sbuffer>& pk, Blob token)
+packToken(msgpack::packer<msgpack::sbuffer>& pk, const Blob& token)
 {
    pk.pack_bin(token.size());
    pk.pack_bin_body((char*)token.data(), token.size());
@@ -601,8 +631,8 @@ NetworkEngine::send(const char *buf, size_t len, int flags, const SockAddr& addr
    return sendto(s, buf, len, flags, (const sockaddr*)&addr.first, addr.second);
 }

-std::shared_ptr<Request>
-NetworkEngine::sendPing(std::shared_ptr<Node> node, RequestCb on_done, RequestExpiredCb on_expired) {
+Sp<Request>
+NetworkEngine::sendPing(Sp<Node> node, RequestCb&& on_done, RequestExpiredCb&& on_expired) {
    auto tid = TransId {TransPrefix::PING, getNewTid()};
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
@@ -621,7 +651,7 @@ NetworkEngine::sendPing(std::shared_ptr<Node> node, RequestCb on_done, RequestEx
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), node, std::move(b),
+    Sp<Request> req(new Request {tid, node, std::move(b),
        [=](const Request& req_status, ParsedMessage&&) {
            DHT_LOG.d(req_status.node->id, "[node %s] got pong !", req_status.node->toString().c_str());
            if (on_done) {
@@ -660,9 +690,9 @@ NetworkEngine::sendPong(const SockAddr& addr, TransId tid) {
    send(buffer.data(), buffer.size(), 0, addr);
 }

-std::shared_ptr<Request>
-NetworkEngine::sendFindNode(std::shared_ptr<Node> n, const InfoHash& target, want_t want,
-        RequestCb on_done, RequestExpiredCb on_expired) {
+Sp<Request>
+NetworkEngine::sendFindNode(Sp<Node> n, const InfoHash& target, want_t want,
+        RequestCb&& on_done, RequestExpiredCb&& on_expired) {
    auto tid = TransId {TransPrefix::FIND_NODE, getNewTid()};
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
@@ -688,7 +718,7 @@ NetworkEngine::sendFindNode(std::shared_ptr<Node> n, const InfoHash& target, wan
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), n, std::move(b),
+    Sp<Request> req(new Request {tid, n, std::move(b),
        [=](const Request& req_status, ParsedMessage&& msg) { /* on done */
            if (on_done) {
                on_done(req_status, {std::forward<ParsedMessage>(msg)});
@@ -706,9 +736,9 @@ NetworkEngine::sendFindNode(std::shared_ptr<Node> n, const InfoHash& target, wan
 }


-std::shared_ptr<Request>
-NetworkEngine::sendGetValues(std::shared_ptr<Node> n, const InfoHash& info_hash, const Query& query, want_t want,
-        RequestCb on_done, RequestExpiredCb on_expired) {
+Sp<Request>
+NetworkEngine::sendGetValues(Sp<Node> n, const InfoHash& info_hash, const Query& query, want_t want,
+        RequestCb&& on_done, RequestExpiredCb&& on_expired) {
    auto tid = TransId {TransPrefix::GET_VALUES, getNewTid()};
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
@@ -737,7 +767,7 @@ NetworkEngine::sendGetValues(std::shared_ptr<Node> n, const InfoHash& info_hash,
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), n, std::move(b),
+    Sp<Request> req(new Request {tid, n, std::move(b),
        [=](const Request& req_status, ParsedMessage&& msg) { /* on done */
            if (on_done) {
                on_done(req_status, {std::forward<ParsedMessage>(msg)});
@@ -798,7 +828,7 @@ NetworkEngine::deserializeNodes(ParsedMessage& msg) {
 }

 std::vector<Blob>
-NetworkEngine::packValueHeader(msgpack::sbuffer& buffer, const std::vector<std::shared_ptr<Value>>& st)
+NetworkEngine::packValueHeader(msgpack::sbuffer& buffer, const std::vector<Sp<Value>>& st)
 {
    auto svals = serializeValues(st);
    size_t total_size = 0;
@@ -853,7 +883,8 @@ NetworkEngine::sendValueParts(TransId tid, const std::vector<Blob>& svals, const

 void
 NetworkEngine::sendNodesValues(const SockAddr& addr, TransId tid, const Blob& nodes, const Blob& nodes6,
-        const std::vector<std::shared_ptr<Value>>& st, const Query& query, const Blob& token) {
+        const std::vector<Sp<Value>>& st, const Query& query, const Blob& token)
+{
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
    pk.pack_map(4+(network?1:0));
@@ -909,9 +940,9 @@ NetworkEngine::sendNodesValues(const SockAddr& addr, TransId tid, const Blob& no
 }

 Blob
-NetworkEngine::bufferNodes(sa_family_t af, const InfoHash& id, std::vector<std::shared_ptr<Node>>& nodes)
+NetworkEngine::bufferNodes(sa_family_t af, const InfoHash& id, std::vector<Sp<Node>>& nodes)
 {
-    std::sort(nodes.begin(), nodes.end(), [&](const std::shared_ptr<Node>& a, const std::shared_ptr<Node>& b){
+    std::sort(nodes.begin(), nodes.end(), [&](const Sp<Node>& a, const Sp<Node>& b){
        return id.xorCmp(a->id, b->id) < 0;
    });
    size_t nnode = std::min<size_t>(SEND_NODES, nodes.size());
@@ -944,7 +975,7 @@ NetworkEngine::bufferNodes(sa_family_t af, const InfoHash& id, std::vector<std::

 std::pair<Blob, Blob>
 NetworkEngine::bufferNodes(sa_family_t af, const InfoHash& id, want_t want,
-        std::vector<std::shared_ptr<Node>>& nodes4, std::vector<std::shared_ptr<Node>>& nodes6)
+        std::vector<Sp<Node>>& nodes4, std::vector<Sp<Node>>& nodes6)
 {
    if (want < 0)
        want = af == AF_INET ? WANT4 : WANT6;
@@ -960,19 +991,47 @@ NetworkEngine::bufferNodes(sa_family_t af, const InfoHash& id, want_t want,
    return {std::move(bnodes4), std::move(bnodes6)};
 }

-std::shared_ptr<Request>
-NetworkEngine::sendListen(std::shared_ptr<Node> n, const InfoHash& infohash, const Query& query, const Blob& token,
-        RequestCb on_done, RequestExpiredCb on_expired) {
-    auto tid = TransId {TransPrefix::LISTEN, getNewTid()};
+Sp<Request>
+NetworkEngine::sendListen(Sp<Node> n,
+        const InfoHash& hash,
+        const Query& query,
+        const Blob& token,
+        Sp<Request> previous,
+        RequestCb&& on_done,
+        RequestExpiredCb&& on_expired,
+        SocketCb&& socket_cb)
+{
+    Sp<Socket> socket;
+    auto tid = TransId { TransPrefix::LISTEN, previous ? previous->tid.getTid() : getNewTid() };
+    if (previous and previous->node == n) {
+        socket = previous->socket;
+    } else {
+        if (previous)
+            DHT_LOG.e(hash, "[node %s] trying refresh listen contract with wrong node", previous->node->toString().c_str());
+        /* TODO: Manually creating a socket for "listen" backward compatibility.
+         * As soon as this is not an issue anymore, switch to using
+         * ::createSocket function! */
+        auto sid = TransId {TransPrefix::GET_VALUES, tid.getTid()};
+        socket = std::make_shared<Socket>(n, sid, socket_cb);
+        opened_sockets.emplace(sid, socket);
+    }
+
+    if (not socket) {
+        DHT_LOG.e(hash, "[node %s] unable to get a valid socket for listen. Aborting listen", n->toString().c_str());
+        return {};
+    }
+
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
    pk.pack_map(5+(network?1:0));

    auto has_query = query.where.getFilter() or not query.select.getSelection().empty();
-    pk.pack(std::string("a")); pk.pack_map(3 + has_query);
+    pk.pack(std::string("a")); pk.pack_map(4 + has_query);
      pk.pack(std::string("id"));    pk.pack(myid);
-      pk.pack(std::string("h"));     pk.pack(infohash);
+      pk.pack(std::string("h"));     pk.pack(hash);
      pk.pack(std::string("token")); packToken(pk, token);
+      pk.pack(std::string("sid"));  pk.pack_bin(socket->id.size());
+                                     pk.pack_bin_body((const char*)socket->id.data(), socket->id.size());
      if (has_query) {
          pk.pack(std::string("q")); pk.pack(query);
      }
@@ -987,7 +1046,7 @@ NetworkEngine::sendListen(std::shared_ptr<Node> n, const InfoHash& infohash, con
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), n, std::move(b),
+    Sp<Request> req(new Request {tid, n, std::move(b),
        [=](const Request& req_status, ParsedMessage&& msg) { /* on done */
            if (on_done)
                on_done(req_status, {std::forward<ParsedMessage>(msg)});
@@ -996,7 +1055,7 @@ NetworkEngine::sendListen(std::shared_ptr<Node> n, const InfoHash& infohash, con
            if (on_expired)
                on_expired(req_status, done);
        },
-        true
+        socket
    });
    sendRequest(req);
    ++out_stats.listen;
@@ -1024,14 +1083,14 @@ NetworkEngine::sendListenConfirmation(const SockAddr& addr, TransId tid) {
    send(buffer.data(), buffer.size(), 0, addr);
 }

-std::shared_ptr<Request>
-NetworkEngine::sendAnnounceValue(std::shared_ptr<Node> n,
+Sp<Request>
+NetworkEngine::sendAnnounceValue(Sp<Node> n,
        const InfoHash& infohash,
-        const std::shared_ptr<Value>& value,
+        const Sp<Value>& value,
        time_point created,
        const Blob& token,
-        RequestCb on_done,
-        RequestExpiredCb on_expired)
+        RequestCb&& on_done,
+        RequestExpiredCb&& on_expired)
 {
    auto tid = TransId {TransPrefix::ANNOUNCE_VALUES, getNewTid()};
    msgpack::sbuffer buffer;
@@ -1058,7 +1117,7 @@ NetworkEngine::sendAnnounceValue(std::shared_ptr<Node> n,
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), n, std::move(b),
+    Sp<Request> req(new Request {tid, n, std::move(b),
        [=](const Request& req_status, ParsedMessage&& msg) { /* on done */
            if (msg.value_id == Value::INVALID_ID) {
                DHT_LOG.d(infohash, "Unknown search or announce!");
@@ -1083,13 +1142,13 @@ NetworkEngine::sendAnnounceValue(std::shared_ptr<Node> n,
    return req;
 }

-std::shared_ptr<Request>
-NetworkEngine::sendRefreshValue(std::shared_ptr<Node> n,
+Sp<Request>
+NetworkEngine::sendRefreshValue(Sp<Node> n,
                const InfoHash& infohash,
                const Value::Id& vid,
                const Blob& token,
-                RequestCb on_done,
-                RequestExpiredCb on_expired)
+                RequestCb&& on_done,
+                RequestExpiredCb&& on_expired)
 {
    auto tid = TransId {TransPrefix::REFRESH, getNewTid()};
    msgpack::sbuffer buffer;
@@ -1112,7 +1171,7 @@ NetworkEngine::sendRefreshValue(std::shared_ptr<Node> n,
    }

    Blob b {buffer.data(), buffer.data() + buffer.size()};
-    std::shared_ptr<Request> req(new Request {tid.getTid(), n, std::move(b),
+    Sp<Request> req(new Request {tid, n, std::move(b),
        [=](const Request& req_status, ParsedMessage&& msg) { /* on done */
            if (msg.value_id == Value::INVALID_ID) {
                DHT_LOG.d(infohash, "Unknown search or announce!");
@@ -1163,7 +1222,8 @@ NetworkEngine::sendError(const SockAddr& addr,
        TransId tid,
        uint16_t code,
        const std::string& message,
-        bool include_id) {
+        bool include_id)
+{
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
    pk.pack_map(4 + (include_id?1:0));
@@ -1260,6 +1320,9 @@ ParsedMessage::msgpack_unpack(msgpack::object msg)
        error_code = e->via.array.ptr[0].as<uint16_t>();
    }

+    if (auto t = findMapValue(req, "sid"))
+        socket_id = {t->as<std::array<char, 4>>()};
+
    if (auto rid = findMapValue(req, "id"))
        id = {*rid};

@@ -1419,4 +1482,5 @@ ParsedMessage::complete()
 }


-}
+} /* namespace net  */
+} /* namespace dht */
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -72,7 +72,7 @@ Node::update(const SockAddr& new_addr)

 /** To be called when a message was sent to the node */
 void
-Node::requested(std::shared_ptr<Request>& req)
+Node::requested(std::shared_ptr<net::Request>& req)
 {
    requests_.emplace_back(req);
 }
@@ -80,12 +80,12 @@ Node::requested(std::shared_ptr<Request>& 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<Request> req)
+Node::received(time_point now, std::shared_ptr<net::Request> req)
 {
    time = now;
+    expired_ = false;
    if (req) {
        reply_time = now;
-        expired_ = false;
        for (auto it = requests_.begin(); it != requests_.end();) {
            auto r = it->lock();
            if (not r or r == req)
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  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
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -12,15 +12,26 @@ static std::uniform_int_distribution<int> rand_byte{ 0, std::numeric_limits<uint
 static std::uniform_int_distribution<uint8_t> rand_byte;
 #endif

-std::shared_ptr<Node>
+Sp<Node>
 Bucket::randomNode()
 {
    if (nodes.empty())
        return nullptr;
-    std::uniform_int_distribution<unsigned> rand_node(0, nodes.size()-1);
+    unsigned expired_node_count = std::count_if(nodes.cbegin(), nodes.cend(), [](const decltype(nodes)::value_type& node) {
+        return node->isExpired();
+    });
+    auto prioritize_not_expired = expired_node_count < nodes.size();
+
+    std::uniform_int_distribution<unsigned> rand_node(0, prioritize_not_expired
+            ? nodes.size() - expired_node_count - 1
+            : nodes.size()-1);
    unsigned nn = rand_node(rd);
-    for (auto& n : nodes)
-        if (not nn--) return n;
+    for (auto& n : nodes) {
+        if (not (prioritize_not_expired and n->isExpired())) {
+            if (not nn--)
+                return n;
+        }
+    }
    return nodes.back();
 }

@@ -59,15 +70,17 @@ RoutingTable::middle(const RoutingTable::const_iterator& it) const
 unsigned
 RoutingTable::depth(const RoutingTable::const_iterator& it) const
 {
+    if (it == end())
+        return 0;
    int bit1 = it->first.lowbit();
    int bit2 = std::next(it) != end() ? std::next(it)->first.lowbit() : -1;
    return std::max(bit1, bit2)+1;
 }

-std::vector<std::shared_ptr<Node>>
+std::vector<Sp<Node>>
 RoutingTable::findClosestNodes(const InfoHash id, time_point now, size_t count) const
 {
-    std::vector<std::shared_ptr<Node>> nodes {};
+    std::vector<Sp<Node>> nodes {};
    auto bucket = findBucket(id);

    if (bucket == end()) { return nodes; }
@@ -78,7 +91,7 @@ RoutingTable::findClosestNodes(const InfoHash id, time_point now, size_t count)
                continue;

            auto here = std::find_if(nodes.begin(), nodes.end(),
-                [&id,&n](std::shared_ptr<Node> &node) {
+                [&id,&n](Sp<Node> &node) {
                    return id.xorCmp(n->id, node->id) < 0;
                }
            );
@@ -149,7 +162,7 @@ RoutingTable::split(const RoutingTable::iterator& b)
    insert(std::next(b), Bucket {b->af, new_id, b->time});

    // Re-assign nodes
-    std::list<std::shared_ptr<Node>> nodes {};
+    std::list<Sp<Node>> nodes {};
    nodes.splice(nodes.begin(), b->nodes);
    while (!nodes.empty()) {
        auto n = nodes.begin();
@@ -1,6 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *           Simon Désaulniers <simon.desaulniers@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
@@ -35,12 +36,8 @@ namespace dht {
 Config& getConfig(SecureDht::Config& conf)
 {
    auto& c = conf.node_config;
-    if (c.node_id == InfoHash()) {
-          if (conf.id.second)
-            c.node_id = InfoHash::get("node:"+conf.id.second->getId().toString());
-        else
-            c.node_id = InfoHash::getRandom();
-    }
+    if (c.node_id == InfoHash() and conf.id.second)
+        c.node_id = InfoHash::get("node:"+conf.id.second->getId().toString());
    return c;
 }

@@ -80,7 +77,7 @@ SecureDht::~SecureDht()
 ValueType
 SecureDht::secureType(ValueType&& type)
 {
-    type.storePolicy = [this,type](InfoHash id, std::shared_ptr<Value>& v, InfoHash nid, const sockaddr* a, socklen_t al) {
+    type.storePolicy = [this,type](InfoHash id, Sp<Value>& v, InfoHash nid, const sockaddr* a, socklen_t al) {
        if (v->isSigned()) {
            if (!v->owner or !v->owner->checkSignature(v->getToSign(), v->signature)) {
                DHT_LOG.WARN("Signature verification failed");
@@ -91,7 +88,7 @@ SecureDht::secureType(ValueType&& type)
        }
        return type.storePolicy(id, v, nid, a, al);
    };
-    type.editPolicy = [this,type](InfoHash id, const std::shared_ptr<Value>& o, std::shared_ptr<Value>& n, InfoHash nid, const sockaddr* a, socklen_t al) {
+    type.editPolicy = [this,type](InfoHash id, const Sp<Value>& o, Sp<Value>& n, InfoHash nid, const sockaddr* a, socklen_t al) {
        if (!o->isSigned())
            return type.editPolicy(id, o, n, nid, a, al);
        if (o->owner != n->owner) {
@@ -117,7 +114,7 @@ SecureDht::secureType(ValueType&& type)
    return type;
 }

-const std::shared_ptr<crypto::Certificate>
+const Sp<crypto::Certificate>
 SecureDht::getCertificate(const InfoHash& node) const
 {
    if (node == getId())
@@ -129,7 +126,7 @@ SecureDht::getCertificate(const InfoHash& node) const
        return it->second;
 }

-const std::shared_ptr<const crypto::PublicKey>
+const Sp<const crypto::PublicKey>
 SecureDht::getPublicKey(const InfoHash& node) const
 {
    if (node == getId())
@@ -141,10 +138,10 @@ SecureDht::getPublicKey(const InfoHash& node) const
        return it->second;
 }

-const std::shared_ptr<crypto::Certificate>
+const Sp<crypto::Certificate>
 SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
 {
-    std::shared_ptr<crypto::Certificate> crt;
+    Sp<crypto::Certificate> crt;
    try {
        crt = std::make_shared<crypto::Certificate>(data);
    } catch (const std::exception& e) {
@@ -166,16 +163,16 @@ SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
 }

 void
-SecureDht::registerCertificate(std::shared_ptr<crypto::Certificate>& cert)
+SecureDht::registerCertificate(Sp<crypto::Certificate>& cert)
 {
    if (cert)
        nodesCertificates_[cert->getId()] = cert;
 }

 void
-SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::shared_ptr<crypto::Certificate>)> cb)
+SecureDht::findCertificate(const InfoHash& node, std::function<void(const Sp<crypto::Certificate>)> cb)
 {
-    std::shared_ptr<crypto::Certificate> b = getCertificate(node);
+    Sp<crypto::Certificate> b = getCertificate(node);
    if (b && *b) {
        DHT_LOG.DEBUG("Using certificate from cache for %s", node.toString().c_str());
        if (cb)
@@ -194,7 +191,7 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
    }

    auto found = std::make_shared<bool>(false);
-    Dht::get(node, [cb,node,found,this](const std::vector<std::shared_ptr<Value>>& vals) {
+    Dht::get(node, [cb,node,found,this](const std::vector<Sp<Value>>& vals) {
        if (*found)
            return false;
        for (const auto& v : vals) {
@@ -214,7 +211,7 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
 }

 void
-SecureDht::findPublicKey(const InfoHash& node, std::function<void(const std::shared_ptr<const crypto::PublicKey>)> cb)
+SecureDht::findPublicKey(const InfoHash& node, std::function<void(const Sp<const crypto::PublicKey>)> cb)
 {
    auto pk = getPublicKey(node);
    if (pk && *pk) {
@@ -223,7 +220,7 @@ SecureDht::findPublicKey(const InfoHash& node, std::function<void(const std::sha
            cb(pk);
        return;
    }
-    findCertificate(node, [=](const std::shared_ptr<crypto::Certificate> crt) {
+    findCertificate(node, [=](const Sp<crypto::Certificate> crt) {
        if (crt && *crt) {
            auto pk = std::make_shared<crypto::PublicKey>(crt->getPublicKey());
            nodesPubKeys_[pk->getId()] = pk;
@@ -237,8 +234,8 @@ SecureDht::findPublicKey(const InfoHash& node, std::function<void(const std::sha
 GetCallback
 SecureDht::getCallbackFilter(GetCallback cb, Value::Filter&& filter)
 {
-    return [=](const std::vector<std::shared_ptr<Value>>& values) {
-        std::vector<std::shared_ptr<Value>> tmpvals {};
+    return [=](const std::vector<Sp<Value>>& values) {
+        std::vector<Sp<Value>> tmpvals {};
        for (const auto& v : values) {
            // Decrypt encrypted values
            if (v->isEncrypted()) {
@@ -291,7 +288,7 @@ SecureDht::listen(const InfoHash& id, GetCallback cb, Value::Filter&& f, Where&&
 }

 void
-SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallback callback, bool permanent)
+SecureDht::putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback, bool permanent)
 {
    if (val->id == Value::INVALID_ID) {
        crypto::random_device rdev;
@@ -307,7 +304,7 @@ SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallb

    // Check if data already exists on the dht
    get(hash,
-        [val,this] (const std::vector<std::shared_ptr<Value>>& vals) {
+        [val,this] (const std::vector<Sp<Value>>& vals) {
            DHT_LOG.DEBUG("Found online previous value being announced.");
            for (const auto& v : vals) {
                if (!v->isSigned())
@@ -328,9 +325,9 @@ SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallb
 }

 void
-SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, std::shared_ptr<Value> val, DoneCallback callback, bool permanent)
+SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, Sp<Value> val, DoneCallback callback, bool permanent)
 {
-    findPublicKey(to, [=](const std::shared_ptr<const crypto::PublicKey> pk) {
+    findPublicKey(to, [=](const Sp<const crypto::PublicKey> pk) {
        if(!pk || !*pk) {
            if (callback)
                callback(false, {});
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-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
@@ -1,7 +1,7 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
- *              Simon Désaulniers <sim.desaulniers@gmail.com>
+ *              Simon Désaulniers <simon.desaulniers@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
@@ -52,7 +52,7 @@ std::ostream& operator<< (std::ostream& s, const Value& v)
            s << "Data (type: " << v.type << " ): ";
            s << std::hex;
            for (size_t i=0; i<v.data.size(); i++)
-                s << std::setfill('0') << std::setw(2) << (unsigned)v.data[i] << " ";
+                s << std::setfill('0') << std::setw(2) << (unsigned)v.data[i];
            s << std::dec;
        }
    }
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -1,7 +1,8 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *          Simon Désaulniers <simon.desaulniers@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
@@ -101,12 +102,10 @@ void cmd_loop(std::shared_ptr<DhtRunner>& dht, dht_params& params)
            continue;
        } else if (op == "ll") {
            print_node_info(dht, params);
-            unsigned good4, dubious4, cached4, incoming4;
-            unsigned good6, dubious6, cached6, incoming6;
-            dht->getNodesStats(AF_INET, &good4, &dubious4, &cached4, &incoming4);
-            dht->getNodesStats(AF_INET6, &good6, &dubious6, &cached6, &incoming6);
-            std::cout << "IPv4 nodes : " << good4 << " good, " << dubious4 << " dubious, " << incoming4 << " incoming." << std::endl;
-            std::cout << "IPv6 nodes : " << good6 << " good, " << dubious6 << " dubious, " << incoming6 << " incoming." << std::endl;
+            std::cout << "IPv4 stats:" << std::endl;
+            std::cout << dht->getNodesStats(AF_INET).toString() << std::endl;
+            std::cout << "IPv6 stats:" << std::endl;
+            std::cout << dht->getNodesStats(AF_INET6).toString() << std::endl;
            continue;
        } else if (op == "lr") {
            std::cout << "IPv4 routing table:" << std::endl;
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
@@ -73,11 +73,9 @@ main(int argc, char **argv)
    gnutls_global_init();
 #endif
    auto params = parseArgs(argc, argv);
-    auto ca_tmp = dht::crypto::generateIdentity("DHT Node CA");
-    auto crt_tmp = dht::crypto::generateIdentity("Scanner node", ca_tmp);

    DhtRunner dht;
-    dht.run(params.port, crt_tmp, true, params.network);
+    dht.run(params.port, {}, true, params.network);

    if (not params.bootstrap.first.empty())
        dht.bootstrap(params.bootstrap.first.c_str(), params.bootstrap.second.c_str());
@@ -86,12 +84,13 @@ main(int argc, char **argv)
    std::cout << "Scanning network..." << std::endl;
    auto all_nodes = std::make_shared<NodeSet>();

+    // Set hash to 1 because 0 is the null hash
    dht::InfoHash cur_h {};
    cur_h.setBit(8*HASH_LEN-1, 1);

    std::this_thread::sleep_for(std::chrono::seconds(2));

-    std::atomic_uint done {false};
+    std::atomic_uint done {0};
    step(dht, done, all_nodes, cur_h, 0);

    {
@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2017 Savoir-faire Linux Inc.
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
Author	SHA1	Message	Date
Adrien Béraud	93c5ad7cbc	crypto: make Certificate::isCA() more restrictive	2017-02-07 16:51:16 -05:00
Adrien Béraud	03d52e4284	Merge pull request #170 from sim590/dht-random-id dht: randomize id in Dht layer	2017-02-07 22:08:57 +01:00
Simon Désaulniers	9d83ee169b	dht: randomize id in Dht layer	2017-02-07 15:58:04 -05:00
Adrien Béraud	43b181ebbf	python: add bindings for network, maintain_storage	2017-01-25 11:57:42 -05:00
Adrien Béraud	ac65ca5177	add shortcut Sp for std::shared_ptr	2017-01-24 23:38:31 -05:00
Adrien Béraud	42671be21e	Merge pull request #168 from sim590/announce-op-fixes Announce op fixes	2017-01-20 11:19:33 -05:00
Simon Désaulniers	efa6930de2	dht: fix multiple put on a single search segfault "Iterators pointing to an element between the new logical end and the physical end of the range are still dereferenceable, but the elements themselves have unspecified values (as per MoveAssignable post-condition)." - http://en.cppreference.com/w/cpp/algorithm/remove	2017-01-20 02:40:05 -05:00
Simon Désaulniers	19c47ec781	dht: correctly tell if value is announced * A value should be considered announced if all good nodes up to a count of TARGET_NODES have been tried in the search . * Bug fix where SearchNode::isAnnounced criteria was not consistent with announce operation.	2017-01-20 02:39:59 -05:00
Adrien Béraud	435cd554e6	securedht: add getLongId()	2017-01-19 12:09:12 -05:00
Adrien Béraud	10c70ebd12	hash: add string I/O	2017-01-19 12:08:49 -05:00
Adrien Béraud	7da3ff1bba	hash: add support for SHA256 public key fingerprints	2017-01-18 16:08:31 -05:00
Adrien Béraud	a222e30428	update to version 1.3.0	2017-01-17 16:44:02 -05:00
Adrien Béraud	bd822fce19	dht: don't stop node insertion on expired search	2017-01-17 16:43:32 -05:00
Adrien Béraud	cabe9dbeb5	dht: declare StorageBucket as class	2017-01-16 17:53:21 -05:00
Adrien Béraud	99b7a07350	sockaddr: make ipCmp comparator const	2017-01-16 17:51:59 -05:00
Adrien Béraud	756e0bd3d8	dht: cleanup paginate Reduce indentation level by 4, add code documentation, remain under 120 chars wide.	2017-01-15 19:02:15 -05:00
Adrien Béraud	9b0ce12b5f	Update README.md	2017-01-15 02:18:37 -05:00
Adrien Béraud	e29c2df002	Merge pull request #166 from sim590/license-notice update license notice (2017)	2017-01-15 02:15:10 -05:00
Simon Désaulniers	b03a8b5b50	update license notice (2017)	2017-01-13 17:27:29 -05:00
Adrien Béraud	32f5175d68	dht: expire storage just on time	2017-01-13 16:06:46 -05:00
Adrien Béraud	7d3a54db57	dht: storage rate limiting	2017-01-13 16:06:46 -05:00
Adrien Béraud	3fb7c2acfe	Merge pull request #165 from atraczyk/master msvc: change contrib repo sources	2017-01-11 14:48:56 -05:00
atraczyk	bce5d35b51	msvc: change contrib repo sources	2017-01-11 14:37:22 -05:00
Adrien Béraud	b6dca5ccd6	dht: use new NodeStats structure to provide stats	2017-01-10 23:34:56 -05:00
Adrien Béraud	23b2712400	dht: use SHA265 instead of SHA512 for the op token The op token is renewed regularly (around every 30 minutes), so SHA256 provides enough security for this non-sensitive token. SHA256 takes 32 bytes instead of 64 bytes for SHA512, and the token is included in every listen requests, renewed every 30 seconds, and every answer to get. In the context of limited bandwith usage, using SHA256 seems more appropriate. This change is backward and forward compatible.	2017-01-10 23:34:56 -05:00
Adrien Béraud	63bec73885	default types: make TrustRequest a map, add confirm field	2017-01-10 14:24:42 -05:00
Simon Désaulniers	af5e0c8982	node: remove expired flag when a node reaches us	2017-01-09 14:40:42 -05:00
Adrien Béraud	5a7c8753e1	python/tools: use asyncio in pingpong test	2017-01-09 14:40:06 -05:00
Adrien Béraud	19fdec96ca	dht: remove getStatus with get	2017-01-09 14:38:51 -05:00
Adrien Béraud	2208a06232	dht: clear acked with announce Clear the search node acked when clearing the corresponding announce, after checking the announce status for all announces.	2017-01-09 00:06:54 -05:00
Adrien Béraud	2cfcaf3909	Merge pull request #164 from sim590/connectivity-changes routing_table: complete connecting state resolution	2017-01-04 14:04:37 -05:00
Simon Désaulniers	620868b5d6	routing_table: complete connecting state resolution After a connectivity change, the DHT would enter the "connecting" state in order to try to resolve good nodes. However, the previous algorithm would probabilistically increase time for completion each time a node would fail to resolve. We now avoid this by prioritizing non-expired nodes in the process. Also, a subtle error would sensibly stop the process for 30 minutes due to using the Node::NODE_EXPIRE_TIME constant instead of Node::MAX_RESPONSE_TIME.	2017-01-03 17:48:40 -05:00
Adrien Béraud	e7295bac7b	crypto: prevent signing certificates with a non-CA certificate	2017-01-02 16:16:28 -05:00
Adrien Béraud	38aa86de2a	crypto/crl: add getIssuerName, getIssuerUID	2016-12-29 11:19:27 -05:00
Adrien Béraud	fdf476a3f3	cmake: generate opendhtConfigVersion.cmake	2016-12-29 11:18:45 -05:00
Adrien Béraud	22f27a6cc0	cmake: generate opendhtConfig.cmake	2016-12-28 18:19:16 -05:00
Adrien Béraud	c72ea8ce77	tools/scanner: don't use a certificate	2016-12-09 02:41:40 -05:00
Adrien Béraud	ea168353b9	tools/scanner: use urllib3 streaming	2016-12-09 02:41:12 -05:00
Adrien Béraud	79b9c4838e	Merge pull request #161 from savoirfairelinux/yomgui1-patch-1 remove InfoHash::toCString()	2016-12-06 18:35:56 -05:00
Guillaume Roguez	d6e86ebcc9	remove InfoHash::toCString() Implementation of InfoHash::toCString() is broken	2016-12-06 18:28:14 -05:00
Adrien Béraud	197aaa47f0	crypto: prevent duplicate CRLs, reimport after signing	2016-12-06 16:59:54 -05:00
Adrien Béraud	ad234004aa	crypto: store CRLs in a set	2016-12-05 15:43:00 -05:00
Adrien Béraud	a88e6a4c5f	crypto: make CRL default expiration same as certificate	2016-12-02 12:59:03 -05:00
Adrien Béraud	c776dad96f	crypto: add Certificate::getExpiration()	2016-12-02 12:58:10 -05:00
Adrien Béraud	31fedd529b	crypto: add CRL msgpack serialization	2016-12-01 18:42:26 -05:00
Adrien Béraud	e9adff9dc5	crypto: add CRL move operator, export as DER	2016-11-30 17:30:09 -05:00
Adrien Béraud	bfd58a204b	crypto: add CRL import/export methods	2016-11-30 16:31:29 -05:00
Adrien Béraud	867bcf1514	crypto: add EC key generation	2016-11-29 18:04:25 -05:00
Adrien Béraud	fb882ee440	crypto: add revocation list	2016-11-29 18:03:49 -05:00
Adrien Béraud	215d3d2847	http server: add cmd arguments	2016-11-29 13:31:40 -05:00
Adrien Béraud	43a345ba0c	python: add HTTP server to access the DHT	2016-11-29 12:08:33 -05:00
Adrien Béraud	f73f5e2798	log: cosmetics	2016-11-29 01:27:42 -05:00
Istvan	3724670fcc	Log.cpp added to src/MakeFile.am	2016-11-29 00:50:47 -05:00
Istvan	e7db64bd74	Log functions are moved to log.cpp Log functions are moved to the log.cpp in order to avoid multiple definitions of the logger functions.	2016-11-29 00:50:47 -05:00
Adrien Béraud	9c29b8a29e	Merge pull request #160 from sim590/fix-include-dep buildtools: add def.h to include files	2016-11-28 01:49:30 -05:00
Adrien Béraud	c22f0e4d43	Update Makefile.am	2016-11-28 01:48:26 -05:00
Adrien Béraud	4e2b11c24c	Update CMakeLists.txt	2016-11-28 01:47:33 -05:00
Simon Désaulniers	8c34e927ea	buildtools: add def.h to include files	2016-11-27 23:28:23 -05:00
Adrien Béraud	8a5de47aa0	hide symbols by default (#140 )	2016-11-23 18:27:24 -05:00
Adrien Béraud	7f84c1e397	utils: remove useless definitions	2016-11-23 15:12:37 -05:00
Adrien Béraud	65c915fd9d	value: print hex value data contiguously	2016-11-23 11:01:14 -05:00
Adrien Béraud	0fd4f73ab1	network monitor: access proper dictionary key	2016-11-23 11:00:11 -05:00
Adrien Béraud	01117567b1	cmake: adapt pkg-config paths to GNUInstallDirs	2016-11-22 10:43:01 -05:00
Adrien Béraud	d68cc5cf40	Merge pull request #156 from sim590/cython-robust-check autoconf: robustly check for cython3	2016-11-21 15:10:40 -05:00
Simon Désaulniers	6db16be2fa	autoconf: robustly check for cython3	2016-11-14 21:07:36 -05:00
Adrien Béraud	5166b1add9	tools: add network monitor The network monitor allows to regularly check the status of an OpenDHT network, by performing listen and put operations at random places on the DHT. This first version exit with status code 1 if the test fails.	2016-11-10 01:03:29 -05:00
Adrien Béraud	9fadcc907c	python: add default port for bootstrap	2016-11-10 00:58:35 -05:00
Adrien Béraud	42171efc3f	dht: send values to all sockets for a node We used to send values once to a given node, however the receiving node may have canceled or dropped the request since then, so we now send the values for every socket and the optimization will happen on the sending side.	2016-11-09 21:53:43 -05:00
Adrien Béraud	206f12648f	Merge pull request #155 from aviau/patch-1 Multi-Arch support	2016-11-09 13:10:08 -05:00
Alexandre Viau	ecd0573c4d	Multi-Arch support	2016-11-09 11:30:17 -05:00
Simon Désaulniers	2d9f6241a9	net: don't close socket on listen renew	2016-11-08 16:07:15 -05:00
Adrien Béraud	77ee50f5a6	Merge pull request #154 from savoirfairelinux/c_str infohash: add helper to C string format conversion	2016-11-08 15:48:05 -05:00
Guillaume Roguez	297c37e609	infohash: add helper to C string format conversion This const void* convertion method helps a lot with programs that need to print the hash with a printf() like function.	2016-11-08 15:26:13 -05:00
Simon Désaulniers	9bb1ab43eb	net.h: moved to include/opendht/	2016-11-08 14:52:09 -05:00
Adrien Béraud	cd36b13c30	dht: prevent infinite loop in expireStorage()	2016-11-07 16:56:08 -05:00
Adrien Béraud	5d63084627	Merge pull request #152 from sim590/listen-consistency Listen consistency	2016-11-07 10:33:05 -05:00
Simon Désaulniers	ab7d1d6582	dht,net: introduce socket, support multiple listen Since the initial implementation of listen operation, multiple listen requests from a single node on a same hash was not possible without singular inconsistencies. The flaw was coming from the fact that nodes receiving listen request could not differentiate between listen refresh request and a new independent listen request. This patch introduces the new net::Socket structure which in time will enable remote nodes to send update for a storage while differentiating between concurrent listen requests. A socket has a unique identifier which consists of a transaction id as defined in the OpenDHT protocol.	2016-11-07 06:44:15 -05:00
Simon Désaulniers	77ea6d8c2f	net: create net namespace, moving relevant structs	2016-11-05 19:29:00 -04:00
Simon Désaulniers	b5cd629160	dht: callback if no storage maintenance	2016-11-04 09:15:10 -04:00
Adrien Béraud	39467c8b71	tools: add python cluster runner commands	2016-11-02 02:32:06 -04:00
Adrien Béraud	87740e3b38	tools: add python node cluster runner	2016-11-01 03:14:26 -04:00
Adrien Béraud	19848a9b72	python: encode log file name	2016-11-01 03:13:56 -04:00
Adrien Béraud	36e9998fe2	scanner: use urllib3	2016-11-01 03:13:56 -04:00
Adrien Béraud	b2529c241e	log: flush on new line	2016-11-01 03:13:56 -04:00
Adrien Béraud	83c47037d2	dht: remove unimplemented declaration	2016-11-01 03:13:56 -04:00
Adrien Béraud	125b6f9236	dht: make storage maintenance optional, default disabled	2016-10-31 14:43:56 -04:00
Adrien Béraud	e260ba6b78	infohash: remove misused restrict	2016-10-31 12:35:50 -04:00
Simon Désaulniers	eafb934e85	bump version to 1.2.1	2016-10-28 18:49:09 -04:00
Adrien Béraud	c3d3da20f6	Merge pull request #146 from sim590/permanent-put-enhancement dht: make reannounce margin bigger, safer	2016-10-28 16:24:07 -04:00
Adrien Béraud	6036ccdbaa	dht: try inserting new nodes smarter (#150 ) Attempt closest search and nearby searches until we are too far instead of trying every search.	2016-10-28 15:46:27 -04:00
Simon Désaulniers	9404a4d069	dht: make reannounce margin bigger, safer Reannouncing margin going from 5 seconds to 10 seconds.	2016-10-28 15:24:09 -04:00