travis: add llvm docker build

A permanent put is going to be executed once and every time the data expires on
each SearchNode.

.travis.yml

@@ -1,44 +1,18 @@
-sudo: false
+sudo: required
 
 services:
   - docker
 
 language: cpp
 
-compiler:
-  - gcc
-  - clang
-
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.9
-    - g++-4.9
-    - libgnutls28-dev
-    - cmake
-
 before_install:
-  - if [ $TRAVIS_OS_NAME == linux ] && [ $CXX == g++ ]; then export CXX=/usr/bin/g++-4.9 && export CC=/usr/bin/gcc-4.9; fi
-  - if [ $TRAVIS_OS_NAME == linux ]; then git clone https://github.com/msgpack/msgpack-c.git; fi
-  - if [ $TRAVIS_OS_NAME == linux ]; then cd msgpack-c && git checkout cpp-1.2.0 && mkdir build && mkdir -p $HOME/usr && cd build; fi
-  - if [ $TRAVIS_OS_NAME == linux ]; then cmake -DCMAKE_INSTALL_PREFIX=$HOME/usr -DMSGPACK_CXX11=ON -DMSGPACK_BUILD_EXAMPLES=OFF .. && make -j && make install && cd ../.. && pwd; fi
-  - if [ $TRAVIS_OS_NAME == osx ]; then brew update && brew install llvm36 && brew install msgpack && brew install gnutls && brew link --force llvm36; fi
-
-before_script:
-  - if [ $TRAVIS_OS_NAME == linux ]; then travis_retry ./autogen.sh && ./configure --prefix=$HOME/usr; fi
-  - if [ $TRAVIS_OS_NAME == osx ]; then travis_retry ./autogen.sh && ./configure; fi
+- docker pull aberaud/opendht-deps
+- docker pull aberaud/opendht-deps-llvm
 
 script:
-  - make -j
+- docker build -f docker/DockerfileTravis .
+- docker build -f docker/DockerfileTravisLlvm .
 
 notifications:
   email:
       - adrien.beraud@savoirfairelinux.com
-
-env:
-  - LANG="en_US.UTF-8"
-
-os:
-  - osx

CMakeLists.txt

@@ -1,9 +1,10 @@
 cmake_minimum_required (VERSION 2.8.6)
 project (opendht)
 set (opendht_VERSION_MAJOR 0)
-set (opendht_VERSION_MINOR 5.2)
+set (opendht_VERSION_MINOR 6.1)
 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")
 
@@ -12,85 +13,129 @@ set (exec_prefix "\${prefix}")
 set (libdir "\${exec_prefix}/lib")
 set (includedir "\${prefix}/include")
 
+option (OPENDHT_DEBUG "Build with debug flags" OFF)
+option (OPENDHT_STATIC "Build static library" ON)
+option (OPENDHT_SHARED "Build shared library" ON)
+option (OPENDHT_LTO "Build with LTO" OFF)
+
 option (OPENDHT_PYTHON "Build Python bindings" OFF)
 option (OPENDHT_TOOLS "Build DHT tools" ON)
-option (OPENDHT_DEBUG "Build with debug flags" OFF)
 
-set (CMAKE_CXX_FLAGS "-pthread -std=c++11 -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor ${CMAKE_CXX_FLAGS}")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -std=c++11 -Wno-return-type -Wall -Wextra -Wnon-virtual-dtor")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")
+if (OPENDHT_LTO)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto -fuse-linker-plugin")
+    if (CMAKE_COMPILER_IS_GNUCC)
+        SET (CMAKE_AR        "gcc-ar")
+        SET (CMAKE_NM        "gcc-nm")
+        SET (CMAKE_RANLIB    "gcc-ranlib")
+    endif ()
+endif ()
 
 find_package (GnuTLS 3.1 REQUIRED)
 find_package (Msgpack 1.2 REQUIRED)
 if (OPENDHT_TOOLS)
-	find_package (Readline 6 REQUIRED)
+    find_package (Readline 6 REQUIRED)
 endif ()
 
 list (APPEND opendht_SOURCES
-	src/utils.cpp
-	src/infohash.cpp
-	src/crypto.cpp
-	src/default_types.cpp
-	src/value.cpp
-	src/dht.cpp
-	src/securedht.cpp
-	src/dhtrunner.cpp
+    src/utils.cpp
+    src/infohash.cpp
+    src/crypto.cpp
+    src/default_types.cpp
+    src/node.cpp
+    src/value.cpp
+    src/dht.cpp
+    src/callbacks.cpp
+    src/routing_table.cpp
+    src/node_cache.cpp
+    src/network_engine.cpp
+    src/securedht.cpp
+    src/dhtrunner.cpp
+    src/argon2/argon2.c
+    src/argon2/core.c
+    src/argon2/blake2/blake2b.c
+    src/argon2/thread.c
+    src/argon2/encoding.c
+    src/argon2/ref.c
 )
 
 list (APPEND opendht_HEADERS
-	include/opendht/utils.h
-	include/opendht/rng.h
-	include/opendht/crypto.h
-	include/opendht/infohash.h
-	include/opendht/default_types.h
-	include/opendht/value.h
-	include/opendht/dht.h
-	include/opendht/securedht.h
-	include/opendht.h
+    include/opendht/utils.h
+    include/opendht/rng.h
+    include/opendht/crypto.h
+    include/opendht/infohash.h
+    include/opendht/default_types.h
+    include/opendht/node.h
+    include/opendht/value.h
+    include/opendht/dht.h
+    include/opendht/callbacks.h
+    include/opendht/routing_table.h
+    include/opendht/node_cache.h
+    include/opendht/network_engine.h
+    include/opendht/scheduler.h
+    include/opendht/securedht.h
+    include/opendht/log.h
+    include/opendht.h
 )
 
 configure_file (
-	opendht.pc.in
-	opendht.pc
-	@ONLY
+    opendht.pc.in
+    opendht.pc
+    @ONLY
 )
 
 include_directories (
-	./
-	include/
-	include/opendht/
-	${CMAKE_CURRENT_BINARY_DIR}/include/
+    ./
+    include/
+    include/opendht/
+    ${CMAKE_CURRENT_BINARY_DIR}/include/
 )
 
 if (OPENDHT_DEBUG)
-	set(CMAKE_BUILD_TYPE Debug)
+    set(CMAKE_BUILD_TYPE Debug)
 else ()
-	set(CMAKE_BUILD_TYPE Release)
+    set(CMAKE_BUILD_TYPE Release)
 endif ()
 
-add_library (opendht SHARED
-	${opendht_SOURCES}
-	${opendht_HEADERS}
-)
-set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
-#set_target_properties (opendht PROPERTIES SOVERSION 1 VERSION 1.0.0)
-
-add_library (opendht-static STATIC
-	${opendht_SOURCES}
-	${opendht_HEADERS}
-)
-set_target_properties (opendht-static PROPERTIES OUTPUT_NAME "opendht")
-
 if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-	set(CMAKE_INSTALL_LIBDIR lib)
+    set(CMAKE_INSTALL_LIBDIR lib)
+endif ()
+
+if (OPENDHT_STATIC)
+    add_library (opendht-static STATIC
+        ${opendht_SOURCES}
+        ${opendht_HEADERS}
+    )
+    set_target_properties (opendht-static PROPERTIES OUTPUT_NAME "opendht")
+    if (OPENDHT_LTO)
+        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})
+endif ()
+
+if (OPENDHT_SHARED)
+    add_library (opendht SHARED
+        ${opendht_SOURCES}
+        ${opendht_HEADERS}
+    )
+    set_target_properties (opendht PROPERTIES IMPORT_SUFFIX "_import.lib")
+    set_target_properties (opendht PROPERTIES SOVERSION ${opendht_VERSION_MAJOR} VERSION ${opendht_VERSION})
+    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})
 endif ()
 
 if (OPENDHT_TOOLS)
-	add_subdirectory(tools)
+    add_subdirectory(tools)
 endif ()
 
 if (OPENDHT_PYTHON)
-	add_subdirectory(python)
+    add_subdirectory(python)
 endif ()
 
-install (TARGETS opendht opendht-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
 install (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
 install (FILES ${CMAKE_CURRENT_BINARY_DIR}/opendht.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

MSVC/.gitignore

@@ -0,0 +1,248 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+#output directories
+DebugLib/
+Debug/
+ReleaseLib/
+Release/
+.config/
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.VC.VC.opendb
+*.VC.db
+*.db
+*.filters
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings 
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignoreable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Microsoft Azure ApplicationInsights config file
+ApplicationInsights.config
+
+# Windows Store app package directory
+AppPackages/
+BundleArtifacts/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+
+# FAKE - F# Make
+.fake/
+
+!config.h

MSVC/opendht.sln

@@ -0,0 +1,257 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opendht", "opendht.vcxproj", "{711397CE-E5D5-467D-9457-8716C047E50C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		DebugDLL|x64 = DebugDLL|x64
+		DebugDLL|x86 = DebugDLL|x86
+		DebugDLLStaticDeps|x64 = DebugDLLStaticDeps|x64
+		DebugDLLStaticDeps|x86 = DebugDLLStaticDeps|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+		ReleaseDLL|x64 = ReleaseDLL|x64
+		ReleaseDLL|x86 = ReleaseDLL|x86
+		ReleaseDLLStaticDeps|x64 = ReleaseDLLStaticDeps|x64
+		ReleaseDLLStaticDeps|x86 = ReleaseDLLStaticDeps|x86
+		ReleaseLTO|x64 = ReleaseLTO|x64
+		ReleaseLTO|x86 = ReleaseLTO|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x86.Build.0 = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x64.ActiveCfg = Debug|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x64.Build.0 = Debug|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x86.ActiveCfg = Debug|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x86.Build.0 = Debug|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x64.ActiveCfg = Release|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x64.Build.0 = Release|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x86.ActiveCfg = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x86.Build.0 = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x64.ActiveCfg = Debug|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x64.Build.0 = Debug|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x86.ActiveCfg = Debug|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x86.Build.0 = Debug|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x64.Build.0 = DebugDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x86.Build.0 = DebugDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x64.ActiveCfg = Release|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x64.Build.0 = Release|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x86.ActiveCfg = Release|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x86.Build.0 = Release|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x64.ActiveCfg = Debug|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x64.Build.0 = Debug|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x86.ActiveCfg = Debug|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x86.Build.0 = Debug|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x64.ActiveCfg = Release|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x64.Build.0 = Release|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x86.ActiveCfg = Release|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x86.Build.0 = Release|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x64.ActiveCfg = Debug|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x64.Build.0 = Debug|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x86.ActiveCfg = Debug|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x86.Build.0 = Debug|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x64.Build.0 = DebugDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x86.Build.0 = DebugDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x64.ActiveCfg = Release|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x64.Build.0 = Release|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x86.ActiveCfg = Release|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x86.Build.0 = Release|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x64.ActiveCfg = Debug|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x64.Build.0 = Debug|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x86.ActiveCfg = Debug|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x86.Build.0 = Debug|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x64.ActiveCfg = Release|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x64.Build.0 = Release|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x86.ActiveCfg = Release|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x86.Build.0 = Release|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x64.ActiveCfg = Debug|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x64.Build.0 = Debug|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x86.ActiveCfg = Debug|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x86.Build.0 = Debug|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x64.ActiveCfg = Release|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x64.Build.0 = Release|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x86.ActiveCfg = Release|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x86.Build.0 = Release|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x64.ActiveCfg = Debug|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x64.Build.0 = Debug|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x64.ActiveCfg = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x64.Build.0 = Release|x64
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

MSVC/opendht.vcxproj

@@ -0,0 +1,224 @@
+<?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="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\src\callbacks.cpp" />
+    <ClCompile Include="..\src\crypto.cpp" />
+    <ClCompile Include="..\src\default_types.cpp" />
+    <ClCompile Include="..\src\dht.cpp" />
+    <ClCompile Include="..\src\dhtrunner.cpp" />
+    <ClCompile Include="..\src\infohash.cpp" />
+    <ClCompile Include="..\src\network_engine.cpp" />
+    <ClCompile Include="..\src\node.cpp" />
+    <ClCompile Include="..\src\node_cache.cpp" />
+    <ClCompile Include="..\src\routing_table.cpp" />
+    <ClCompile Include="..\src\securedht.cpp" />
+    <ClCompile Include="..\src\utils.cpp" />
+    <ClCompile Include="..\src\value.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\opendht.h" />
+    <ClInclude Include="..\include\opendht\callbacks.h" />
+    <ClInclude Include="..\include\opendht\crypto.h" />
+    <ClInclude Include="..\include\opendht\default_types.h" />
+    <ClInclude Include="..\include\opendht\dht.h" />
+    <ClInclude Include="..\include\opendht\dhtrunner.h" />
+    <ClInclude Include="..\include\opendht\infohash.h" />
+    <ClInclude Include="..\include\opendht\log.h" />
+    <ClInclude Include="..\include\opendht\network_engine.h" />
+    <ClInclude Include="..\include\opendht\node.h" />
+    <ClInclude Include="..\include\opendht\node_cache.h" />
+    <ClInclude Include="..\include\opendht\request.h" />
+    <ClInclude Include="..\include\opendht\rng.h" />
+    <ClInclude Include="..\include\opendht\routing_table.h" />
+    <ClInclude Include="..\include\opendht\scheduler.h" />
+    <ClInclude Include="..\include\opendht\securedht.h" />
+    <ClInclude Include="..\include\opendht\utils.h" />
+    <ClInclude Include="..\include\opendht\value.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{711397CE-E5D5-467D-9457-8716C047E50C}</ProjectGuid>
+    <RootNamespace>opendht</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <OutDir>$(ProjectDir)..\..\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <TargetName>opendhtd</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <OutDir>$(ProjectDir)..\..\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <TargetName>opendht</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <OutDir>$(ProjectDir)..\..\</OutDir>
+    <TargetName>opendhtd</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(ProjectDir)..\..\</OutDir>
+    <TargetName>opendht</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>..\..\include;..\include;..\include\opendht;..\..\msgpack-c\include;</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32_NATIVE;WIN32_LEAN_AND_MEAN;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4804;4800;4101;4267;4244;4503;</DisableSpecificWarnings>
+      <AdditionalOptions>-D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions)</AdditionalOptions>
+      <SuppressStartupBanner>false</SuppressStartupBanner>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+mkdir $(OutDir)\include\opendht
+copy ..\include\opendht\*.h $(OutDir)\include\opendht
+copy ..\include\opendht.h $(OutDir)\include\</Command>
+    </PostBuildEvent>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x86\$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>..\..\include;..\include;..\include\opendht;..\..\msgpack-c\include;</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32_NATIVE;WIN32_LEAN_AND_MEAN;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4804;4800;4101;4267;4244;4503;</DisableSpecificWarnings>
+      <AdditionalOptions>-D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+mkdir $(OutDir)\include\opendht
+copy ..\include\opendht\*.h $(OutDir)\include\opendht
+copy ..\include\opendht.h $(OutDir)\include\</Command>
+    </PostBuildEvent>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x64\$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>..\..\include;..\include;..\include\opendht;..\..\msgpack-c\include;</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32_NATIVE;WIN32_LEAN_AND_MEAN;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4804;4800;4101;4267;4244;4503;</DisableSpecificWarnings>
+      <AdditionalOptions>-D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions)</AdditionalOptions>
+      <ProgramDataBaseFileName>$(OutDir)\lib\x86\$(TargetName).pdb</ProgramDataBaseFileName>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+mkdir $(OutDir)\include\opendht
+copy ..\include\opendht\*.h $(OutDir)\include\opendht
+copy ..\include\opendht.h $(OutDir)\include\</Command>
+    </PostBuildEvent>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x86\$(TargetName)$(TargetExt)</OutputFile>
+      <LinkTimeCodeGeneration>false</LinkTimeCodeGeneration>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Full</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>..\..\include;..\include;..\include\opendht;..\..\msgpack-c\include;</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32_NATIVE;WIN32_LEAN_AND_MEAN;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4804;4800;4101;4267;4244;4503;</DisableSpecificWarnings>
+      <AdditionalOptions>-D_SCL_SECURE_NO_WARNINGS %(AdditionalOptions)</AdditionalOptions>
+      <ProgramDataBaseFileName>$(OutDir)\lib\x64\$(TargetName).pdb</ProgramDataBaseFileName>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PostBuildEvent>
+      <Command>mkdir $(OutDir)\include
+mkdir $(OutDir)\include\opendht
+copy ..\include\opendht\*.h $(OutDir)\include\opendht
+copy ..\include\opendht.h $(OutDir)\include\</Command>
+    </PostBuildEvent>
+    <Lib>
+      <OutputFile>$(OutDir)\lib\x64\$(TargetName)$(TargetExt)</OutputFile>
+      <LinkTimeCodeGeneration>false</LinkTimeCodeGeneration>
+    </Lib>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

MSVC/opendht_deps.sln

@@ -0,0 +1,292 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opendht", "opendht.vcxproj", "{711397CE-E5D5-467D-9457-8716C047E50C}"
+	ProjectSection(ProjectDependencies) = postProject
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518} = {070FEF2B-0C3F-4F33-9D3C-53C7330BF518}
+		{122A2EA4-B283-4241-9655-786DE78283B2} = {122A2EA4-B283-4241-9655-786DE78283B2}
+		{6F610EE8-7F59-4191-AB88-F63843267C02} = {6F610EE8-7F59-4191-AB88-F63843267C02}
+	EndProjectSection
+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}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libgnutls", "..\..\gnutls\MSVC\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}
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32} = {CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C} = {200F3D3C-8B84-46D8-953A-6C0EBD283B5C}
+		{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}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libhogweed", "..\..\nettle\MSVC\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}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libzlib", "..\..\zlib\MSVC\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
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		DebugDLL|x64 = DebugDLL|x64
+		DebugDLL|x86 = DebugDLL|x86
+		DebugDLLStaticDeps|x64 = DebugDLLStaticDeps|x64
+		DebugDLLStaticDeps|x86 = DebugDLLStaticDeps|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+		ReleaseDLL|x64 = ReleaseDLL|x64
+		ReleaseDLL|x86 = ReleaseDLL|x86
+		ReleaseDLLStaticDeps|x64 = ReleaseDLLStaticDeps|x64
+		ReleaseDLLStaticDeps|x86 = ReleaseDLLStaticDeps|x86
+		ReleaseLTO|x64 = ReleaseLTO|x64
+		ReleaseLTO|x86 = ReleaseLTO|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Debug|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLL|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x64.ActiveCfg = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x64.Build.0 = Debug|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x86.ActiveCfg = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.DebugDLLStaticDeps|x86.Build.0 = Debug|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.Release|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLL|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseDLLStaticDeps|x86.Build.0 = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x64.ActiveCfg = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x64.Build.0 = Release|x64
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x86.ActiveCfg = Release|Win32
+		{711397CE-E5D5-467D-9457-8716C047E50C}.ReleaseLTO|x86.Build.0 = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x64.ActiveCfg = Debug|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x64.Build.0 = Debug|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x86.ActiveCfg = Debug|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Debug|x86.Build.0 = Debug|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x64.ActiveCfg = Release|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x64.Build.0 = Release|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x86.ActiveCfg = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.Release|x86.Build.0 = Release|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x64.ActiveCfg = Debug|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x64.Build.0 = Debug|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x86.ActiveCfg = Debug|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Debug|x86.Build.0 = Debug|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x64.Build.0 = DebugDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.DebugDLLStaticDeps|x86.Build.0 = DebugDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x64.ActiveCfg = Release|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x64.Build.0 = Release|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x86.ActiveCfg = Release|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.Release|x86.Build.0 = Release|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLLStaticDeps|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLLStaticDeps|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{6F610EE8-7F59-4191-AB88-F63843267C02}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x64.ActiveCfg = Debug|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x64.Build.0 = Debug|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x86.ActiveCfg = Debug|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Debug|x86.Build.0 = Debug|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x64.ActiveCfg = Release|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x64.Build.0 = Release|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x86.ActiveCfg = Release|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.Release|x86.Build.0 = Release|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x64.ActiveCfg = Debug|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x64.Build.0 = Debug|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x86.ActiveCfg = Debug|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Debug|x86.Build.0 = Debug|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x64.Build.0 = DebugDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.DebugDLLStaticDeps|x86.Build.0 = DebugDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x64.ActiveCfg = Release|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x64.Build.0 = Release|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x86.ActiveCfg = Release|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.Release|x86.Build.0 = Release|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLLStaticDeps|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLLStaticDeps|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x64.ActiveCfg = Debug|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x64.Build.0 = Debug|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x86.ActiveCfg = Debug|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Debug|x86.Build.0 = Debug|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x64.ActiveCfg = Release|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x64.Build.0 = Release|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x86.ActiveCfg = Release|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.Release|x86.Build.0 = Release|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x64.ActiveCfg = Debug|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x64.Build.0 = Debug|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x86.ActiveCfg = Debug|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Debug|x86.Build.0 = Debug|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x86.ActiveCfg = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLL|x86.Build.0 = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x64.ActiveCfg = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x64.Build.0 = DebugDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x86.ActiveCfg = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.DebugDLLStaticDeps|x86.Build.0 = DebugDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x64.ActiveCfg = Release|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x64.Build.0 = Release|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x86.ActiveCfg = Release|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.Release|x86.Build.0 = Release|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x86.ActiveCfg = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLL|x86.Build.0 = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x64.ActiveCfg = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x64.Build.0 = ReleaseDLL|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x86.ActiveCfg = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseDLLStaticDeps|x86.Build.0 = ReleaseDLL|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x64.ActiveCfg = ReleaseLTO|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x64.Build.0 = ReleaseLTO|x64
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x86.ActiveCfg = ReleaseLTO|Win32
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32}.ReleaseLTO|x86.Build.0 = ReleaseLTO|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x64.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x64.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLL|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x64.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x86.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.DebugDLLStaticDeps|x86.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x64.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLL|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x64.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseDLLStaticDeps|x86.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x64.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x64.Build.0 = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x86.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.ReleaseLTO|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{02B94302-23D6-43EF-8865-95CDE99D5DC2} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{6F610EE8-7F59-4191-AB88-F63843267C02} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{CB8BB76F-D3FF-434E-A85E-7FFC0893EC9B} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{200F3D3C-8B84-46D8-953A-6C0EBD283B5C} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{070FEF2B-0C3F-4F33-9D3C-53C7330BF518} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{CA9A4A38-CC63-4BDB-8CFB-E058965DDA32} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+		{122A2EA4-B283-4241-9655-786DE78283B2} = {71A1A9EC-1104-4335-A87E-AF8749FD5B34}
+	EndGlobalSection
+EndGlobal

MSVC/project_get_dependencies.bat

@@ -0,0 +1,71 @@
+@ECHO OFF
+SETLOCAL EnableDelayedExpansion
+
+SET UPSTREAMURL=https://github.com/atraczyk
+SET DEPENDENCIES=( ^
+gmp, ^
+gnutls, ^
+nettle, ^
+msgpack-c ^
+)
+
+SET PASSDEPENDENCIES=%~1
+
+git status >NUL 2>&1
+IF %ERRORLEVEL% EQU 128 (
+    git init
+) ELSE (
+    IF %ERRORLEVEL% EQU 9009 (
+        ECHO git not installed.
+        EXIT /B 1
+    )
+)
+
+SET CURRDIR=%~dp1
+
+cd ..\..
+FOR %%I IN %DEPENDENCIES% DO (
+    ECHO !PASSDEPENDENCIES! | FINDSTR /C:"%%I" >NUL 2>&1 || (
+        CALL :cloneOrUpdateRepo "%%I" )
+)
+cd %CURRDIR% >NUL
+GOTO exit
+
+:cloneOrUpdateRepo
+SET REPONAME=%~1
+IF NOT EXIST "%REPONAME%" (
+    ECHO %REPONAME%: Existing folder not found. Cloning repository...
+    SET REPOURL=%UPSTREAMURL%/%REPONAME%.git
+    git clone !REPOURL! --quiet
+    cd %REPONAME%
+    git config --local core.autocrlf false
+    git rm --cached -r . --quiet
+    git reset --hard --quiet
+    cd ..\
+)
+
+SET PASSDEPENDENCIES=%PASSDEPENDENCIES% %REPONAME%
+
+IF EXIST "%REPONAME%\MSVC\project_get_dependencies.bat" (
+    ECHO %REPONAME%: Found additional dependencies...
+    ECHO.
+    cd %REPONAME%\MSVC
+    project_get_dependencies.bat "!PASSDEPENDENCIES!" || GOTO exitOnError
+    cd ..\..
+)
+ECHO.
+EXIT /B %ERRORLEVEL%
+
+:exitOnError
+cd %CURRDIR%
+
+:exit
+(
+    ENDLOCAL
+    SET PASSDEPENDENCIES=%PASSDEPENDENCIES%
+)
+    
+ECHO %CMDCMDLINE% | FINDSTR /L %COMSPEC% >NUL 2>&1
+IF %ERRORLEVEL% == 0 IF "%~1"=="" PAUSE
+
+EXIT /B 0

README.md

@@ -70,33 +70,37 @@ int main()
 ```python
 import opendht as dht
 
-r = dht.DhtRunner()
-r.run()
+node = dht.DhtRunner()
+node.run()
 
 # Join the network through any running node,
 # here using a known bootstrap node.
-r.bootstrap("bootstrap.ring.cx", "4222")
-
-r.put(dht.InfoHash.get("unique_key"), dht.Value(b'some binary data'))
+node.bootstrap("bootstrap.ring.cx", "4222")
 
 # blocking call (provide callback arguments to make the call non-blocking)
-results = r.get(dht.InfoHash.get("unique_key"))
+node.put(dht.InfoHash.get("unique_key"), dht.Value(b'some binary data'))
+
+results = node.get(dht.InfoHash.get("unique_key"))
 for r in results:
     print(r)
 ```
 
-Licence
--
-Copyright (C) 2014-2016 Savoir-faire Linux Inc.
-
-Licenced under the GNU General Public License version 3, though the core routing library (dht.cpp) is licenced under the MIT licence.
-
-This project is independent from another project called OpenDHT (Sean Rhea. Ph.D. Thesis, 2005), now extinct.
-
 Dependencies
 -
 - msgpack-c 1.2+, used for data serialization.
 - GnuTLS 3.1+, used for cryptographic operations.
 - Nettle 2.4+, a GnuTLS dependency for crypto.
 - Build tested with GCC 4.8+ (GNU/Linux, Android, Windows with MinGW), Clang/LLVM (Linux, OS X).
+- Build tested with Microsoft Visual Studio 2015
 
+Licence
+-
+Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+
+Licenced under the GNU General Public License version 3 (see COPYING for the full licence).
+
+This project is independent from another project called OpenDHT (Sean Rhea. Ph.D. Thesis, 2005), now extinct.
+
+Donations
+-
+We gratefully accept Bitcoin donations to support OpenDHT development at: `bitcoin:3EykSd1An888efq4Bq3KaV3hJ3JQ4FPnwm`.

configure.ac

@@ -1,6 +1,6 @@
-AC_INIT(opendht, 0.5.2)
+AC_INIT(opendht, 0.6.1)
 AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE([foreign])
+AM_INIT_AUTOMAKE([foreign subdir-objects])
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CANONICAL_HOST
@@ -14,23 +14,26 @@ AC_PROG_CXX
 AM_PROG_AR
 
 dnl Check for Doxygen
-AC_ARG_ENABLE([doc], [AS_HELP_STRING([--disable-doc], [Disable documentation generation (doxygen)])])
-AS_IF([test "x$enable_doc" != "xno"], [
-  AC_CHECK_PROGS([DOXYGEN], [doxygen])
-  AS_IF([test -z "$DOXYGEN"],[AC_MSG_WARN([Doxygen not found - continuing without Doxygen support])])
+AC_ARG_ENABLE([doc], AS_HELP_STRING([--enable-doc], [Enable documentation generation (doxygen)]))
+AS_IF([test "x$enable_doc" = "xyes"], [
+       AC_CHECK_PROGS([DOXYGEN], [doxygen])
+       AS_IF([test -z "$DOXYGEN"], [AC_MSG_WARN([Doxygen not found - continuing without Doxygen support])])       
 ])
 AM_CONDITIONAL([HAVE_DOXYGEN], [test -n "$DOXYGEN"])
 
 dnl Check for Python
 AC_ARG_ENABLE([python], [AS_HELP_STRING([--disable-python], [Disble python binding])])
 AS_IF([test "x$enable_python" != "xno"], [
-  AM_PATH_PYTHON([3.3],, [:])
-  AS_IF([test -n "$PYTHON"],[
-    AC_CHECK_PROGS([CYTHON], [cython])
-    AS_IF([test -z "$CYTHON"],[AC_MSG_WARN([Cython not found - continuing without python support])])
-  ])
-])
+       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])])
+              AC_CHECK_PROGS([PIP], [pip3])
+              AS_IF([test -z "$PIP"],[AC_MSG_WARN([pip not found - continuing without python uninstall support])])
+              ])
+       ])
 AM_CONDITIONAL([USE_CYTHON], [test -n "$CYTHON"])
+AM_CONDITIONAL([HAVE_PIP], [test -n "$PIP"])
 
 case "${host_os}" in
   "")
@@ -69,12 +72,13 @@ AS_IF([test "x$SYS" = "xandroid"],
 LT_INIT()
 LT_LANG(C++)
 
-AX_CXX_COMPILE_STDCXX_11([noext],[mandatory])
+AX_CXX_COMPILE_STDCXX(11,[noext],[mandatory])
 
 PKG_PROG_PKG_CONFIG()
-PKG_CHECK_MODULES([nettle], [nettle >= 2.4])
-PKG_CHECK_MODULES([GNUTLS], [gnutls >= 3.1])
-PKG_CHECK_MODULES([msgpack], [msgpack >= 1.2])
+PKG_CHECK_MODULES([Nettle], [nettle >= 2.4])
+PKG_CHECK_MODULES([GnuTLS], [gnutls >= 3.1])
+PKG_CHECK_MODULES([MsgPack], [msgpack >= 1.2])
+CXXFLAGS="${CXXFLAGS} -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT"
 
 AC_ARG_ENABLE([tools], AS_HELP_STRING([--disable-tools],[Disable tools (CLI DHT node)]),,build_tools=yes)
 AM_CONDITIONAL(ENABLE_TOOLS, test x$build_tools == xyes)
@@ -97,6 +101,7 @@ AM_COND_IF([USE_CYTHON], [
 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
+                 src/argon2/Makefile
                  tools/Makefile
                  opendht.pc])
 AC_OUTPUT

docker/Dockerfile

@@ -0,0 +1,6 @@
+FROM aberaud/opendht-deps
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr && make -j8 && make install \
+	&& cd ../.. && rm -rf opendht

docker/DockerfileDeps

@@ -0,0 +1,9 @@
+FROM ubuntu:16.04
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+RUN apt-get update && apt-get install -y build-essential cmake git wget libncurses5-dev libreadline-dev nettle-dev libgnutls-dev cython3 python3-dev python3-setuptools
+RUN wget https://github.com/msgpack/msgpack-c/releases/download/cpp-1.4.2/msgpack-1.4.2.tar.gz \
+	&& tar -xzf msgpack-1.4.2.tar.gz \
+	&& cd msgpack-1.4.2 && mkdir build && cd build \
+	&& cmake -DMSGPACK_CXX11=ON -DMSGPACK_BUILD_EXAMPLES=OFF -DCMAKE_INSTALL_PREFIX=/usr .. \
+	&& make -j8 && make install \
+	&& cd ../.. && rm -rf msgpack-1.4.2

docker/DockerfileDepsLlvm

@@ -0,0 +1,11 @@
+FROM ubuntu:16.04
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+RUN apt-get update \
+	&& apt-get install -y llvm clang make cmake git wget libncurses5-dev libreadline-dev nettle-dev libgnutls-dev cython3 python3-dev python3-setuptools \
+	&& apt-get remove -y gcc g++ && apt-get autoremove -y && apt-get clean
+RUN wget https://github.com/msgpack/msgpack-c/releases/download/cpp-1.4.2/msgpack-1.4.2.tar.gz \
+	&& tar -xzf msgpack-1.4.2.tar.gz \
+	&& cd msgpack-1.4.2 && mkdir build && cd build \
+	&& cmake -DMSGPACK_CXX11=ON -DMSGPACK_BUILD_EXAMPLES=OFF -DCMAKE_INSTALL_PREFIX=/usr .. \
+	&& make -j8 && make install \
+	&& cd ../.. && rm -rf msgpack-1.4.2

docker/DockerfileLlvm

@@ -0,0 +1,6 @@
+FROM aberaud/opendht-deps-llvm
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+RUN git clone https://github.com/savoirfairelinux/opendht.git \
+	&& cd opendht && mkdir build && cd build \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr && make -j8 && make install \
+	&& cd ../.. && rm -rf opendht

docker/DockerfileTravis

@@ -0,0 +1,6 @@
+FROM aberaud/opendht-deps
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+COPY . /root/opendht
+RUN cd /root/opendht && mkdir build && cd build \
+	&& cmake -DCMAKE_INSTALL_PREFIX=/usr .. && make -j8 && make install \
+	&& cd ../.. && rm -rf opendht

docker/DockerfileTravisLlvm

@@ -0,0 +1,6 @@
+FROM aberaud/opendht-deps-llvm
+MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+COPY . /root/opendht
+RUN cd /root/opendht && mkdir build && cd build \
+	&& cmake -DCMAKE_INSTALL_PREFIX=/usr .. && make -j8 && make install \
+	&& cd ../.. && rm -rf opendht

include/opendht.h

@@ -19,9 +19,6 @@
 
 #pragma once
 
-#include "opendht/dht.h"
-#include "opendht/value.h"
-#include "opendht/infohash.h"
-#include "opendht/securedht.h"
 #include "opendht/dhtrunner.h"
+#include "opendht/log.h"
 #include "opendht/default_types.h"

include/opendht/callbacks.h

@@ -0,0 +1,76 @@
+/*
+ *  Copyright (C) 2014-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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#pragma once
+
+#include "infohash.h"
+#include "value.h"
+
+#include <vector>
+#include <memory>
+#include <functional>
+
+namespace dht {
+
+struct Node;
+
+enum class NodeStatus {
+    Disconnected, // 0 nodes
+    Connecting,   // 1+ nodes
+    Connected     // 1+ good nodes
+};
+
+struct Config {
+    InfoHash node_id;
+    bool is_bootstrap;
+};
+
+struct SecureDhtConfig
+{
+    Config node_config;
+    crypto::Identity id;
+};
+
+using ValuesExport = std::pair<InfoHash, Blob>;
+
+using GetCallback = std::function<bool(const std::vector<std::shared_ptr<Value>>& values)>;
+using GetCallbackSimple = std::function<bool(std::shared_ptr<Value> value)>;
+using ShutdownCallback = std::function<void()>;
+
+using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;
+
+typedef bool (*GetCallbackRaw)(std::shared_ptr<Value>, void *user_data);
+
+static constexpr size_t DEFAULT_STORAGE_LIMIT {1024 * 1024 * 64};
+
+GetCallbackSimple bindGetCb(GetCallbackRaw raw_cb, void* user_data);
+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);
+typedef void (*ShutdownCallbackRaw)(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);
+
+
+}

include/opendht/crypto.h

@@ -31,14 +31,13 @@ extern "C" {
 #include <vector>
 #include <memory>
 
+#ifdef _WIN32
+#include <iso646.h>
+#endif
+
 namespace dht {
 namespace crypto {
 
-struct PrivateKey;
-struct Certificate;
-
-typedef std::pair<std::shared_ptr<PrivateKey>, std::shared_ptr<Certificate>> Identity;
-
 class CryptoException : public std::runtime_error {
     public:
         CryptoException(const std::string& str) : std::runtime_error(str) {};
@@ -52,14 +51,10 @@ class DecryptError : public CryptoException {
         DecryptError(const std::string& str = "") : CryptoException(str) {};
 };
 
-/**
- * Generate an RSA key pair (2048 bits) and a certificate.
- * @param name the name used in the generated certificate
- * @param ca if set, the certificate authority that will sign the generated certificate.
- *           If not set, the generated certificate will be a self-signed CA.
- * @param key_length stength of the generated provste key (bits).
- */
-Identity generateIdentity(const std::string& name = "dhtnode", Identity ca = {}, unsigned key_length = 4096);
+struct PrivateKey;
+struct Certificate;
+
+using Identity = std::pair<std::shared_ptr<PrivateKey>, std::shared_ptr<Certificate>>;
 
 /**
  * A public key.
@@ -67,12 +62,22 @@ Identity generateIdentity(const std::string& name = "dhtnode", Identity ca = {},
 struct PublicKey
 {
     PublicKey() {}
+
+    /**
+     * Takes ownership of an existing gnutls_pubkey.
+     */
     PublicKey(gnutls_pubkey_t k) : pk(k) {}
     PublicKey(const Blob& pk);
     PublicKey(PublicKey&& o) noexcept : pk(o.pk) { o.pk = nullptr; };
 
     ~PublicKey();
-    operator bool() const { return pk; }
+    explicit operator bool() const { return pk; }
+    bool operator ==(const PublicKey& o) const {
+        return pk == o.pk || getId() == o.getId();
+    }
+    bool operator !=(const PublicKey& o) const {
+        return !(*this == o);
+    }
 
     PublicKey& operator=(PublicKey&& o) noexcept;
 
@@ -119,13 +124,13 @@ struct PrivateKey
 
     PrivateKey(const Blob& import, const std::string& password = {});
     ~PrivateKey();
-    operator bool() const { return key; }
+    explicit operator bool() const { return key; }
     PublicKey getPublicKey() const;
     Blob serialize(const std::string& password = {}) const;
 
     /**
      * Sign the provided binary object.
-     * @returns the signed data.
+     * @returns the signature data.
      */
     Blob sign(const Blob&) const;
 
@@ -151,7 +156,7 @@ private:
     PrivateKey& operator=(const PrivateKey&) = delete;
     Blob decryptBloc(const uint8_t* src, size_t src_size) const;
 
-    friend dht::crypto::Identity dht::crypto::generateIdentity(const std::string&, dht::crypto::Identity, unsigned key_length);
+    //friend dht::crypto::Identity dht::crypto::generateIdentity(const std::string&, dht::crypto::Identity, unsigned key_length);
 };
 
 struct Certificate {
@@ -202,6 +207,14 @@ struct Certificate {
         return b;
     }
 
+    /**
+     * Import certificate chain (PEM or DER).
+     * Certificates are not checked during import.
+     *
+     * Iterator is the type of an iterator or pointer to
+     * gnutls_x509_crt_t or Blob instances to import, that should be
+     * ordered from subject to issuer.
+     */
     template<typename Iterator>
     void unpack(const Iterator& begin, const Iterator& end)
     {
@@ -218,10 +231,16 @@ struct Certificate {
         *this = first ? std::move(*first) : Certificate();
     }
 
-
     /**
-     * Import certificate chain (PEM or DER),
-     * ordered from subject to issuer
+     * Import certificate chain (PEM or DER).
+     * Certificates are not checked during import.
+     *
+     * Iterator is the type of an iterator or pointer to the bytes of
+     * the certificates to import.
+     *
+     * @param certs list of (begin, end) iterator pairs, pointing to the
+     *              PEM or DER certificate data to import, that should be
+     *              ordered from subject to issuer.
      */
     template<typename Iterator>
     void unpack(const std::vector<std::pair<Iterator, Iterator>>& certs)
@@ -254,7 +273,7 @@ struct Certificate {
 
     void msgpack_unpack(msgpack::object o);
 
-    operator bool() const { return cert; }
+    explicit operator bool() const { return cert; }
     PublicKey getPublicKey() const;
 
     /** Same as getPublicKey().getId() */
@@ -288,24 +307,52 @@ struct Certificate {
      */
     std::string toString(bool chain = true) const;
 
+    static Certificate generate(const PrivateKey& key, const std::string& name = "dhtnode", Identity ca = {}, bool is_ca = false);
+
     gnutls_x509_crt_t cert {};
     std::shared_ptr<Certificate> issuer {};
 private:
     Certificate(const Certificate&) = delete;
     Certificate& operator=(const Certificate&) = delete;
-
-    friend dht::crypto::Identity dht::crypto::generateIdentity(const std::string&, dht::crypto::Identity, unsigned key_length);
 };
 
+
 /**
- * AES-GCM encryption. Key must be 128, 192 or 126 bits long (16, 24 or 32 bytes).
+ * Generate an RSA key pair (4096 bits) and a certificate.
+ * @param name the name used in the generated certificate
+ * @param ca if set, the certificate authority that will sign the generated certificate.
+ *           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);
+
+
+/**
+ * SHA512
+ */
+Blob hash(const Blob& data);
+
+/**
+ * Generates an encryption key from a text password,
+ * making the key longer to bruteforce.
+ * The generated key also depends on a unique salt value of any size,
+ * that can be transmitted in clear, and will be generated if
+ * not provided (32 bytes).
+ */
+Blob stretchKey(const std::string& password, Blob& salt);
+
+/**
+ * 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);
 
 /**
  * AES-GCM decryption.
  */
 Blob aesDecrypt(const Blob& data, const Blob& key);
+Blob aesDecrypt(const Blob& data, const std::string& password);
 
 }
 }

include/opendht/default_types.h

@@ -21,6 +21,16 @@
 
 #include "value.h"
 
+namespace dht {
+enum class ImStatus : uint8_t {
+    NONE = 0,
+    TYPING,
+    RECEIVED,
+    READ
+};
+}
+MSGPACK_ADD_ENUM(dht::ImStatus);
+
 namespace dht {
 
 class DhtMessage : public Value::Serializable<DhtMessage>
@@ -56,7 +66,8 @@ private:
 
 public:
     virtual void unpackValue(const Value& v) override {
-        from = v.owner.getId();
+        if (v.owner)
+            from = v.owner->getId();
         BaseClass::unpackValue(v);
     }
 
@@ -89,6 +100,9 @@ public:
     dht::InfoHash to;
 };
 
+
+
+
 class ImMessage : public SignedValue<ImMessage>
 {
 private:
@@ -110,7 +124,9 @@ public:
     dht::Value::Id id;
     std::string msg;
     long date {0};
-    MSGPACK_DEFINE_MAP(id, msg, date);
+    ImStatus status {ImStatus::NONE};
+
+    MSGPACK_DEFINE_MAP(id, msg, date, status);
 };
 
 class TrustRequest : public EncryptedValue<TrustRequest>

include/opendht/dht.h

@@ -1,34 +1,33 @@
 /*
-Copyright (C) 2009-2014 Juliusz Chroboczek
-Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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.
+ */
 
-Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>,
-            Juliusz Chroboczek <jch@pps.univ–paris–diderot.fr>
-            Simon Désaulniers <sim.desaulniers@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
 
 #pragma once
 
 #include "infohash.h"
 #include "value.h"
+#include "utils.h"
+#include "network_engine.h"
+#include "scheduler.h"
+#include "routing_table.h"
+#include "callbacks.h"
 
 #include <string>
 #include <array>
@@ -40,73 +39,13 @@ THE SOFTWARE.
 #include <algorithm>
 #include <memory>
 
+#ifdef _WIN32
+#include <iso646.h>
+#endif
+
 namespace dht {
 
-using Address = std::pair<sockaddr_storage, socklen_t>;
-
-std::string print_addr(const sockaddr* sa, socklen_t slen);
-std::string print_addr(const sockaddr_storage& ss, socklen_t sslen);
-std::string printAddr(const Address& addr);
-
-struct NodeExport {
-    InfoHash id;
-    sockaddr_storage ss;
-    socklen_t sslen;
-};
-
-struct Node {
-    InfoHash id {};
-    sockaddr_storage ss;
-    socklen_t sslen {0};
-    time_point time {time_point::min()};            /* last time eared about */
-    time_point reply_time {time_point::min()};      /* time of last correct reply received */
-    time_point pinged_time {time_point::min()};     /* time of last message sent */
-    unsigned pinged {0};           /* how many requests we sent since last reply */
-
-    Node() : ss() {
-        std::fill_n((uint8_t*)&ss, sizeof(ss), 0);
-    }
-    Node(const InfoHash& id, const sockaddr* sa, socklen_t salen)
-        : id(id), ss(), sslen(salen) {
-        std::copy_n((const uint8_t*)sa, salen, (uint8_t*)&ss);
-        if ((unsigned)salen < sizeof(ss))
-            std::fill_n((uint8_t*)&ss+salen, sizeof(ss)-salen, 0);
-    }
-    InfoHash getId() const {
-        return id;
-    }
-    std::pair<const sockaddr*, socklen_t> getAddr() const {
-        return {(const sockaddr*)&ss, sslen};
-    }
-    std::string getAddrStr() const {
-        return print_addr(ss, sslen);
-    }
-    bool isExpired(time_point now) const;
-    bool isExpired() const { return isExpired(clock::now()); }
-    bool isGood(time_point now) const;
-    bool isMessagePending(time_point now) const;
-    NodeExport exportNode() const { return NodeExport {id, ss, sslen}; }
-    sa_family_t getFamily() const { return ss.ss_family; }
-
-    void update(const sockaddr* sa, socklen_t salen);
-
-    /** To be called when a message was sent to the node */
-    void requested(time_point now);
-
-    /** To be called when a message was received from the node.
-     Answer should be true if the message was an aswer to a request we made*/
-    void received(time_point now, bool answer);
-
-    friend std::ostream& operator<< (std::ostream& s, const Node& h);
-
-    static constexpr const std::chrono::minutes NODE_GOOD_TIME {120};
-
-    /* The time after which we consider a node to be expirable. */
-    static constexpr const std::chrono::minutes NODE_EXPIRE_TIME {10};
-
-    /* Time for a request to timeout */
-    static constexpr const std::chrono::seconds MAX_RESPONSE_TIME {3};
-};
+struct Request;
 
 /**
  * Main Dht class.
@@ -118,73 +57,13 @@ struct Node {
 class Dht {
 public:
 
-    enum class Status {
-        Disconnected, // 0 nodes
-        Connecting,   // 1+ nodes
-        Connected     // 1+ good nodes
-    };
-
-    struct Config {
-        InfoHash node_id;
-        bool is_bootstrap;
-    };
-
     // [[deprecated]]
     using NodeExport = dht::NodeExport;
 
-    typedef std::function<bool(const std::vector<std::shared_ptr<Value>>& values)> GetCallback;
-    typedef std::function<bool(std::shared_ptr<Value> value)> GetCallbackSimple;
-    typedef std::function<void()> ShutdownCallback;
+    // [[deprecated]]
+    using Status = NodeStatus;
 
-    typedef bool (*GetCallbackRaw)(std::shared_ptr<Value>, void *user_data);
-
-    static constexpr size_t DEFAULT_STORAGE_LIMIT {1024 * 1024 * 64};
-
-    static GetCallbackSimple
-    bindGetCb(GetCallbackRaw raw_cb, void* user_data) {
-        if (not raw_cb) return {};
-        return [=](const std::shared_ptr<Value>& value) {
-            return raw_cb(value, user_data);
-        };
-    }
-    static GetCallback
-    bindGetCb(GetCallbackSimple cb) {
-        if (not cb) return {};
-        return [=](const std::vector<std::shared_ptr<Value>>& values) {
-            for (const auto& v : values)
-                if (not cb(v))
-                    return false;
-            return true;
-        };
-    }
-
-    typedef std::function<void(bool success, const std::vector<std::shared_ptr<Node>>& nodes)> DoneCallback;
-    typedef void (*DoneCallbackRaw)(bool, std::vector<std::shared_ptr<Node>>*, void *user_data);
-    typedef void (*ShutdownCallbackRaw)(void *user_data);
-
-    typedef std::function<void(bool success)> DoneCallbackSimple;
-
-    static ShutdownCallback
-    bindShutdownCb(ShutdownCallbackRaw shutdown_cb_raw, void* user_data) {
-        return [=]() { shutdown_cb_raw(user_data); };
-    }
-    static DoneCallback
-    bindDoneCb(DoneCallbackSimple donecb) {
-        if (not donecb) return {};
-        using namespace std::placeholders;
-        return std::bind(donecb, _1);
-    }
-    static DoneCallback
-    bindDoneCb(DoneCallbackRaw raw_cb, void* user_data) {
-        if (not raw_cb) return {};
-        return [=](bool success, const std::vector<std::shared_ptr<Node>>& nodes) {
-            raw_cb(success, (std::vector<std::shared_ptr<Node>>*)&nodes, user_data);
-        };
-    }
-
-    using want_t = int_fast8_t;
-
-    Dht() {}
+    Dht();
 
     /**
      * Initialise the Dht with two open sockets (for IPv4 and IP6)
@@ -201,9 +80,9 @@ public:
     /**
      * Get the current status of the node for the given family.
      */
-    Status getStatus(sa_family_t af) const;
+    NodeStatus getStatus(sa_family_t af) const;
 
-    Status getStatus() const {
+    NodeStatus getStatus() const {
         return std::max(getStatus(AF_INET), getStatus(AF_INET6));
     }
 
@@ -223,7 +102,7 @@ public:
     /**
      * Enable or disable logging of DHT internal messages
      */
-    void setLoggers(LogMethod&& error = NOLOG, LogMethod&& warn = NOLOG, LogMethod&& debug = NOLOG);
+    void setLoggers(LogMethod error = NOLOG, LogMethod warn = NOLOG, LogMethod debug = NOLOG);
 
     virtual void registerType(const ValueType& type) {
         types[type.id] = type;
@@ -257,15 +136,15 @@ public:
                         cb and donecb won't be called again afterward.
      * @param f a filter function used to prefilter values.
      */
-    void get(const InfoHash& key, GetCallback cb, DoneCallback donecb=nullptr, Value::Filter f = Value::AllFilter());
-    void get(const InfoHash& key, GetCallback cb, DoneCallbackSimple donecb, Value::Filter f = Value::AllFilter()) {
-        get(key, cb, bindDoneCb(donecb), f);
+    virtual void get(const InfoHash& key, GetCallback cb, DoneCallback donecb={}, Value::Filter&& f={});
+    virtual void get(const InfoHash& key, GetCallback cb, DoneCallbackSimple donecb={}, Value::Filter&& f={}) {
+        get(key, cb, bindDoneCb(donecb), std::forward<Value::Filter>(f));
     }
-    void get(const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb=nullptr, Value::Filter f = Value::AllFilter()) {
-        get(key, bindGetCb(cb), donecb, f);
+    virtual void get(const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb={}, Value::Filter&& f={}) {
+        get(key, bindGetCb(cb), donecb, std::forward<Value::Filter>(f));
     }
-    void get(const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter f = Value::AllFilter()) {
-        get(key, bindGetCb(cb), bindDoneCb(donecb), f);
+    virtual void get(const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter&& f={}) {
+        get(key, bindGetCb(cb), bindDoneCb(donecb), std::forward<Value::Filter>(f));
     }
 
     /**
@@ -288,16 +167,35 @@ public:
      * reannounced on a regular basis.
      * User can call #cancelPut(InfoHash, Value::Id) to cancel a put operation.
      */
-    void put(const InfoHash& key, std::shared_ptr<Value>, DoneCallback cb=nullptr, time_point created=time_point::max());
-    void put(const InfoHash& key, const std::shared_ptr<Value>& v, DoneCallbackSimple cb, time_point created=time_point::max()) {
-        put(key, v, bindDoneCb(cb), created);
+    void put(const InfoHash& key,
+            std::shared_ptr<Value>,
+            DoneCallback cb=nullptr,
+            time_point created=time_point::max(),
+            bool permanent = false);
+    void put(const InfoHash& key,
+            const std::shared_ptr<Value>& v,
+            DoneCallbackSimple cb,
+            time_point created=time_point::max(),
+            bool permanent = false)
+    {
+        put(key, v, bindDoneCb(cb), created, permanent);
     }
 
-    void put(const InfoHash& key, Value&& v, DoneCallback cb=nullptr, time_point created=time_point::max()) {
-        put(key, std::make_shared<Value>(std::move(v)), cb, created);
+    void put(const InfoHash& key,
+            Value&& v,
+            DoneCallback cb=nullptr,
+            time_point created=time_point::max(),
+            bool permanent = false)
+    {
+        put(key, std::make_shared<Value>(std::move(v)), cb, created, permanent);
     }
-    void put(const InfoHash& key, Value&& v, DoneCallbackSimple cb, time_point created=time_point::max()) {
-        put(key, std::forward<Value>(v), bindDoneCb(cb), created);
+    void put(const InfoHash& key,
+            Value&& v,
+            DoneCallbackSimple cb,
+            time_point created=time_point::max(),
+            bool permanent = false)
+    {
+        put(key, std::forward<Value>(v), bindDoneCb(cb), created, permanent);
     }
 
     /**
@@ -323,12 +221,12 @@ public:
      *
      * @return a token to cancel the listener later.
      */
-    size_t listen(const InfoHash&, GetCallback, Value::Filter = Value::AllFilter());
-    size_t listen(const InfoHash& key, GetCallbackSimple cb, Value::Filter f = Value::AllFilter()) {
-        return listen(key, bindGetCb(cb), f);
+    virtual size_t listen(const InfoHash&, GetCallback, Value::Filter&&={});
+    virtual size_t listen(const InfoHash& key, GetCallbackSimple cb, Value::Filter f={}) {
+        return listen(key, bindGetCb(cb), std::forward<Value::Filter>(f));
     }
 
-    bool cancelListen(const InfoHash&, size_t token);
+    virtual bool cancelListen(const InfoHash&, size_t token);
 
     /**
      * Inform the DHT of lower-layer connectivity changes.
@@ -343,23 +241,18 @@ public:
      */
     std::vector<NodeExport> exportNodes();
 
-    typedef std::pair<InfoHash, Blob> ValuesExport;
     std::vector<ValuesExport> exportValues() const;
     void importValues(const std::vector<ValuesExport>&);
 
-    int getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return, unsigned *incoming_return) const;
+    int getNodesStats(sa_family_t af, unsigned *good_return, unsigned *dubious_return, unsigned *cached_return,
+            unsigned *incoming_return) const;
     std::string getStorageLog() const;
     std::string getRoutingTablesLog(sa_family_t) const;
     std::string getSearchesLog(sa_family_t) const;
 
     void dumpTables() const;
     std::vector<unsigned> getNodeMessageStats(bool in = false) {
-        auto stats = in ? std::vector<unsigned>{in_stats.ping,  in_stats.find,  in_stats.get,  in_stats.listen,  in_stats.put}
-                  : std::vector<unsigned>{out_stats.ping, out_stats.find, out_stats.get, out_stats.listen, out_stats.put};
-        if (in) { in_stats = {}; }
-        else { out_stats = {}; }
-
-        return stats;
+        return network_engine.getNodeMessageStats(in);
     }
 
     /**
@@ -377,38 +270,32 @@ public:
         return {total_store_size, total_values};
     }
 
-    /* This must be provided by the user. */
-    static bool isBlacklisted(const sockaddr*, socklen_t) { return false; }
-
     std::vector<Address> getPublicAddress(sa_family_t family = 0);
 
 protected:
-    LogMethod DHT_DEBUG = NOLOG;
-    LogMethod DHT_WARN = NOLOG;
-    LogMethod DHT_ERROR = NOLOG;
+    Logger DHT_LOG;
 
 private:
 
-    static constexpr unsigned TARGET_NODES {8};
-
     /* When performing a search, we search for up to SEARCH_NODES closest nodes
        to the destination, and use the additional ones to backtrack if any of
        the target 8 turn out to be dead. */
     static constexpr unsigned SEARCH_NODES {14};
-    static constexpr unsigned LISTEN_NODES {3};
+
+    /* Concurrent requests during a search */
+    static constexpr unsigned SEARCH_REQUESTS {4};
+
+    /* Number of listening nodes */
+    static constexpr unsigned LISTEN_NODES {4};
 
     /* The maximum number of values we store for a given hash. */
-    static constexpr unsigned MAX_VALUES {2048};
+    static constexpr unsigned MAX_VALUES {1024};
 
     /* The maximum number of hashes we're willing to track. */
     static constexpr unsigned MAX_HASHES {16384};
 
     /* The maximum number of searches we keep data about. */
-    static constexpr unsigned MAX_SEARCHES {128};
-
-    /* The time after which we can send get requests for
-       a search in case of no answers. */
-    static constexpr std::chrono::seconds SEARCH_GET_STEP {3};
+    static constexpr unsigned MAX_SEARCHES {2048};
 
     static constexpr std::chrono::minutes MAX_STORAGE_MAINTENANCE_EXPIRE_TIME {10};
 
@@ -420,165 +307,9 @@ private:
 
     static constexpr std::chrono::seconds REANNOUNCE_MARGIN {5};
 
-    static constexpr std::chrono::seconds UDP_REPLY_TIME {15};
-
-    /* The maximum number of nodes that we snub.  There is probably little
-        reason to increase this value. */
-    static constexpr unsigned BLACKLISTED_MAX {10};
-
-    static constexpr long unsigned MAX_REQUESTS_PER_SEC {1600};
-
     static constexpr size_t TOKEN_SIZE {64};
 
-    static const std::string my_v;
-
-    struct NodeCache {
-        std::shared_ptr<Node> getNode(const InfoHash& id, sa_family_t family);
-        std::shared_ptr<Node> getNode(const InfoHash& id, const sockaddr* sa, socklen_t sa_len, time_point now, int confirmed);
-        void putNode(std::shared_ptr<Node> n);
-
-        /**
-         * Reset the connectivity state of every node,
-         * Giving them a new chance if they where expired.
-         * To use in case of connectivity change etc.
-         */
-        void clearBadNodes(sa_family_t family = 0);
-    private:
-        std::list<std::weak_ptr<Node>> cache_4;
-        std::list<std::weak_ptr<Node>> cache_6;
-    };
-
-    struct Bucket {
-        Bucket() : cached() {}
-        Bucket(sa_family_t af, const InfoHash& f = {}, time_point t = time_point::min())
-            : 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 {};
-        sockaddr_storage cached;  /* the address of a likely candidate */
-        socklen_t cachedlen {0};
-
-        /** Return a random node in a bucket. */
-        std::shared_ptr<Node> randomNode();
-    };
-
-    class RoutingTable : public std::list<Bucket> {
-    public:
-        using std::list<Bucket>::list;
-
-        InfoHash middle(const RoutingTable::const_iterator&) const;
-
-        std::vector<std::shared_ptr<Node>> findClosestNodes(const InfoHash id, size_t count = TARGET_NODES) const;
-
-        RoutingTable::iterator findBucket(const InfoHash& id);
-        RoutingTable::const_iterator findBucket(const InfoHash& id) const;
-
-        /**
-         * Return true if the id is in the bucket's range.
-         */
-        inline bool contains(const RoutingTable::const_iterator& bucket, const InfoHash& id) const {
-            return InfoHash::cmp(bucket->first, id) <= 0
-                && (std::next(bucket) == end() || InfoHash::cmp(id, std::next(bucket)->first) < 0);
-        }
-
-        /**
-         * Return true if the table has no bucket ore one empty buket.
-         */
-        inline bool isEmpty() const {
-            return empty() || (size() == 1 && front().nodes.empty());
-        }
-
-        /**
-         * Return a random id in the bucket's range.
-         */
-        InfoHash randomId(const RoutingTable::const_iterator& bucket) const;
-
-        unsigned depth(const RoutingTable::const_iterator& bucket) const;
-
-        /**
-         * Split a bucket in two equal parts.
-         */
-        bool split(const RoutingTable::iterator& b);
-    };
-
-    struct SearchNode {
-        SearchNode(std::shared_ptr<Node> node) : node(node) {}
-
-        struct RequestStatus {
-            time_point request_time {time_point::min()};    /* the time of the last unanswered request */
-            time_point reply_time {time_point::min()};      /* the time of the last confirmation */
-            RequestStatus() {};
-            RequestStatus(time_point q, time_point a = time_point::min()) : request_time(q), reply_time(a) {};
-            bool expired(time_point now) const {
-                return reply_time < request_time && now > request_time + Node::MAX_RESPONSE_TIME;
-            }
-            bool pending(time_point now) const {
-                return reply_time < request_time && now - request_time <= Node::MAX_RESPONSE_TIME;
-            }
-        };
-        typedef std::map<Value::Id, RequestStatus> AnnounceStatusMap;
-
-        /**
-         * Can we use this node to listen/announce now ?
-         */
-        bool isSynced(time_point now) const {
-            return not node->isExpired(now) and
-                   getStatus.reply_time >= now - Node::NODE_EXPIRE_TIME;
-        }
-        bool canGet(time_point now, time_point update) const {
-            return not node->isExpired(now) and
-                   (now > getStatus.reply_time + Node::NODE_EXPIRE_TIME or update > getStatus.reply_time) and
-                   now > getStatus.request_time + Node::MAX_RESPONSE_TIME;
-        }
-
-        bool isAnnounced(Value::Id vid, const ValueType& type, time_point now) const {
-            auto ack = acked.find(vid);
-            if (ack == acked.end()) {
-                return false;
-            }
-            return ack->second.reply_time + type.expiration > now;
-        }
-        bool isListening(time_point now) const {
-            return listenStatus.reply_time + LISTEN_EXPIRE_TIME > now;
-        }
-
-        time_point getAnnounceTime(AnnounceStatusMap::const_iterator ack, const ValueType& type) const {
-            if (ack == acked.end())
-                return time_point::min();
-            return std::max(
-                ack->second.reply_time + type.expiration - REANNOUNCE_MARGIN,
-                ack->second.request_time + Node::MAX_RESPONSE_TIME
-            );
-        }
-        time_point getAnnounceTime(Value::Id vid, const ValueType& type) const {
-            return getAnnounceTime(acked.find(vid), type);
-        }
-        time_point getListenTime() const {
-            return std::max(
-                listenStatus.reply_time + LISTEN_EXPIRE_TIME - REANNOUNCE_MARGIN,
-                listenStatus.request_time + Node::MAX_RESPONSE_TIME
-            );
-        }
-
-        std::shared_ptr<Node> node {};
-
-        RequestStatus getStatus {};    /* get/sync status */
-        RequestStatus listenStatus {};
-        AnnounceStatusMap acked {};    /* announcement status for a given value id */
-
-        Blob token {};
-
-        /**
-         * A search node is candidate if the search is/was synced and this node is a new candidate for inclusion
-         *
-         */
-        bool candidate {false};
-
-        // Generic temporary flag.
-        // Must be reset to false after use by the algorithm.
-        bool pending {false};
-    };
+    struct SearchNode;
 
     /**
      * A single "get" operation data
@@ -594,6 +325,7 @@ private:
      * A single "put" operation data
      */
     struct Announce {
+        bool permanent;
         std::shared_ptr<Value> value;
         time_point created;
         DoneCallback callback;
@@ -608,77 +340,10 @@ private:
     };
 
     /**
-     * A search is a pointer to the nodes we think are responsible
+     * A search is a list of the nodes we think are responsible
      * for storing values for a given hash.
      */
-    struct Search {
-        InfoHash id {};
-        sa_family_t af;
-
-        uint16_t tid;
-        time_point step_time {time_point::min()};           /* the time of the last search step */
-        time_point get_step_time {time_point::min()};       /* the time of the last get step */
-
-        bool expired {false};              /* no node, or all nodes expired */
-        bool done {false};                 /* search is over, cached for later */
-        bool refilled {false};
-
-        /* search routing table */
-        std::vector<SearchNode> nodes {};
-
-        /* pending puts */
-        std::vector<Announce> announce {};
-
-        /* pending gets */
-        std::vector<Get> callbacks {};
-
-        /* listeners */
-        std::map<size_t, LocalListener> listeners {};
-        size_t listener_token = 1;
-
-        /**
-         * @returns true if the node was not present and added to the search
-         */
-        bool insertNode(std::shared_ptr<Node> n, time_point now, const Blob& token={});
-        unsigned insertBucket(const Bucket&, time_point now);
-
-        /**
-         * Can we use this search to announce ?
-         */
-        bool isSynced(time_point now) const;
-
-        time_point getLastGetTime() const;
-
-        /**
-         * Is this get operation done ?
-         */
-        bool isDone(const Get& get, time_point now) const;
-
-        time_point getUpdateTime(time_point now) const;
-
-        bool isAnnounced(Value::Id id, const ValueType& type, time_point now) const;
-        bool isListening(time_point now) const;
-
-        /**
-         * ret = 0 : no announce required.
-         * ret > 0 : (re-)announce required at time ret.
-         */
-        time_point getAnnounceTime(const std::map<ValueType::Id, ValueType>& types, time_point now) const;
-
-        /**
-         * ret = 0 : no listen required.
-         * ret > 0 : (re-)announce required at time ret.
-         */
-        time_point getListenTime(time_point now) const;
-
-        time_point getNextStepTime(const std::map<ValueType::Id, ValueType>& types, time_point now) const;
-
-        bool removeExpiredNode(time_point now);
-
-        unsigned refill(const RoutingTable&, time_point now);
-
-        std::vector<std::shared_ptr<Node>> getNodes() const;
-    };
+    struct Search;
 
     struct ValueStorage {
         std::shared_ptr<Value> data {};
@@ -692,144 +357,23 @@ private:
      * Foreign nodes asking for updates about an InfoHash.
      */
     struct Listener {
-        InfoHash id {};
-        sockaddr_storage ss;
-        socklen_t sslen {};
-        uint16_t tid {};
+        size_t rid {};
         time_point time {};
 
-        /*constexpr*/ Listener() : ss() {}
-        Listener(const InfoHash& id, const sockaddr *from, socklen_t fromlen, uint16_t ttid, time_point t) : id(id), ss(), sslen(fromlen), tid(ttid), time(t) {
-            memcpy(&ss, from, fromlen);
-        }
-        void refresh(const sockaddr *from, socklen_t fromlen, uint16_t ttid, time_point t) {
-            memcpy(&ss, from, fromlen);
-            sslen = fromlen;
-            tid = ttid;
+        /*constexpr*/ Listener(size_t rid, time_point t) : rid(rid), time(t) {}
+
+        void refresh(size_t tid, time_point t) {
+            rid = tid;
             time = t;
         }
     };
 
-    struct Storage {
-        InfoHash id;
-        time_point maintenance_time {};
-        std::vector<Listener> listeners {};
-        std::map<size_t, LocalListener> local_listeners {};
-        size_t listener_token {1};
-
-        Storage() {}
-        Storage(InfoHash id, time_point now) : id(id), maintenance_time(now+MAX_STORAGE_MAINTENANCE_EXPIRE_TIME) {}
-
-        bool empty() const {
-            return values.empty();
-        }
-
-        void clear();
-
-        size_t valueCount() const {
-            return values.size();
-        }
-
-        size_t totalSize() const {
-            return total_size;
-        }
-
-        const std::vector<ValueStorage>& getValues() const { return values; }
-
-        std::shared_ptr<Value> getById(Value::Id vid) const {
-            for (auto& v : values)
-                if (v.data->id == vid) return v.data;
-            return {};
-        }
-
-        std::vector<std::shared_ptr<Value>> get(Value::Filter f = {}) const {
-            std::vector<std::shared_ptr<Value>> newvals {};
-            if (not f) newvals.reserve(values.size());
-            for (auto& v : values) {
-                if (not f || f(*v.data))
-                    newvals.push_back(v.data);
-            }
-            return newvals;
-        }
-
-        /**
-         * Stores a new value in this storage, or replace a previous value
-         *
-         * @return <storage, change_size, change_value_num>
-         *      storage: set if a change happened
-         *      change_size: size difference
-         *      change_value_num: change of value number (0 or 1)
-         */
-        std::tuple<ValueStorage*, ssize_t, ssize_t>
-        store(const std::shared_ptr<Value>& value, time_point created, ssize_t size_left);
-
-        std::pair<ssize_t, ssize_t> expire(const std::map<ValueType::Id, ValueType>& types, time_point now);
-
-    private:
-        std::vector<ValueStorage> values {};
-        size_t total_size {};
-    };
-
-    enum class MessageType {
-        Error = 0,
-        Reply,
-        Ping,
-        FindNode,
-        GetValues,
-        AnnounceValue,
-        Listen
-    };
-
-    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 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> {
-        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;
-            }
-        }
-
-        bool matches(const TransPrefix prefix, uint16_t *seqno_return = nullptr) const {
-            if (std::equal(begin(), begin()+2, prefix.begin())) {
-                if (seqno_return)
-                    *seqno_return = *reinterpret_cast<const uint16_t*>(&(*this)[2]);
-                return true;
-            } else
-                return false;
-        }
-
-        unsigned length {4};
-    };
+    struct Storage;
 
     // prevent copy
     Dht(const Dht&) = delete;
     Dht& operator=(const Dht&) = delete;
 
-    // socket descriptors
-    int dht_socket {-1};
-    int dht_socket6 {-1};
-
     InfoHash myid {};
 
     std::array<uint8_t, 8> secret {{}};
@@ -838,9 +382,6 @@ private:
     // registred types
     std::map<ValueType::Id, ValueType> types;
 
-    // cache of nodes not in the main routing table but used for searches
-    NodeCache cache;
-
     // are we a bootstrap node ?
     // note: Any running node can be used as a bootstrap node.
     //       Only nodes running only as bootstrap nodes should
@@ -851,12 +392,13 @@ private:
     RoutingTable buckets {};
     RoutingTable buckets6 {};
 
-    std::vector<Storage> store {};
+    std::vector<Storage> store;
     size_t total_values {0};
     size_t total_store_size {0};
     size_t max_store_size {DEFAULT_STORAGE_LIMIT};
 
-    std::list<Search> searches {};
+    std::map<InfoHash, std::shared_ptr<Search>> searches4 {};
+    std::map<InfoHash, std::shared_ptr<Search>> searches6 {};
     uint16_t search_id {0};
 
     // map a global listen token to IPv4, IPv6 specific listen tokens.
@@ -864,73 +406,16 @@ private:
     std::map<size_t, std::tuple<size_t, size_t, size_t>> listeners {};
     size_t listener_token {1};
 
-    sockaddr_storage blacklist[BLACKLISTED_MAX] {};
-    unsigned next_blacklisted = 0;
-
     // timing
-    time_point now;
+    Scheduler scheduler {};
+    std::shared_ptr<Scheduler::Job> nextNodesConfirmation {};
     time_point mybucket_grow_time {time_point::min()}, mybucket6_grow_time {time_point::min()};
-    time_point expire_stuff_time {time_point::min()};
-    time_point search_time {time_point::max()};
-    time_point confirm_nodes_time {time_point::min()};
-    time_point rotate_secrets_time {time_point::min()};
-    std::queue<time_point> rate_limit_time {};
+
+    NetworkEngine network_engine;
 
     using ReportedAddr = std::pair<unsigned, Address>;
     std::vector<ReportedAddr> reported_addr;
 
-    // Networking & packet handling
-    int send(const char* buf, size_t len, int flags, const sockaddr*, socklen_t);
-    int sendPing(const sockaddr*, socklen_t, TransId tid);
-    int sendPong(const sockaddr*, socklen_t, TransId tid);
-
-    int sendFindNode (const sockaddr*, socklen_t, TransId tid, const InfoHash& target, want_t want, int confirm);
-    int sendGetValues(const sockaddr*, socklen_t, TransId tid, const InfoHash& target, want_t want, int confirm);
-
-    int sendNodesValues(const sockaddr*, socklen_t, TransId tid,
-                              const uint8_t *nodes, unsigned nodes_len,
-                              const uint8_t *nodes6, unsigned nodes6_len,
-                              const std::vector<ValueStorage>& st, const Blob& token);
-
-    int sendClosestNodes(const sockaddr*, socklen_t, TransId tid,
-                               const InfoHash& id, want_t want, const Blob& token={},
-                               const std::vector<ValueStorage>& st = {});
-
-
-    int sendListen(const sockaddr*, socklen_t, TransId,
-                            const InfoHash&, const Blob& token, int confirm);
-
-    int sendListenConfirmation(const sockaddr*, socklen_t, TransId);
-
-    int sendAnnounceValue(const sockaddr*, socklen_t, TransId, const InfoHash&,
-            const Value&, time_point created, const Blob& token,
-            int confirm);
-
-    int sendValueAnnounced(const sockaddr*, socklen_t, TransId, Value::Id);
-
-    int sendError(const sockaddr*, socklen_t, TransId tid, uint16_t code, const char *message, bool include_id=false);
-
-    void processMessage(const uint8_t *buf, size_t buflen, const sockaddr *from, socklen_t fromlen);
-
-    struct ParsedMessage {
-        MessageType type;
-        InfoHash id;
-        InfoHash info_hash;
-        InfoHash target;
-        TransId tid;
-        Blob token;
-        Value::Id value_id;
-        time_point created { time_point::max() };
-        Blob nodes4;
-        Blob nodes6;
-        std::vector<std::shared_ptr<Value>> values;
-        want_t want;
-        uint16_t error_code;
-        std::string ua;
-        Address addr;
-        void msgpack_unpack(msgpack::object o);
-    };
-
     void rotateSecrets();
 
     Blob makeToken(const sockaddr *sa, bool old) const;
@@ -939,18 +424,10 @@ private:
     void reportedAddr(const sockaddr *sa, socklen_t sa_len);
 
     // Storage
-    decltype(Dht::store)::iterator findStorage(const InfoHash& id) {
-        return std::find_if(store.begin(), store.end(), [&](const Storage& st) {
-            return st.id == id;
-        });
-    }
-    decltype(Dht::store)::const_iterator findStorage(const InfoHash& id) const {
-        return std::find_if(store.cbegin(), store.cend(), [&](const Storage& st) {
-            return st.id == id;
-        });
-    }
+    decltype(Dht::store)::iterator findStorage(const InfoHash& id);
+    decltype(Dht::store)::const_iterator findStorage(const InfoHash& id) const;
 
-    void storageAddListener(const InfoHash& id, const InfoHash& node, const sockaddr *from, socklen_t fromlen, uint16_t tid);
+    void storageAddListener(const InfoHash& id, const std::shared_ptr<Node>& node, size_t tid);
     bool storageStore(const InfoHash& id, const std::shared_ptr<Value>& value, time_point created);
     void expireStorage();
     void storageChanged(Storage& st, ValueStorage&);
@@ -960,6 +437,7 @@ private:
      * node is too far from the target, values are sent to the appropriate
      * nodes.
      */
+    void dataPersistence();
     size_t maintainStorage(InfoHash id, bool force=false, DoneCallback donecb=nullptr);
 
     // Buckets
@@ -983,22 +461,14 @@ private:
     void expireBuckets(RoutingTable&);
     int sendCachedPing(Bucket& b);
     bool bucketMaintenance(RoutingTable&);
-    static unsigned insertClosestNode(uint8_t *nodes, unsigned numnodes, const InfoHash& id, const Node& n);
-    unsigned bufferClosestNodes(uint8_t *nodes, unsigned numnodes, const InfoHash& id, const Bucket& b) const;
     void dumpBucket(const Bucket& b, std::ostream& out) const;
 
     // Nodes
-    std::shared_ptr<Node> newNode(const InfoHash& id, const sockaddr*, socklen_t, int confirm, const sockaddr* addr=nullptr, socklen_t addr_length=0);
+    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 pinged(Node& n, Bucket *b = nullptr);
-
-    void blacklistNode(const InfoHash* id, const sockaddr*, socklen_t);
-    bool isNodeBlacklisted(const sockaddr*, socklen_t) const;
-    static bool isMartian(const sockaddr*, socklen_t);
-
     // Searches
 
     /**
@@ -1006,36 +476,47 @@ private:
      * specified infohash (id), using the specified IP version (IPv4 or IPv6).
      * The values can be filtered by an arbitrary provided filter.
      */
-    Search* search(const InfoHash& id, sa_family_t af, GetCallback = nullptr, DoneCallback = nullptr, Value::Filter = Value::AllFilter());
-    void announce(const InfoHash& id, sa_family_t af, std::shared_ptr<Value> value, DoneCallback callback, time_point created=time_point::max());
+    std::shared_ptr<Search> search(const InfoHash& id, sa_family_t af, GetCallback = nullptr, DoneCallback = nullptr, Value::Filter = Value::AllFilter());
+    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());
 
-    std::list<Search>::iterator newSearch();
     void bootstrapSearch(Search& sr);
     Search *findSearch(unsigned short tid, sa_family_t af);
     void expireSearches();
 
+    void confirmNodes();
+    void expire();
+
     /**
      * If update is true, this method will also send message to synced but non-updated search nodes.
      */
-    SearchNode* searchSendGetValues(Search& sr, SearchNode *n = nullptr, bool update = true);
+    SearchNode* searchSendGetValues(std::shared_ptr<Search> sr, SearchNode *n = nullptr, bool update = true);
 
-    void searchStep(Search& sr);
+    void searchStep(std::shared_ptr<Search> sr);
     void dumpSearch(const Search& sr, std::ostream& out) const;
 
-    bool rateLimit();
     bool neighbourhoodMaintenance(RoutingTable&);
 
-    struct MessageStats {
-        unsigned ping {0};
-        unsigned find {0};
-        unsigned get {0};
-        unsigned put {0};
-        unsigned listen {0};
-    };
-
-    MessageStats in_stats {}, out_stats {};
+    void processMessage(const uint8_t *buf, size_t buflen, const sockaddr *from, socklen_t fromlen);
 
+    void onError(std::shared_ptr<Request> node, DhtProtocolException e);
+    /* when our address is reported by a distant peer. */
+    void onReportedAddr(const InfoHash& id, sockaddr* sa , socklen_t salen);
+    /* when we receive a ping request */
+    NetworkEngine::RequestAnswer onPing(std::shared_ptr<Node> node);
+    /* when we receive a "find node" request */
+    NetworkEngine::RequestAnswer onFindNode(std::shared_ptr<Node> node, InfoHash& hash, want_t want);
+    void onFindNodeDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search> sr);
+    /* when we receive a "get values" request */
+    NetworkEngine::RequestAnswer onGetValues(std::shared_ptr<Node> node, InfoHash& hash, want_t want);
+    void onGetValuesDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search> sr);
+    /* when we receive a listen request */
+    NetworkEngine::RequestAnswer onListen(std::shared_ptr<Node> node, InfoHash& hash, Blob& token, size_t rid);
+    void onListenDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search>& sr);
+    /* when we receive an announce request */
+    NetworkEngine::RequestAnswer onAnnounce(std::shared_ptr<Node> node,
+            InfoHash& hash, Blob& token, std::vector<std::shared_ptr<Value>> v, time_point created);
+    void onAnnounceDone(const Request& status, NetworkEngine::RequestAnswer& a, std::shared_ptr<Search>& sr);
 };
 
 }

include/opendht/dhtrunner.h

@@ -20,7 +20,10 @@
 
 #pragma once
 
-#include "securedht.h"
+//#include "securedht.h"
+#include "infohash.h"
+#include "value.h"
+#include "callbacks.h"
 
 #include <thread>
 #include <mutex>
@@ -33,6 +36,10 @@
 
 namespace dht {
 
+struct Node;
+class SecureDht;
+struct SecureDhtConfig;
+
 /**
  * Provides a thread-safe interface to run the (secure) DHT.
  * The class will open sockets on the provided port and will
@@ -42,28 +49,28 @@ namespace dht {
 class DhtRunner {
 
 public:
-    typedef std::function<void(Dht::Status, Dht::Status)> StatusCallback;
+    typedef std::function<void(NodeStatus, NodeStatus)> StatusCallback;
 
     DhtRunner();
     virtual ~DhtRunner();
 
-    void get(InfoHash id, Dht::GetCallbackSimple cb, Dht::DoneCallback donecb={}, Value::Filter f = Value::AllFilter()) {
-        get(id, Dht::bindGetCb(cb), donecb, f);
+    void get(InfoHash id, GetCallbackSimple cb, DoneCallback donecb={}, Value::Filter f = Value::AllFilter()) {
+        get(id, bindGetCb(cb), donecb, f);
     }
 
-    void get(InfoHash id, Dht::GetCallbackSimple cb, Dht::DoneCallbackSimple donecb={}, Value::Filter f = Value::AllFilter()) {
-        get(id, Dht::bindGetCb(cb), donecb, f);
+    void get(InfoHash id, GetCallbackSimple cb, DoneCallbackSimple donecb={}, Value::Filter f = Value::AllFilter()) {
+        get(id, bindGetCb(cb), donecb, f);
     }
 
-    void get(InfoHash hash, Dht::GetCallback vcb, Dht::DoneCallback dcb, Value::Filter f={});
+    void get(InfoHash hash, GetCallback vcb, DoneCallback dcb, Value::Filter f={});
 
-    void get(InfoHash id, Dht::GetCallback cb, Dht::DoneCallbackSimple donecb={}, Value::Filter f = Value::AllFilter()) {
-        get(id, cb, Dht::bindDoneCb(donecb), f);
+    void get(InfoHash id, GetCallback cb, DoneCallbackSimple donecb={}, Value::Filter f = Value::AllFilter()) {
+        get(id, cb, bindDoneCb(donecb), f);
     }
-    void get(const std::string& key, Dht::GetCallback vcb, Dht::DoneCallbackSimple dcb={}, Value::Filter f = Value::AllFilter());
+    void get(const std::string& key, GetCallback vcb, DoneCallbackSimple dcb={}, Value::Filter f = Value::AllFilter());
 
     template <class T>
-    void get(InfoHash hash, std::function<bool(std::vector<T>&&)> cb, Dht::DoneCallbackSimple dcb={})
+    void get(InfoHash hash, std::function<bool(std::vector<T>&&)> cb, DoneCallbackSimple dcb={})
     {
         get(hash, [=](const std::vector<std::shared_ptr<Value>>& vals) {
             return cb(unpackVector<T>(vals));
@@ -72,7 +79,7 @@ public:
         getFilterSet<T>());
     }
     template <class T>
-    void get(InfoHash hash, std::function<bool(T&&)> cb, Dht::DoneCallbackSimple dcb={})
+    void get(InfoHash hash, std::function<bool(T&&)> cb, DoneCallbackSimple dcb={})
     {
         get(hash, [=](const std::vector<std::shared_ptr<Value>>& vals) {
             for (const auto& v : vals) {
@@ -115,10 +122,10 @@ public:
         return p->get_future();
     }
 
-    std::future<size_t> listen(InfoHash key, Dht::GetCallback vcb, Value::Filter f = Value::AllFilter());
-    std::future<size_t> listen(const std::string& key, Dht::GetCallback vcb, Value::Filter f = Value::AllFilter());
-    std::future<size_t> listen(InfoHash key, Dht::GetCallbackSimple cb, Value::Filter f = Value::AllFilter()) {
-        return listen(key, Dht::bindGetCb(cb), f);
+    std::future<size_t> listen(InfoHash key, GetCallback vcb, Value::Filter f = Value::AllFilter());
+    std::future<size_t> listen(const std::string& key, GetCallback vcb, Value::Filter f = Value::AllFilter());
+    std::future<size_t> listen(InfoHash key, GetCallbackSimple cb, Value::Filter f = Value::AllFilter()) {
+        return listen(key, bindGetCb(cb), f);
     }
 
     template <class T>
@@ -149,40 +156,40 @@ public:
     void cancelListen(InfoHash h, size_t token);
     void cancelListen(InfoHash h, std::shared_future<size_t> token);
 
-    void put(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallback cb={});
-    void put(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallbackSimple cb) {
-        put(hash, value, Dht::bindDoneCb(cb));
+    void put(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb={}, bool permanent = false);
+    void put(InfoHash hash, std::shared_ptr<Value> value, DoneCallbackSimple cb, bool permanent = false) {
+        put(hash, value, bindDoneCb(cb), permanent);
     }
 
-    void put(InfoHash hash, Value&& value, Dht::DoneCallback cb={});
-    void put(InfoHash hash, Value&& value, Dht::DoneCallbackSimple cb) {
-        put(hash, std::forward<Value>(value), Dht::bindDoneCb(cb));
+    void put(InfoHash hash, Value&& value, DoneCallback cb={}, bool permanent = false);
+    void put(InfoHash hash, Value&& value, DoneCallbackSimple cb, bool permanent = false) {
+        put(hash, std::forward<Value>(value), bindDoneCb(cb), permanent);
     }
-    void put(const std::string& key, Value&& value, Dht::DoneCallbackSimple cb={});
+    void put(const std::string& key, Value&& value, DoneCallbackSimple cb={}, bool permanent = false);
 
     void cancelPut(const InfoHash& h, const Value::Id& id);
 
-    void putSigned(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallback cb={});
-    void putSigned(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallbackSimple cb) {
-        putSigned(hash, value, Dht::bindDoneCb(cb));
+    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb={});
+    void putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallbackSimple cb) {
+        putSigned(hash, value, bindDoneCb(cb));
     }
 
-    void putSigned(InfoHash hash, Value&& value, Dht::DoneCallback cb={});
-    void putSigned(InfoHash hash, Value&& value, Dht::DoneCallbackSimple cb) {
-        putSigned(hash, std::forward<Value>(value), Dht::bindDoneCb(cb));
+    void putSigned(InfoHash hash, Value&& value, DoneCallback cb={});
+    void putSigned(InfoHash hash, Value&& value, DoneCallbackSimple cb) {
+        putSigned(hash, std::forward<Value>(value), bindDoneCb(cb));
     }
-    void putSigned(const std::string& key, Value&& value, Dht::DoneCallbackSimple cb={});
+    void putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb={});
 
-    void putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, Dht::DoneCallback cb={});
-    void putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, Dht::DoneCallbackSimple cb) {
-        putEncrypted(hash, to, value, Dht::bindDoneCb(cb));
+    void putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb={});
+    void putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallbackSimple cb) {
+        putEncrypted(hash, to, value, bindDoneCb(cb));
     }
 
-    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, Dht::DoneCallback cb={});
-    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, Dht::DoneCallbackSimple cb) {
-        putEncrypted(hash, to, std::forward<Value>(value), Dht::bindDoneCb(cb));
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb={});
+    void putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallbackSimple cb) {
+        putEncrypted(hash, to, std::forward<Value>(value), bindDoneCb(cb));
     }
-    void putEncrypted(const std::string& key, InfoHash to, Value&& value, Dht::DoneCallback cb={});
+    void putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb={});
 
     void bootstrap(const char* host, const char* service);
     void bootstrap(const std::vector<std::pair<sockaddr_storage, socklen_t>>& nodes);
@@ -195,31 +202,11 @@ public:
      */
     void connectivityChanged();
 
-    void dumpTables() const
-    {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->dumpTables();
-    }
+    void dumpTables() const;
 
-    InfoHash getId() const {
-        if (!dht_)
-            return {};
-        return dht_->getId();
-    }
+    InfoHash getId() const;
 
-    InfoHash getNodeId() const {
-        if (!dht_)
-            return {};
-        return dht_->getNodeId();
-    }
-
-    /**
-     * @deprecated Use getNodeId()
-     */
-    //[[deprecated]]
-    InfoHash getRoutingId() const {
-        return getNodeId();
-    }
+    InfoHash getNodeId() const;
 
     /**
      * Returns the currently bound address.
@@ -237,107 +224,41 @@ public:
         return ntohs(((sockaddr_in*)&getBound(f).first)->sin_port);
     }
 
-    std::pair<size_t, size_t> getStoreSize() const {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        if (!dht_)
-            return {};
-        return dht_->getStoreSize();
-    }
+    std::pair<size_t, size_t> getStoreSize() const;
 
-    void setStorageLimit(size_t limit = Dht::DEFAULT_STORAGE_LIMIT) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        if (!dht_)
-            throw std::runtime_error("dht is not running");
-        return dht_->setStorageLimit(limit);
-    }
+    void setStorageLimit(size_t limit = DEFAULT_STORAGE_LIMIT);
 
-    std::vector<NodeExport> exportNodes() const {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        if (!dht_)
-            return {};
-        return dht_->exportNodes();
-    }
+    std::vector<NodeExport> exportNodes() const;
 
-    std::vector<Dht::ValuesExport> exportValues() const {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        if (!dht_)
-            return {};
-        return dht_->exportValues();
-    }
+    std::vector<ValuesExport> exportValues() const;
 
-    void setLoggers(LogMethod&& error = NOLOG, LogMethod&& warn = NOLOG, LogMethod&& debug = NOLOG) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->setLoggers(std::forward<LogMethod>(error), std::forward<LogMethod>(warn), std::forward<LogMethod>(debug));
-    }
+    void setLoggers(LogMethod err = NOLOG, LogMethod warn = NOLOG, LogMethod debug = NOLOG);
 
-    void registerType(const ValueType& type) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->registerType(type);
-    }
+    void registerType(const ValueType& type);
 
-    void importValues(const std::vector<Dht::ValuesExport>& values) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->importValues(values);
-    }
+    void importValues(const std::vector<ValuesExport>& values);
 
     bool isRunning() const {
         return running;
     }
 
-    int 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);
-    }
+    int 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::lock_guard<std::mutex> lck(dht_mtx);
-        return dht_->getNodeMessageStats(in);
-    }
-
-    std::string getStorageLog() const
-    {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        return dht_->getStorageLog();
-    }
-    std::string getRoutingTablesLog(sa_family_t af) const
-    {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        return dht_->getRoutingTablesLog(af);
-    }
-    std::string getSearchesLog(sa_family_t af = 0) const
-    {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        return dht_->getSearchesLog(af);
-    }
-    std::vector<Address> getPublicAddress(sa_family_t af = 0)
-    {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        return dht_->getPublicAddress(af);
-    }
-    std::vector<std::string> getPublicAddressStr(sa_family_t af = 0)
-    {
-        auto addrs = getPublicAddress(af);
-        std::vector<std::string> ret(addrs.size());
-        std::transform(addrs.begin(), addrs.end(), ret.begin(), dht::printAddr);
-        return ret;
-    }
+    std::vector<unsigned> getNodeMessageStats(bool in = false) const;
+    std::string getStorageLog() const;
+    std::string getRoutingTablesLog(sa_family_t af) const;
+    std::string getSearchesLog(sa_family_t af = 0) const;
+    std::vector<Address> getPublicAddress(sa_family_t af = 0);
+    std::vector<std::string> getPublicAddressStr(sa_family_t af = 0);
 
     // securedht methods
 
     void findCertificate(InfoHash hash, std::function<void(const std::shared_ptr<crypto::Certificate>)>);
-    void registerCertificate(std::shared_ptr<crypto::Certificate> cert) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->registerCertificate(cert);
-    }
-    void setLocalCertificateStore(SecureDht::CertificateStoreQuery&& query_method) {
-        std::lock_guard<std::mutex> lck(dht_mtx);
-        dht_->setLocalCertificateStore(std::move(query_method));
-    }
+    void registerCertificate(std::shared_ptr<crypto::Certificate> cert);
+    void setLocalCertificateStore(CertificateStoreQuery&& query_method);
 
     struct Config {
-        SecureDht::Config dht_config;
+        SecureDhtConfig dht_config;
         bool threaded;
     };
 
@@ -349,14 +270,14 @@ public:
      */
     void run(in_port_t port, const crypto::Identity identity, bool threaded = false, bool is_bootstrap = false) {
         run(port, {
-            .dht_config = {
-                .node_config = {
-                    .node_id = {},
-                    .is_bootstrap = is_bootstrap
+            /*.dht_config = */{
+                /*.node_config = */{
+                    /*.node_id = */{},
+                    /*.is_bootstrap = */is_bootstrap
                 },
-                .id = identity
+                /*.id = */identity
             },
-            .threaded = threaded
+            /*.threaded = */threaded
         });
     }
     void run(in_port_t port, Config config);
@@ -393,7 +314,7 @@ public:
     /**
      * Gracefuly disconnect from network.
      */
-    void shutdown(Dht::ShutdownCallback cb);
+    void shutdown(ShutdownCallback cb);
 
     /**
      * Quit and wait for all threads to terminate.
@@ -404,16 +325,16 @@ public:
 
 private:
 
-    void doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDht::Config config);
+    void doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDhtConfig config);
     time_point loop_();
 
     static std::vector<std::pair<sockaddr_storage, socklen_t>> getAddrInfo(const char* host, const char* service);
 
-    Dht::Status getStatus() const {
+    NodeStatus getStatus() const {
         return std::max(status4, status6);
     }
 
-    std::unique_ptr<SecureDht> dht_ {};
+    std::unique_ptr<SecureDht> dht_;
     mutable std::mutex dht_mtx {};
     std::thread dht_thread {};
     std::condition_variable cv {};
@@ -428,8 +349,8 @@ private:
 
     std::atomic<bool> running {false};
 
-    Dht::Status status4 {Dht::Status::Disconnected},
-                status6 {Dht::Status::Disconnected};
+    NodeStatus status4 {NodeStatus::Disconnected},
+               status6 {NodeStatus::Disconnected};
     StatusCallback statusCb {nullptr};
 
     Address bound4 {};

include/opendht/infohash.h

@@ -21,6 +21,19 @@
 
 #include <msgpack.hpp>
 
+#ifndef _WIN32
+#include <netinet/in.h>
+#include <netdb.h>
+#ifdef __ANDROID__
+typedef uint16_t in_port_t;
+#endif
+#else
+#include <iso646.h>
+#include <ws2tcpip.h>
+typedef uint16_t sa_family_t;
+typedef uint16_t in_port_t;
+#endif
+
 #include <iostream>
 #include <iomanip>
 #include <array>
@@ -29,6 +42,7 @@
 #include <stdexcept>
 #include <cstring>
 
+
 // bytes
 #define HASH_LEN 20u
 
@@ -82,7 +96,11 @@ 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
         return std::memcmp(id1.data(), id2.data(), HASH_LEN);
     }
 
@@ -197,23 +215,12 @@ public:
 
 };
 
-}
+static constexpr const InfoHash zeroes {};
 
-namespace std
-{
-    template<>
-    struct hash<dht::InfoHash>
-    {
-        typedef dht::InfoHash argument_type;
-        typedef std::size_t result_type;
+struct NodeExport {
+    InfoHash id;
+    sockaddr_storage ss;
+    socklen_t sslen;
+};
 
-        result_type operator()(dht::InfoHash const& s) const
-        {
-            result_type r {};
-            std::hash<uint8_t> hash_fn;
-            for (size_t i = 0; i < HASH_LEN; i++)
-                r = r ^ (hash_fn(s[i]) << i*4);
-            return r;
-        }
-    };
 }

include/opendht/log.h

@@ -0,0 +1,108 @@
+/*
+ *  Copyright (C) 2014-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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#pragma once
+
+#include "dhtrunner.h"
+
+#include <iostream>
+#include <fstream>
+
+namespace dht {
+namespace log {
+
+/**
+ * Terminal colors for logging
+ */
+namespace Color {
+    enum Code {
+        FG_RED      = 31,
+        FG_GREEN    = 32,
+        FG_YELLOW   = 33,
+        FG_BLUE     = 34,
+        FG_DEFAULT  = 39,
+        BG_RED      = 41,
+        BG_GREEN    = 42,
+        BG_BLUE     = 44,
+        BG_DEFAULT  = 49
+    };
+    class Modifier {
+        const Code code;
+    public:
+        constexpr Modifier(Code pCode) : code(pCode) {}
+        friend std::ostream&
+        operator<<(std::ostream& os, const Modifier& mod) {
+            return os << "\033[" << mod.code << 'm';
+        }
+    };
+}
+
+constexpr const Color::Modifier def(Color::FG_DEFAULT);
+constexpr const Color::Modifier red(Color::FG_RED);
+constexpr const Color::Modifier yellow(Color::FG_YELLOW);
+
+/**
+ * Print va_list to std::ostream (used for logging).
+ */
+void
+printLog(std::ostream& s, char const* m, va_list args) {
+    static constexpr int BUF_SZ = 8192;
+    char buffer[BUF_SZ];
+    int ret = vsnprintf(buffer, sizeof(buffer), m, args);
+    if (ret < 0)
+        return;
+    s.write(buffer, std::min(ret, BUF_SZ));
+    if (ret >= BUF_SZ)
+        s << "[[TRUNCATED]]";
+    s.put('\n');
+}
+
+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);
+}
+
+} /* log */
+} /* dht  */
+

include/opendht/network_engine.h

@@ -0,0 +1,467 @@
+/*
+ *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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.
+ */
+
+
+#pragma once
+
+#include "node_cache.h"
+#include "value.h"
+#include "infohash.h"
+#include "node.h"
+#include "scheduler.h"
+#include "utils.h"
+#include "rng.h"
+
+#include <vector>
+#include <string>
+#include <functional>
+#include <algorithm>
+#include <memory>
+#include <random>
+#include <queue>
+
+namespace dht {
+
+#ifndef MSG_CONFIRM
+#define MSG_CONFIRM 0
+#endif
+
+class DhtProtocolException : public DhtException {
+public:
+    // sent to another peer (http-like).
+    static const constexpr uint16_t NON_AUTHORITATIVE_INFORMATION {203}; /* incomplete request packet. */
+    static const constexpr uint16_t UNAUTHORIZED {401};                  /* wrong tokens. */
+    // for internal use (custom).
+    static const constexpr uint16_t INVALID_TID_SIZE {421};              /* id was truncated. */
+    static const constexpr uint16_t UNKNOWN_TID {422};                   /* unknown tid */
+    static const constexpr uint16_t WRONG_NODE_INFO_BUF_LEN {423};       /* node info length is wrong */
+
+    static const std::string GET_NO_INFOHASH;    /* received "get" request with no infohash */
+    static const std::string LISTEN_NO_INFOHASH; /* got "listen" request without infohash */
+    static const std::string LISTEN_WRONG_TOKEN; /* wrong token in "listen" request */
+    static const std::string PUT_NO_INFOHASH;    /* no infohash in "put" request */
+    static const std::string PUT_WRONG_TOKEN;    /* got "put" request with wrong token */
+    static const std::string PUT_INVALID_ID;     /* invalid id in "put" request */
+
+    DhtProtocolException(uint16_t code, const std::string& msg="", InfoHash failing_node_id={})
+        : DhtException(msg), msg(msg), code(code), failing_node_id(failing_node_id) {}
+
+    std::string getMsg() const { return msg; }
+    uint16_t getCode() const { return code; }
+    const InfoHash getNodeId() const { return failing_node_id; }
+
+private:
+    std::string msg;
+    uint16_t code;
+    const InfoHash failing_node_id;
+};
+
+struct ParsedMessage;
+
+/*!
+ * @class   NetworkEngine
+ * @brief   An abstraction of communication protocol on the network.
+ * @details
+ * The NetworkEngine processes all requests to nodes by offering a public
+ * interface for handling sending and receiving packets. The following
+ * parameters specify callbacks for DHT work:
+ *
+ * @param onError        callback for handling error messages.
+ * @param onNewNode      callback for handling new nodes.
+ * @param onReportedAddr callback for reporting an our address as seen from the other peer.
+ * @param onPing         callback for ping request.
+ * @param onFindNode     callback for "find node" request.
+ * @param onGetValues    callback for "get values" request.
+ * @param onListen       callback for "listen" request.
+ * @param onAnnounce     callback for "announce" request.
+ */
+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 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.
+     * @details
+     * Answer for a request to be (de)serialized. Used for reponding to a node
+     * and looking up the response from a node.
+     */
+    struct RequestAnswer {
+        Blob ntoken {};
+        Value::Id vid {};
+        std::vector<std::shared_ptr<Value>> values {};
+        std::vector<std::shared_ptr<Node>> nodes4 {};
+        std::vector<std::shared_ptr<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();
+
+private:
+
+    /**
+     * @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.
+     */
+    std::function<void(const std::shared_ptr<Node>&, int)> onNewNode;
+    /**
+     * @brief when an addres is reported from a distant node.
+     *
+     * @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.
+     */
+    std::function<void(const InfoHash&, sockaddr*, socklen_t)> onReportedAddr;
+    /**
+     * @brief on ping request callback.
+     *
+     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     */
+    std::function<RequestAnswer(std::shared_ptr<Node>)> onPing {};
+    /**
+     * @brief on find node request callback.
+     *
+     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     * @param vhash (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>,
+            InfoHash&,
+            want_t)> onFindNode {};
+    /**
+     * @brief on "get values" request callback.
+     *
+     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     * @param vhash (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>,
+            InfoHash&,
+            want_t)> onGetValues {};
+    /**
+     * @brief on listen request callback.
+     *
+     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     * @param vhash (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>,
+            InfoHash&,
+            Blob&,
+            uint16_t)> onListen {};
+    /**
+     * @brief on announce request callback.
+     *
+     * @param node (type: std::shared_ptr<Node>) the requesting node.
+     * @param vhash (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 created (type: time_point) time when the value was created.
+     */
+    std::function<RequestAnswer(std::shared_ptr<Node>,
+            InfoHash&,
+            Blob&,
+            std::vector<std::shared_ptr<Value>>,
+            time_point)> onAnnounce {};
+
+public:
+    using RequestCb = std::function<void(const Request&, RequestAnswer&&)>;
+    using RequestExpiredCb = std::function<void(const Request&, bool)>;
+
+    NetworkEngine(Logger& log, Scheduler& scheduler) : myid(zeroes), DHT_LOG(log), scheduler(scheduler) {}
+    NetworkEngine(InfoHash& myid, int s, int s6, Logger& log, Scheduler& scheduler,
+            decltype(NetworkEngine::onError) onError,
+            decltype(NetworkEngine::onNewNode) onNewNode,
+            decltype(NetworkEngine::onReportedAddr) onReportedAddr,
+            decltype(NetworkEngine::onPing) onPing,
+            decltype(NetworkEngine::onFindNode) onFindNode,
+            decltype(NetworkEngine::onGetValues) onGetValues,
+            decltype(NetworkEngine::onListen) onListen,
+            decltype(NetworkEngine::onAnnounce) onAnnounce) :
+        onError(onError), onNewNode(onNewNode), onReportedAddr(onReportedAddr), onPing(onPing), onFindNode(onFindNode),
+        onGetValues(onGetValues), onListen(onListen), onAnnounce(onAnnounce), myid(myid),
+        dht_socket(s), dht_socket6(s6), DHT_LOG(log), scheduler(scheduler)
+    {
+        transaction_id = std::uniform_int_distribution<decltype(transaction_id)>{1}(rd_device);
+    }
+    virtual ~NetworkEngine() {
+        clear();
+    };
+
+    void clear();
+
+    /**
+     * 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.
+     */
+    void tellListener(std::shared_ptr<Node> n, uint16_t rid, InfoHash hash, want_t want, Blob ntoken,
+            std::vector<std::shared_ptr<Node>> nodes, std::vector<std::shared_ptr<Node>> nodes6,
+            std::vector<std::shared_ptr<Value>> values);
+
+    bool isRunning(sa_family_t af) const;
+    inline want_t want () const { return dht_socket >= 0 && dht_socket6 >= 0 ? (WANT4 | WANT6) : -1; }
+
+    /**************
+     *  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);
+        }
+    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& target,
+                want_t want,
+                RequestCb on_done,
+                RequestExpiredCb on_expired);
+    std::shared_ptr<Request>
+        sendListen(std::shared_ptr<Node> n,
+                const InfoHash& infohash,
+                const Blob& token,
+                RequestCb on_done,
+                RequestExpiredCb on_expired);
+    std::shared_ptr<Request>
+        sendAnnounceValue(std::shared_ptr<Node> n,
+                const InfoHash& infohash,
+                const Value& v,
+                time_point created,
+                const Blob& token,
+                RequestCb on_done,
+                RequestExpiredCb on_expired);
+
+    /**
+     * Parses a message and calls appropriate callbacks.
+     *
+     * @param buf  The buffer containing the binary message.
+     * @param buflen  The length of the buffer.
+     * @param from  The address info of the sender.
+     * @param fromlen  The length of the corresponding sockaddr structure.
+     * @param now  The time to adjust the clock in the network engine.
+     */
+    void processMessage(const uint8_t *buf, size_t buflen, const sockaddr* from, socklen_t fromlen);
+
+    std::shared_ptr<Node> insertNode(const InfoHash& myid, const sockaddr* from, socklen_t fromlen) {
+        return cache.getNode(myid, from, fromlen, scheduler.time(), 0);
+    }
+
+    std::vector<unsigned> getNodeMessageStats(bool in) {
+        auto& st = in ? in_stats : out_stats;
+        std::vector<unsigned> stats {st.ping,  st.find,  st.get,  st.listen,  st.put};
+        st = {};
+        return stats;
+    }
+
+    void blacklistNode(const std::shared_ptr<Node>& n);
+
+private:
+    /***************
+     *  Constants  *
+     ***************/
+    static constexpr long unsigned MAX_REQUESTS_PER_SEC {1600};
+    /* the length of a node info buffer in ipv4 format */
+    static const constexpr size_t NODE4_INFO_BUF_LEN {26};
+    /* the length of a node info buffer in ipv6 format */
+    static const constexpr size_t NODE6_INFO_BUF_LEN {38};
+    /* TODO */
+    static constexpr std::chrono::seconds UDP_REPLY_TIME {15};
+    /* The maximum number of nodes that we snub.  There is probably little
+        reason to increase this value. */
+    static constexpr unsigned BLACKLISTED_MAX {10};
+    /* TODO */
+    static const std::string my_v;
+
+    /* DHT info */
+    const InfoHash& myid;
+    const int dht_socket {-1};
+    const int dht_socket6 {-1};
+    const Logger& DHT_LOG;
+
+    NodeCache cache {};
+    sockaddr_storage blacklist[BLACKLISTED_MAX] {};
+    unsigned next_blacklisted = 0;
+
+    bool rateLimit();
+
+    static bool isMartian(const sockaddr* sa, socklen_t len);
+    bool isNodeBlacklisted(const sockaddr*, socklen_t) const;
+
+    void requestStep(std::shared_ptr<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);
+
+    /**
+     * Generates a new request id, skipping the invalid id.
+     *
+     * @return the new id.
+     */
+    uint16_t getNewTid() {
+        ++transaction_id;
+        return transaction_id == TransId::INVALID ? ++transaction_id : transaction_id;
+    }
+
+    struct MessageStats {
+        unsigned ping {0};
+        unsigned find {0};
+        unsigned get {0};
+        unsigned put {0};
+        unsigned listen {0};
+    };
+
+
+    // basic wrapper for socket sendto function
+    int send(const char *buf, size_t len, int flags, const sockaddr *sa, socklen_t salen);
+
+    /*************
+     *  Answers  *
+     *************/
+    /* answer to a ping  request */
+    void sendPong(const sockaddr* sa, socklen_t salen, TransId tid);
+    /* answer to findnodes/getvalues request */
+    void sendNodesValues(const sockaddr* sa,
+            socklen_t salen,
+            TransId tid,
+            const Blob& nodes,
+            const Blob& nodes6,
+            const std::vector<std::shared_ptr<Value>>& st,
+            const Blob& token);
+    Blob bufferNodes(sa_family_t af, const InfoHash& id, std::vector<std::shared_ptr<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);
+    /* answer to a listen request */
+    void sendListenConfirmation(const sockaddr* sa, socklen_t salen, TransId tid);
+    /* answer to put request */
+    void sendValueAnnounced(const sockaddr* sa, socklen_t salen, TransId, Value::Id);
+    /* answer in case of error */
+    void sendError(const sockaddr* sa,
+            socklen_t salen,
+            TransId tid,
+            uint16_t code,
+            const std::string& message,
+            bool include_id=false);
+
+    void deserializeNodesValues(ParsedMessage& msg);
+
+    std::queue<time_point> rate_limit_time {};
+    static std::mt19937 rd_device;
+
+    // requests handling
+    uint16_t transaction_id {1};
+    std::map<uint16_t, std::shared_ptr<Request>> requests {};
+    MessageStats in_stats {}, out_stats {};
+
+    Scheduler& scheduler;
+};
+
+}

include/opendht/node.h

@@ -0,0 +1,103 @@
+/*
+ *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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.
+ */
+
+#pragma once
+
+#include "infohash.h" // includes socket structures
+#include "utils.h"
+
+#include <list>
+
+namespace dht {
+
+struct Request;
+
+struct Node {
+    friend class NetworkEngine;
+
+    InfoHash id;
+
+    socklen_t sslen {0};
+    sockaddr_storage ss;
+
+    time_point time {time_point::min()};            /* last time eared about */
+    time_point reply_time {time_point::min()};      /* time of last correct reply received */
+
+    Node(const InfoHash& id, const sockaddr* sa, socklen_t salen)
+        : id(id), sslen(salen), ss() {
+        std::copy_n((const uint8_t*)sa, salen, (uint8_t*)&ss);
+        if ((unsigned)salen < sizeof(ss))
+            std::fill_n((uint8_t*)&ss+salen, sizeof(ss)-salen, 0);
+    }
+    InfoHash getId() const {
+        return id;
+    }
+    std::pair<const sockaddr*, socklen_t> getAddr() const {
+        return {(const sockaddr*)&ss, sslen};
+    }
+    std::string getAddrStr() const {
+        return print_addr(ss, sslen);
+    }
+    bool isExpired() const { return expired_; }
+    bool isGood(time_point now) const;
+    bool isPendingMessage() const;
+    size_t getPendingMessageCount() const;
+
+    NodeExport exportNode() const { return NodeExport {id, ss, sslen}; }
+    sa_family_t getFamily() const { return ss.ss_family; }
+
+    void update(const sockaddr* sa, socklen_t salen);
+
+    void requested(std::shared_ptr<Request>& req);
+    void received(time_point now, std::shared_ptr<Request> req);
+
+    void setExpired();
+
+    /**
+     * Resets the state of the node so it's not expired anymore.
+     */
+    void reset() { expired_ = false; }
+
+    std::string toString() const;
+
+    friend std::ostream& operator<< (std::ostream& s, const Node& h);
+
+    static constexpr const std::chrono::minutes NODE_GOOD_TIME {120};
+
+    /* The time after which we consider a node to be expirable. */
+    static constexpr const std::chrono::minutes NODE_EXPIRE_TIME {10};
+
+    /* Time for a request to timeout */
+    static constexpr const std::chrono::seconds MAX_RESPONSE_TIME {1};
+
+private:
+
+    std::list<std::weak_ptr<Request>> requests_ {};
+    bool expired_ {false};
+
+    void clearPendingQueue() {
+        requests_.remove_if([](std::weak_ptr<Request>& w) {
+            return w.expired();
+        });
+    }
+
+};
+
+}

include/opendht/node_cache.h

@@ -0,0 +1,52 @@
+/*
+ *  Copyright (C) 2014-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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#pragma once
+
+#include "node.h"
+
+#include <list>
+#include <memory>
+
+namespace dht {
+
+struct NodeCache {
+    std::shared_ptr<Node> getNode(const InfoHash& id, sa_family_t family);
+    std::shared_ptr<Node> getNode(const InfoHash& id, const sockaddr* sa, socklen_t sa_len, time_point now, int confirmed);
+
+    /**
+     * Reset the connectivity state of every node,
+     * Giving them a new chance if they where expired.
+     * To use in case of connectivity change etc.
+     */
+    void clearBadNodes(sa_family_t family = 0);
+
+private:
+    class NodeMap : public std::map<InfoHash, std::weak_ptr<Node>> {
+    public:
+        std::shared_ptr<Node> getNode(const InfoHash& id);
+        std::shared_ptr<Node> getNode(const InfoHash& id, const sockaddr* sa, socklen_t sa_len, time_point now, int confirmed);
+        void clearBadNodes();
+    };
+
+    NodeMap cache_4;
+    NodeMap cache_6;
+};
+
+}

include/opendht/request.h

@@ -0,0 +1,113 @@
+/*
+ *  Copyright (C) 2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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.
+ */
+
+namespace dht {
+
+class NetworkEngine;
+struct ParsedMessage;
+
+/*!
+ * @class   Request
+ * @brief   An atomic request destined to a node.
+ * @details
+ * A request contains data used by the NetworkEngine to process a request
+ * desitned to specific node and std::function callbacks to execute when the
+ * request is done.
+ */
+struct Request {
+    friend class dht::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. */
+
+    enum class State
+    {
+        PENDING,
+        CANCELLED,
+        EXPIRED,
+        COMPLETED
+    };
+
+    bool expired() const { return state_ == State::EXPIRED; }
+    bool completed() const { return state_ == State::COMPLETED; }
+    bool cancelled() const { return state_ == State::CANCELLED; }
+    bool pending() const { return state_ == State::PENDING; }
+    bool over() const { return not pending(); }
+    State getState() const { return state_; }
+
+    Request() {}
+    Request(uint16_t 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) { }
+
+    void setExpired() {
+        if (pending()) {
+            state_ = Request::State::EXPIRED;
+            on_expired(*this, true);
+            clear();
+        }
+    }
+    void setDone(ParsedMessage&& msg) {
+        if (pending() or persistent) {
+            state_ = Request::State::COMPLETED;
+            on_done(*this, std::forward<ParsedMessage>(msg));
+            if (not persistent)
+                clear();
+        }
+    }
+
+    void cancel() {
+        if (pending()) {
+            state_ = State::CANCELLED;
+            clear();
+        }
+    }
+
+private:
+    static const constexpr size_t MAX_ATTEMPT_COUNT {3};
+
+    bool isExpired(time_point now) const {
+        return pending() and now > last_try + Node::MAX_RESPONSE_TIME and attempt_count >= Request::MAX_ATTEMPT_COUNT;
+    }
+
+    void clear() {
+        on_done = {};
+        on_expired = {};
+        msg.clear();
+    }
+
+    State state_ {State::PENDING};
+
+    unsigned attempt_count {0};                /* number of attempt to process the request. */
+    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 {};
+
+    const uint16_t tid {0};                   /* the request id. */
+    Blob msg {};                              /* the serialized message. */
+    const bool persistent {false};            /* the request is not erased upon completion. */
+};
+
+}

include/opendht/rng.h

@@ -17,11 +17,14 @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
  */
 
+#pragma once
+
 #include <random>
 
 namespace dht {
 namespace crypto {
 
+#ifndef WIN32_NATIVE
 #ifdef _WIN32
 
 /**
@@ -99,6 +102,9 @@ private:
 
 using random_device = std::random_device;
 
+#endif
+#else
+using random_device = std::random_device;
 #endif
 
 }} // dht::crypto

include/opendht/routing_table.h

@@ -0,0 +1,79 @@
+/*
+ *  Copyright (C) 2014-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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#pragma once
+
+#include "node.h"
+
+namespace dht {
+
+struct Bucket {
+    Bucket() : cached() {}
+    Bucket(sa_family_t af, const InfoHash& f = {}, time_point t = time_point::min())
+        : 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 */
+
+    /** Return a random node in a bucket. */
+    std::shared_ptr<Node> randomNode();
+};
+
+class RoutingTable : public std::list<Bucket> {
+public:
+    using std::list<Bucket>::list;
+
+    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;
+
+    RoutingTable::iterator findBucket(const InfoHash& id);
+    RoutingTable::const_iterator findBucket(const InfoHash& id) const;
+
+    /**
+     * Return true if the id is in the bucket's range.
+     */
+    inline bool contains(const RoutingTable::const_iterator& bucket, const InfoHash& id) const {
+        return InfoHash::cmp(bucket->first, id) <= 0
+            && (std::next(bucket) == end() || InfoHash::cmp(id, std::next(bucket)->first) < 0);
+    }
+
+    /**
+     * Return true if the table has no bucket ore one empty buket.
+     */
+    inline bool isEmpty() const {
+        return empty() || (size() == 1 && front().nodes.empty());
+    }
+
+    /**
+     * Return a random id in the bucket's range.
+     */
+    InfoHash randomId(const RoutingTable::const_iterator& bucket) const;
+
+    unsigned depth(const RoutingTable::const_iterator& bucket) const;
+
+    /**
+     * Split a bucket in two equal parts.
+     */
+    bool split(const RoutingTable::iterator& b);
+};
+
+}

include/opendht/scheduler.h

@@ -0,0 +1,118 @@
+/*
+ *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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.
+ */
+
+
+#pragma once
+
+#include "utils.h"
+
+#include <functional>
+#include <map>
+
+namespace dht {
+
+/*!
+ * @class   Scheduler
+ * @brief   Job scheduler
+ * @details
+ * Maintains the timings upon which to execute a job.
+ */
+class Scheduler {
+public:
+    struct Job {
+        Job(std::function<void()>&& f) : do_(std::forward<std::function<void()>>(f)) {}
+        std::function<void()> do_;
+    };
+
+    /**
+     * Adds another job to the queue.
+     *
+     * @param time  The time upon which the job shall be executed.
+     * @param job_func  The job function to execute.
+     *
+     * @return pointer to the newly scheduled job.
+     */
+    std::shared_ptr<Scheduler::Job> add(time_point t, std::function<void()>&& job_func) {
+        auto job = std::make_shared<Job>(std::forward<std::function<void()>>(job_func));
+        if (t != time_point::max())
+            timers.emplace(std::move(t), job);
+        return job;
+    }
+
+    /**
+     * Reschedules a job.
+     *
+     * @param time  The time at which the job shall be rescheduled.
+     * @param job  The job to edit.
+     *
+     * @return pointer to the newly scheduled job.
+     */
+    void edit(std::shared_ptr<Scheduler::Job>& job, time_point t) {
+        if (not job) {
+            std::cerr << "editing an empty job" << std::endl;
+            return;
+        }
+        job = add(t, std::move(job->do_));
+    }
+
+    /**
+     * Runs the jobs to do up to now.
+     *
+     * @return The time for the next job to run.
+     */
+    time_point run() {
+        syncTime();
+        while (not timers.empty()) {
+            auto timer = timers.begin();
+            /*
+             * Running jobs scheduled before "now" prevents run+rescheduling
+             * loops before this method ends. It is garanteed by the fact that a
+             * job will at least be scheduled for "now" and not before.
+             */
+            if (timer->first > now)
+                break;
+
+            const auto& job = *timer->second;
+            if (job.do_)
+                job.do_();
+            timers.erase(timer);
+        }
+        return getNextJobTime();
+    }
+
+    inline time_point getNextJobTime() const {
+        //if (not timers.empty())
+        //    std::cout << "Next job in " << print_dt(timers.begin()->first - clock::now()) << std::endl;
+        return timers.empty() ? time_point::max() : timers.begin()->first;
+    }
+
+    /**
+     * Accessors for the common time reference used for synchronizing
+     * operations.
+     */
+    inline const time_point& time() const { return now; }
+    inline time_point syncTime() { return (now = clock::now()); }
+
+private:
+    time_point now {clock::now()};
+    std::multimap<time_point, std::shared_ptr<Job>> timers {}; /* the jobs ordered by time */
+};
+
+}

include/opendht/securedht.h

@@ -45,11 +45,7 @@ public:
 
     typedef std::function<void(bool)> SignatureCheckCallback;
 
-    struct Config
-    {
-        Dht::Config node_config;
-        crypto::Identity id;
-    };
+    using Config = SecureDhtConfig;
 
     SecureDht() {}
 
@@ -89,19 +85,25 @@ public:
      * If the signature can't be checked, or if the data can't be decrypted, it is not returned.
      * Public, non-signed & non-encrypted data is retransmitted as-is.
      */
-    void get(const InfoHash& id, GetCallback cb, DoneCallback donecb, Value::Filter&& = {});
-    void get(const InfoHash& id, GetCallback cb, DoneCallbackSimple donecb, Value::Filter&& f = {}) {
+    virtual void get(const InfoHash& id, GetCallback cb, DoneCallback donecb={}, Value::Filter&& = {}) override;
+    virtual void get(const InfoHash& id, GetCallback cb, DoneCallbackSimple donecb={}, Value::Filter&& f = {}) override {
         get(id, cb, bindDoneCb(donecb), std::forward<Value::Filter>(f));
     }
+    virtual void get(const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb={}, Value::Filter&& f={}) override {
+        get(key, bindGetCb(cb), donecb, std::forward<Value::Filter>(f));
+    }
+    virtual void get(const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter&& f={}) override {
+        get(key, bindGetCb(cb), bindDoneCb(donecb), std::forward<Value::Filter>(f));
+    }
 
-    size_t listen(const InfoHash& id, GetCallback cb, Value::Filter&& = {});
+    virtual size_t listen(const InfoHash& id, GetCallback cb, Value::Filter&& = {}) override;
 
     /**
      * 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);
-    void putSigned(const InfoHash& hash, Value&& v, DoneCallback callback) {
-        putSigned(hash, std::make_shared<Value>(std::move(v)), callback);
+    void putSigned(const InfoHash& hash, std::shared_ptr<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);
     }
 
     /**
@@ -109,9 +111,9 @@ 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);
-    void putEncrypted(const InfoHash& hash, const InfoHash& to, Value&& v, DoneCallback callback) {
-        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback);
+    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, Value&& v, DoneCallback callback, bool permanent = false) {
+        putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
     }
 
     /**
@@ -124,14 +126,13 @@ 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);
 
     const std::shared_ptr<crypto::Certificate> registerCertificate(const InfoHash& node, const Blob& cert);
     void registerCertificate(std::shared_ptr<crypto::Certificate>& cert);
 
     const std::shared_ptr<crypto::Certificate> getCertificate(const InfoHash& node) const;
-
-
-    using CertificateStoreQuery = std::function<std::vector<std::shared_ptr<crypto::Certificate>>(const InfoHash& pk_id)>;
+    const std::shared_ptr<const crypto::PublicKey> getPublicKey(const InfoHash& node) const;
 
     /**
      * Allows to set a custom callback called by the library to find a locally-stored certificate.
@@ -157,6 +158,7 @@ private:
 
     // our certificate cache
     std::map<InfoHash, std::shared_ptr<crypto::Certificate>> nodesCertificates_ {};
+    std::map<InfoHash, std::shared_ptr<const crypto::PublicKey>> nodesPubKeys_ {};
 
     std::uniform_int_distribution<Value::Id> rand_id {};
 };

include/opendht/utils.h

@@ -19,16 +19,46 @@
 
 #pragma once
 
+#define WANT4 1
+#define WANT6 2
+
 #include <msgpack.hpp>
 
+#ifndef _WIN32
+#include <sys/socket.h>
+#else
+#include <ws2def.h>
+#include <ws2tcpip.h>
+#endif
+
 #include <chrono>
 #include <random>
 #include <functional>
+#include <map>
 
 #include <cstdarg>
 
 namespace dht {
 
+static constexpr unsigned TARGET_NODES {8};
+
+using Address = std::pair<sockaddr_storage, socklen_t>;
+using want_t = int_fast8_t;
+
+std::string print_addr(const sockaddr* sa, socklen_t slen);
+std::string print_addr(const sockaddr_storage& ss, socklen_t sslen);
+std::string printAddr(const Address& addr);
+
+template <typename Key, typename Item, typename Condition>
+void erase_if(std::map<Key, Item>& map, const Condition& condition)
+{
+    for (auto it = map.begin(); it != map.end(); ) {
+        if (condition(*it)) {
+            it = map.erase(it);
+        } else { ++it; }
+    }
+}
+
 class DhtException : public std::runtime_error {
     public:
         DhtException(const std::string &str = "") :
@@ -45,6 +75,15 @@ using duration = clock::duration;
 time_point from_time_t(std::time_t t);
 std::time_t to_time_t(time_point t);
 
+/**
+ * Converts std::chrono::duration to floating-point seconds.
+ */
+template <class DT>
+static double
+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()};
 
@@ -90,16 +129,22 @@ struct LogMethod {
     void logPrintable(const uint8_t *buf, size_t buflen) const {
         std::string buf_clean(buflen, '\0');
         for (size_t i=0; i<buflen; i++)
-            buf_clean[i] = std::isprint(buf[i]) ? buf[i] : '.';
+            buf_clean[i] = isprint(buf[i]) ? buf[i] : '.';
         (*this)("%s", buf_clean.c_str());
     }
 private:
     std::function<void(char const*, va_list)> func;
 };
 
+struct Logger {
+    LogMethod DEBUG = NOLOG;
+    LogMethod WARN = NOLOG;
+    LogMethod ERR = NOLOG;
+};
+
 // Serialization related definitions and utility functions
 
-typedef std::vector<uint8_t> Blob;
+using Blob = std::vector<uint8_t>;
 
 /**
  * Provides backward compatibility with msgpack 1.0
@@ -124,4 +169,4 @@ unpackMsg(Blob b) {
 
 msgpack::unpacked unpackMsg(Blob b);
 
-}
+} // namespace dht

include/opendht/value.h

@@ -26,18 +26,6 @@
 
 #include <msgpack.hpp>
 
-#ifndef _WIN32
-#include <netinet/in.h>
-#include <netdb.h>
-#ifdef __ANDROID__
-typedef uint16_t in_port_t;
-#endif
-#else
-#include <ws2tcpip.h>
-typedef uint16_t sa_family_t;
-typedef uint16_t in_port_t;
-#endif
-
 #include <string>
 #include <sstream>
 #include <bitset>
@@ -80,17 +68,23 @@ using StorePolicy = std::function<bool(InfoHash key, std::shared_ptr<Value>& val
  */
 using EditPolicy = std::function<bool(InfoHash key, const std::shared_ptr<Value>& old_val, std::shared_ptr<Value>& new_val, InfoHash from, const sockaddr* from_addr, socklen_t from_len)>;
 
-static constexpr const size_t MAX_VALUE_SIZE {1024 * 56};
+static constexpr const size_t MAX_VALUE_SIZE {1024 * 14};
 
 struct ValueType {
     typedef uint16_t Id;
+
+    static bool DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t);
+    static bool DEFAULT_EDIT_POLICY(InfoHash, const std::shared_ptr<Value>&, std::shared_ptr<Value>&, InfoHash, const sockaddr*, socklen_t) {
+        return false;
+    }
+
     ValueType () {}
 
     ValueType (Id id, std::string name, duration e = std::chrono::minutes(10))
     : id(id), name(name), expiration(e) {}
 
-    ValueType (Id id, std::string name, duration e, StorePolicy&& sp, EditPolicy&& ep)
-     : id(id), name(name), expiration(e), storePolicy(std::move(sp)), editPolicy(std::move(ep)) {}
+    ValueType (Id id, std::string name, duration e, StorePolicy sp, EditPolicy ep = DEFAULT_EDIT_POLICY)
+     : id(id), name(name), expiration(e), storePolicy(sp), editPolicy(ep) {}
 
     virtual ~ValueType() {}
 
@@ -101,10 +95,6 @@ struct ValueType {
     // Generic value type
     static const ValueType USER_DATA;
 
-    static bool DEFAULT_STORE_POLICY(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr*, socklen_t);
-    static bool DEFAULT_EDIT_POLICY(InfoHash, const std::shared_ptr<Value>&, std::shared_ptr<Value>&, InfoHash, const sockaddr*, socklen_t) {
-        return false;
-    }
 
     Id id {0};
     std::string name {};
@@ -130,9 +120,19 @@ struct Value
     class Filter : public std::function<bool(const Value&)> {
         using std::function<bool(const Value&)>::function;
     public:
+        Filter chain(Filter&& f2) {
+            auto f1 = *this;
+            return chain(std::move(f1), std::move(f2));
+        }
+        Filter chainOr(Filter&& f2) {
+            auto f1 = *this;
+            return chainOr(std::move(f1), std::move(f2));
+        }
         static Filter chain(Filter&& f1, Filter&& f2) {
-            return [f1,f2](const Value& v){
-                return f1(v) && f2(v);
+            if (not f1) return f2;
+            if (not f2) return f1;
+            return [f1,f2](const Value& v) {
+                return f1(v) and f2(v);
             };
         }
         static Filter chain(std::initializer_list<Filter> l) {
@@ -144,10 +144,10 @@ struct Value
                 return true;
             };
         }
-        Filter chain(Filter&& f2) {
-            Filter f1 = std::move(*this);
-            return [f1,f2](const Value& v){
-                return f1(v) && f2(v);
+        static Filter chainOr(Filter&& f1, Filter&& f2) {
+            if (not f1 or not f2) return AllFilter();
+            return [f1,f2](const Value& v) {
+                return f1(v) or f2(v);
             };
         }
     };
@@ -186,10 +186,10 @@ struct Value
     };
 
     template <typename Derived, typename Base=SerializableBase>
-	class Serializable : public Base
-	{
-	public:
-		using Base::Base;
+    class Serializable : public Base
+    {
+    public:
+        using Base::Base;
 
         virtual const ValueType& getType() const {
             return Derived::TYPE;
@@ -197,7 +197,7 @@ struct Value
 
         virtual void unpackValue(const Value& v) {
             auto msg = msgpack::unpack((const char*)v.data.data(), v.data.size());
-            msg.get().convert(static_cast<Derived*>(this));
+            msg.get().convert(*static_cast<Derived*>(this));
         }
 
         virtual Value packValue() const {
@@ -245,7 +245,44 @@ struct Value
         return not cypher.empty();
     }
     bool isSigned() const {
-        return not signature.empty();
+        return owner and not signature.empty();
+    }
+
+    /**
+     * Sign the value using the provided private key.
+     * Afterward, checkSignature() will return true and owner will
+     * be set to the corresponding public key.
+     */
+    void sign(const crypto::PrivateKey& key) {
+        if (isEncrypted())
+            throw DhtException("Can't sign encrypted data.");
+        owner = std::make_shared<const crypto::PublicKey>(key.getPublicKey());
+        signature = key.sign(getToSign());
+    }
+
+    /**
+     * Check that the value is signed and that the signature matches.
+     * If true, the owner field will contain the signer public key.
+     */
+    bool checkSignature() const {
+        return isSigned() and owner->checkSignature(getToSign(), signature);
+    }
+
+    std::shared_ptr<const crypto::PublicKey> getOwner() const {
+        return std::static_pointer_cast<const crypto::PublicKey>(owner);
+    }
+
+    /**
+     * Sign the value with from and returns the encrypted version for to.
+     */
+    Value encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to) {
+        if (isEncrypted())
+            throw DhtException("Data is already encrypted.");
+        setRecipient(to.getId());
+        sign(from);
+        Value nv {id};
+        nv.setCypher(to.encrypt(getToEncrypt()));
+        return nv;
     }
 
     Value() {}
@@ -291,7 +328,7 @@ struct Value
     inline bool operator== (const Value& o) {
         return id == o.id &&
         (isEncrypted() ? cypher == o.cypher :
-        (owner == o.owner && type == o.type && data == o.data && user_type == o.user_type && signature == o.signature));
+        ((owner == o.owner || *owner == *o.owner) && type == o.type && data == o.data && user_type == o.user_type && signature == o.signature));
     }
 
     void setRecipient(const InfoHash& r) {
@@ -337,10 +374,11 @@ struct Value
     template <typename Packer>
     void msgpack_pack_to_sign(Packer& pk) const
     {
-        pk.pack_map((user_type.empty()?0:1) + (owner?(recipient == InfoHash() ? 4 : 5):2));
-        if (owner) { // isSigned
+        bool has_owner = owner && *owner;
+        pk.pack_map((user_type.empty()?0:1) + (has_owner?(recipient == InfoHash() ? 4 : 5):2));
+        if (has_owner) { // isSigned
             pk.pack(std::string("seq"));   pk.pack(seq);
-            pk.pack(std::string("owner")); owner.msgpack_pack(pk);
+            pk.pack(std::string("owner")); owner->msgpack_pack(pk);
             if (recipient != InfoHash()) {
                 pk.pack(std::string("to")); pk.pack(recipient);
             }
@@ -379,13 +417,19 @@ struct Value
 
     void msgpack_unpack(msgpack::object o);
     void msgpack_unpack_body(const msgpack::object& o);
+    Blob getPacked() const {
+        msgpack::sbuffer buffer;
+        msgpack::packer<msgpack::sbuffer> pk(&buffer);
+        pk.pack(*this);
+        return {buffer.data(), buffer.data()+buffer.size()};
+    }
 
     Id id {INVALID_ID};
 
     /**
      * Public key of the signer.
      */
-    crypto::PublicKey owner {};
+    std::shared_ptr<const crypto::PublicKey> owner {};
 
     /**
      * Hash of the recipient (optional).
@@ -421,6 +465,8 @@ struct Value
     Blob cypher {};
 };
 
+using ValuesExport = std::pair<InfoHash, Blob>;
+
 template <typename T,
           typename std::enable_if<std::is_base_of<Value::SerializableBase, T>::value, T>::type* = nullptr>
 Value::Filter

m4/ax_cxx_compile_stdcxx.m4

@@ -0,0 +1,562 @@
+# ===========================================================================
+#   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 4
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
+  m4_if([$1], [11], [],
+        [$1], [14], [],
+        [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])],
+        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$2], [], [],
+        [$2], [ext], [],
+        [$2], [noext], [],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
+        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+  ax_cv_cxx_compile_cxx$1,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+    [ax_cv_cxx_compile_cxx$1=yes],
+    [ax_cv_cxx_compile_cxx$1=no])])
+  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$2], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++$1 -std=gnu++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$2], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE([No compiler with C++$1 support was found])
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              [define if the compiler supports basic C++$1 syntax])
+  fi
+  AC_SUBST(HAVE_CXX$1)
+])
+
+
+dnl  Test body for checking C++11 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+
+dnl  Tests for new features in C++11
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+]])
+
+
+dnl  Tests for new features in C++14
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = [](auto&&... args){
+        const auto istiny = [](auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny[] = { istiny(args)... };
+        return aretiny[0];
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = [a = x](int b){ return a + b; };
+      const auto lambda2 = [a = lambda1(x)](){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_seperators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+]])

m4/ax_cxx_compile_stdcxx_11.m4

@@ -1,135 +0,0 @@
-# ============================================================================
-#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
-# ============================================================================
-#
-# SYNOPSIS
-#
-#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
-#
-# DESCRIPTION
-#
-#   Check for baseline language coverage in the compiler for the C++11
-#   standard; if necessary, add switches to CXXFLAGS to enable support.
-#
-#   The first argument, if specified, indicates whether you insist on an
-#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
-#   -std=c++11).  If neither is specified, you get whatever works, with
-#   preference for an extended mode.
-#
-#   The second argument, if specified 'mandatory' or if left unspecified,
-#   indicates that baseline C++11 support is required and that the macro
-#   should error out if no mode with that support is found.  If specified
-#   'optional', then configuration proceeds regardless, after defining
-#   HAVE_CXX11 if and only if a supporting mode is found.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
-#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
-#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
-#   Copyright (c) 2014 Alexey Sokolov <sokolov@google.com>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 4
-
-m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [[
-  template <typename T>
-    struct check
-    {
-      static_assert(sizeof(int) <= sizeof(T), "not big enough");
-    };
-
-    typedef check<check<bool>> right_angle_brackets;
-
-    int a;
-    decltype(a) b;
-
-    typedef check<int> check_type;
-    check_type c;
-    check_type&& cr = static_cast<check_type&&>(c);
-
-    auto d = a;
-    auto l = [](){};
-]])
-
-AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
-  m4_if([$1], [], [],
-        [$1], [ext], [],
-        [$1], [noext], [],
-        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
-  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
-        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
-        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
-        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])
-  AC_LANG_PUSH([C++])dnl
-  ac_success=no
-  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
-  ax_cv_cxx_compile_cxx11,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-    [ax_cv_cxx_compile_cxx11=yes],
-    [ax_cv_cxx_compile_cxx11=no])])
-  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
-    ac_success=yes
-  fi
-
-  m4_if([$1], [noext], [], [dnl
-  if test x$ac_success = xno; then
-    for switch in -std=gnu++11 -std=gnu++0x; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-
-  m4_if([$1], [ext], [], [dnl
-  if test x$ac_success = xno; then
-    for switch in -std=c++11 -std=c++0x; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-  AC_LANG_POP([C++])
-  if test x$ax_cxx_compile_cxx11_required = xtrue; then
-    if test x$ac_success = xno; then
-      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
-    fi
-  else
-    if test x$ac_success = xno; then
-      HAVE_CXX11=0
-      AC_MSG_NOTICE([No compiler with C++11 support was found])
-    else
-      HAVE_CXX11=1
-      AC_DEFINE(HAVE_CXX11,1,
-                [define if the compiler supports basic C++11 syntax])
-    fi
-
-    AC_SUBST(HAVE_CXX11)
-  fi
-])

opendht.pc.in

@@ -6,4 +6,6 @@ Name: OpenDHT
 Description: C++ Distributed Hash Table library
 Version: @VERSION@
 Libs: -L${libdir} -lopendht
+Libs.private: -lpthread
+Requires.private: gnutls >= 3.1
 Cflags: -I${includedir}

python/CMakeLists.txt

@@ -5,7 +5,7 @@ set(CURRENT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(setup.py.in setup.py)
 
 add_custom_target(python ALL
-	COMMAND python3 setup.py build
-	DEPENDS opendht opendht_cpp.pxd opendht.pyx)
+    COMMAND python3 setup.py build
+    DEPENDS opendht opendht_cpp.pxd opendht.pyx)
 
-install(CODE "execute_process(COMMAND python3 setup.py install WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})")
+install(CODE "execute_process(COMMAND python3 setup.py install --root=\$ENV{DESTDIR}/ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})")

python/Makefile.am

@@ -1,5 +1,7 @@
 if USE_CYTHON
 
+PYTHON_INSTALL_RECORD = $(builddir)/install_record.txt
+
 pybuild.stamp:
 	LDFLAGS="-L$(top_srcdir)/src/.libs" $(PYTHON) setup.py build_ext --inplace
 	echo stamp > pybuild.stamp
@@ -8,10 +10,16 @@ CLEANFILES = pybuild.stamp
 
 all-local: pybuild.stamp
 clean-local:
-	rm -rf $(builddir)/build $(builddir)/*.so
+	rm -rf $(builddir)/build $(builddir)/*.so $(PYTHON_INSTALL_RECORD)
 
-install:
-	$(PYTHON) setup.py install
+install-exec-local:
+	$(PYTHON) setup.py install --root=$(DESTDIR)/ --record $(PYTHON_INSTALL_RECORD)
 	rm -rf $(builddir)/build
 
-endif
+if HAVE_PIP
+uninstall-local:
+	/usr/bin/yes | $(PIP) uninstall $(PACKAGE)
+endif
+
+endif
+

python/opendht.pyx

@@ -84,9 +84,6 @@ cdef class InfoHash(_WithID):
         if op == 2:
             return self._infohash == other._infohash
         return NotImplemented
-    def __hash__(self):
-        cdef cpp.hash[cpp.InfoHash] hash_fn
-        return hash_fn.get(self._infohash)
     def getBit(InfoHash self, bit):
         return self._infohash.getBit(bit)
     def setBit(InfoHash self, bit, b):
@@ -142,7 +139,7 @@ cdef class Value(object):
     property owner:
         def __get__(self):
             h = InfoHash()
-            h._infohash = self._value.get().owner.getId()
+            h._infohash = self._value.get().owner.get().getId()
             return h
     property recipient:
         def __get__(self):
@@ -161,6 +158,9 @@ cdef class Value(object):
             return self._value.get().id
         def __set__(self, cpp.uint64_t value):
             self._value.get().id = value
+    property size:
+        def __get__(self):
+            return self._value.get().size()
 
 cdef class NodeSetIter(object):
     cdef map[cpp.InfoHash, cpp.shared_ptr[cpp.Node]]* _nodes
@@ -242,9 +242,9 @@ cdef class Identity(object):
             return c
 
 cdef class DhtConfig(object):
-    cdef cpp.Config _config
+    cdef cpp.DhtRunnerConfig _config
     def __init__(self):
-        self._config = cpp.Config()
+        self._config = cpp.DhtRunnerConfig()
         self._config.threaded = True;
     def setIdentity(self, Identity id):
         self._config.dht_config.id = id._id
@@ -279,7 +279,13 @@ cdef class DhtRunner(_WithID):
     def shutdown(self, shutdown_cb=None):
         cb_obj = {'shutdown':shutdown_cb}
         ref.Py_INCREF(cb_obj)
-        self.thisptr.shutdown(cpp.Dht.bindShutdownCb(shutdown_callback, <void*>cb_obj))
+        self.thisptr.shutdown(cpp.bindShutdownCb(shutdown_callback, <void*>cb_obj))
+    def enableLogging(self):
+        cpp.enableLogging(self.thisptr[0])
+    def disableLogging(self):
+        cpp.disableLogging(self.thisptr[0])
+    def enableFileLogging(self, str path):
+        cpp.enableFileLogging(self.thisptr[0], path)
     def isRunning(self):
         return self.thisptr.isRunning()
     def getStorageLog(self):
@@ -305,7 +311,7 @@ cdef class DhtRunner(_WithID):
         if get_cb:
             cb_obj = {'get':get_cb, 'done':done_cb}
             ref.Py_INCREF(cb_obj)
-            self.thisptr.get(key._infohash, cpp.Dht.bindGetCb(get_callback, <void*>cb_obj), cpp.Dht.bindDoneCb(done_callback, <void*>cb_obj))
+            self.thisptr.get(key._infohash, cpp.bindGetCb(get_callback, <void*>cb_obj), cpp.bindDoneCb(done_callback, <void*>cb_obj))
         else:
             lock = threading.Condition()
             pending = 0
@@ -332,9 +338,26 @@ cdef class DhtRunner(_WithID):
         val -- the value to put on the DHT
         done_cb -- optional callback called when the operation is completed.
         """
-        cb_obj = {'done':done_cb}
-        ref.Py_INCREF(cb_obj)
-        self.thisptr.put(key._infohash, val._value, cpp.Dht.bindDoneCb(done_callback, <void*>cb_obj))
+        if done_cb:
+            cb_obj = {'done':done_cb}
+            ref.Py_INCREF(cb_obj)
+            self.thisptr.put(key._infohash, val._value, cpp.bindDoneCb(done_callback, <void*>cb_obj))
+        else:
+            lock = threading.Condition()
+            pending = 0
+            ok = False
+            def tmp_done(ok_ret, nodes):
+                nonlocal pending, ok, lock
+                with lock:
+                    ok = ok_ret
+                    pending -= 1
+                    lock.notify()
+            with lock:
+                pending += 1
+                self.put(key, val, done_cb=tmp_done)
+                while pending > 0:
+                    lock.wait()
+            return ok
     def listen(self, InfoHash key, get_cb):
         t = ListenToken()
         t._h = key._infohash
@@ -342,7 +365,7 @@ cdef class DhtRunner(_WithID):
         t._cb['cb'] = cb_obj
         # avoid the callback being destructed if the token is destroyed
         ref.Py_INCREF(cb_obj)
-        t._t = self.thisptr.listen(t._h, cpp.Dht.bindGetCb(get_callback, <void*>cb_obj)).share()
+        t._t = self.thisptr.listen(t._h, cpp.bindGetCb(get_callback, <void*>cb_obj)).share()
         return t
     def cancelListen(self, ListenToken token):
         self.thisptr.cancelListen(token._h, token._t)

python/opendht_cpp.pxd

@@ -85,47 +85,44 @@ cdef extern from "opendht/value.h" namespace "dht":
         Value(vector[uint8_t]) except +
         Value(const uint8_t* dat_ptr, size_t dat_len) except +
         string toString() const
+        size_t size() const
         uint64_t id
-        PublicKey owner
+        shared_ptr[PublicKey] owner
         InfoHash recipient
         vector[uint8_t] data
         string user_type
 
-cdef extern from "opendht/dht.h" namespace "dht":
+cdef extern from "opendht/node.h" namespace "dht":
     cdef cppclass Node:
         Node() except +
         InfoHash getId() const
         string getAddrStr() const
         bool isExpired() const
+
+cdef extern from "opendht/callbacks.h" namespace "dht":
     ctypedef void (*ShutdownCallbackRaw)(void *user_data)
     ctypedef bool (*GetCallbackRaw)(shared_ptr[Value] values, void *user_data)
     ctypedef void (*DoneCallbackRaw)(bool done, vector[shared_ptr[Node]]* nodes, void *user_data)
-    cdef cppclass Dht:
-        cppclass Config:
-            InfoHash node_id
-            bool is_bootstrap
-        cppclass ShutdownCallback:
-            ShutdownCallback() except +
-        cppclass GetCallback:
-            GetCallback() except +
-            #GetCallback(GetCallbackRaw cb, void *user_data) except +
-        cppclass DoneCallback:
-            DoneCallback() except +
-            #DoneCallback(DoneCallbackRaw, void *user_data) except +
-        Dht() except +
-        InfoHash getNodeId() const
-        @staticmethod
-        ShutdownCallback bindShutdownCb(ShutdownCallbackRaw cb, void *user_data)
-        @staticmethod
-        GetCallback bindGetCb(GetCallbackRaw cb, void *user_data)
-        @staticmethod
-        DoneCallback bindDoneCb(DoneCallbackRaw cb, void *user_data)
 
-cdef extern from "opendht/dht.h" namespace "dht":
-    cdef cppclass SecureDht:
-        cppclass Config:
-            Dht.Config node_config
-            Identity id
+    cppclass ShutdownCallback:
+        ShutdownCallback() except +
+    cppclass GetCallback:
+        GetCallback() except +
+        #GetCallback(GetCallbackRaw cb, void *user_data) except +
+    cppclass DoneCallback:
+        DoneCallback() except +
+        #DoneCallback(DoneCallbackRaw, void *user_data) except +
+
+    cdef ShutdownCallback bindShutdownCb(ShutdownCallbackRaw cb, void *user_data)
+    cdef GetCallback bindGetCb(GetCallbackRaw cb, void *user_data)
+    cdef DoneCallback bindDoneCb(DoneCallbackRaw cb, void *user_data)
+
+    cppclass Config:
+        InfoHash node_id
+        bool is_bootstrap
+    cppclass SecureDhtConfig:
+        Config node_config
+        Identity id
 
 cdef extern from "opendht/dhtrunner.h" namespace "dht":
     ctypedef future[size_t] ListenToken
@@ -133,7 +130,7 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
     cdef cppclass DhtRunner:
         DhtRunner() except +
         cppclass Config:
-            SecureDht.Config dht_config
+            SecureDhtConfig dht_config
             bool threaded
         InfoHash getId() const
         InfoHash getNodeId() const
@@ -141,15 +138,21 @@ cdef extern from "opendht/dhtrunner.h" namespace "dht":
         void run(in_port_t, Config config)
         void run(const char*, const char*, const char*, Config config)
         void join()
-        void shutdown(Dht.ShutdownCallback)
+        void shutdown(ShutdownCallback)
         bool isRunning()
         string getStorageLog() const
         string getRoutingTablesLog(sa_family_t af) const
         string getSearchesLog(sa_family_t af) const
-        void get(InfoHash key, Dht.GetCallback get_cb, Dht.DoneCallback done_cb)
-        void put(InfoHash key, shared_ptr[Value] val, Dht.DoneCallback done_cb)
-        ListenToken listen(InfoHash key, Dht.GetCallback get_cb)
+        void get(InfoHash key, GetCallback get_cb, DoneCallback done_cb)
+        void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb)
+        ListenToken listen(InfoHash key, GetCallback get_cb)
         void cancelListen(InfoHash key, SharedListenToken token)
         vector[unsigned] getNodeMessageStats(bool i)
 
-ctypedef DhtRunner.Config Config
+ctypedef DhtRunner.Config DhtRunnerConfig
+
+cdef extern from "opendht/log.h" namespace "dht::log":
+    void enableLogging(DhtRunner& dht)
+    void disableLogging(DhtRunner& dht)
+    void enableFileLogging(DhtRunner& dht, const string& path)
+

python/setup.py.in

@@ -1,4 +1,4 @@
-# Copyright (C) 2015-2016 Savoir-faire Linux Inc. 
+# Copyright (C) 2015-2016 Savoir-faire Linux Inc.
 # Author: Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
 # Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #

python/tools/README.md

@@ -0,0 +1,45 @@
+# Benchmark
+
+The `benchmark.py` script is used for testing OpenDHT in various cases. If you
+run `benchmark.py --help`, you should find the following text:
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      --performance         Launches performance benchmark test. Available args
+                            for "-t" are: gets.
+      --data-persistence    Launches data persistence benchmark test. Available
+                            args for "-t" are: delete, replace, mult_time.
+                            Available args for "-o" are : dump_str_log,
+                            keep_alive, trigger, traffic_plot, op_plot. Use "-m"
+                            to specify the number of producers on the DHT.Use "-e"
+                            to specify the number of values to put on the DHT.
+
+These options specify the feature to be tested. Each feature has its own tests.
+You specify the test by using `-t` flag (see `benchmark.py --help` for full
+help).
+
+## Python dependencies
+
+- pyroute2 >=0.3.14
+- matplotlib
+- GeoIP (used by `scanner.py` for drawing map of the world)
+- ipaddress
+- netifaces
+- networkx
+- numpy
+
+## Usage
+
+Before running the script, you have to build and install OpenDHT and its cython
+wrapper (`cython3` has to be installed) on the system so that it can be found by
+the benchmark script.
+
+    $ cd $OPENDHT_SRC_DIR
+    $ ./autogen.sh
+    $ ./configure
+    $ make && sudo make install
+
+Then, you can use the script like so:
+
+    $ cd $OPENDHT_SRC_DIR/python/tools/
+    $ python3 benchmark.py --performance -t gets -n 2048

python/tools/benchmark.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 # Copyright (C) 2015-2016 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
@@ -22,6 +23,7 @@ import subprocess
 import signal
 import argparse
 import time
+import random
 
 from dht.network import DhtNetwork
 from dht.network import DhtNetworkSubProcess
@@ -130,7 +132,6 @@ class WorkBench():
 
 
 if __name__ == '__main__':
-
     parser = argparse.ArgumentParser(description='Run, test and benchmark a '\
             'DHT network on a local virtual network with simulated packet '\
             'loss and latency.')
@@ -146,27 +147,47 @@ if __name__ == '__main__':
     ifConfArgs.add_argument('-no6', '--disable-ipv6', action="store_true", help='Enable IPv6')
 
     testArgs = parser.add_argument_group('Test arguments')
+    testArgs.add_argument('--bs-dht-log', action='store_true', default=False, help='Enables dht log in bootstrap.')
     testArgs.add_argument('-t', '--test', type=str, default=None, required=True, help='Specifies the test.')
     testArgs.add_argument('-o', '--opt', type=str, default=[], nargs='+',
             help='Options passed to tests routines.')
+    testArgs.add_argument('-m', type=int, default=None, help='Generic size option passed to tests.')
+    testArgs.add_argument('-e', type=int, default=None, help='Generic size option passed to tests.')
 
     featureArgs = parser.add_mutually_exclusive_group(required=True)
-    featureArgs.add_argument('--performance', action='store_true', default=0,
+    featureArgs.add_argument('--performance', action='store_true', default=False,
             help='Launches performance benchmark test. Available args for "-t" are: gets.')
     featureArgs.add_argument('--data-persistence', action='store_true', default=0,
             help='Launches data persistence benchmark test. '\
-                    'Available args for "-t" are: delete, replace, mult_time. '\
-                    'Available args for "-o" are : dump_str_log')
-
+                 'Available args for "-t" are: delete, replace, mult_time. '\
+                 'Available args for "-o" are : dump_str_log, keep_alive, trigger, traffic_plot, op_plot. '\
+                 'Use "-m" to specify the number of producers on the DHT.'\
+                 'Use "-e" to specify the number of values to put on the DHT.')
 
     args = parser.parse_args()
+    test_opt = { o : True for o in args.opt }
 
     wb = WorkBench(args.ifname, args.virtual_locs, args.node_num, loss=args.loss,
             delay=args.delay, disable_ipv4=args.disable_ipv4,
             disable_ipv6=args.disable_ipv6)
-    wb.create_virtual_net()
-
     bootstrap = wb.get_bootstrap()
+
+    bs_dht_log_enabled = False
+    def toggle_bs_dht_log(signum, frame):
+        global bs_dht_log_enabled, bootstrap
+        if bs_dht_log_enabled:
+            bootstrap.front().disableLogging()
+            bs_dht_log_enabled = False
+        else:
+            bootstrap.front().enableLogging()
+            bs_dht_log_enabled = True
+    signal.signal(signal.SIGUSR1, toggle_bs_dht_log)
+
+    if args.bs_dht_log:
+        bs_dht_log_enabled = True
+        bootstrap.front().enableLogging()
+
+    wb.create_virtual_net()
     bootstrap.resize(1)
     print("Launching", wb.node_num, "nodes (", wb.clusters, "clusters of", wb.node_per_loc, "nodes)")
 
@@ -174,10 +195,17 @@ if __name__ == '__main__':
         for i in range(wb.clusters):
             wb.start_cluster(i)
 
+        # recover -e and -m values.
+        if args.e:
+            test_opt.update({ 'num_values' : args.e })
+        if args.m:
+            test_opt.update({ 'num_producers' : args.m })
+
+        # run the test
         if args.performance:
-            PerformanceTest(args.test, wb, *args.opt).run()
+            PerformanceTest(args.test, wb, test_opt).run()
         elif args.data_persistence:
-            PersistenceTest(args.test, wb, *args.opt).run()
+            PersistenceTest(args.test, wb, test_opt).run()
 
     except Exception as e:
         print(e)

python/tools/dht/network.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 # Copyright (c) 2015-2016 Savoir-faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
@@ -33,7 +34,11 @@ from pyroute2.netns.process.proxy import NSPopen
 from opendht import *
 
 
-# TODO: find where token "notifyend" gets printed...
+# useful functions
+b_space_join = lambda *l: b' '.join(map(bytes, l))
+
+# TODO: find where token "notifyend" gets printed... Or switch to MSGPACK for
+# serialisation of packets between both processes.
 class DhtNetworkSubProcess(NSPopen):
     """
     Handles communication with DhtNetwork sub process.
@@ -43,6 +48,8 @@ class DhtNetworkSubProcess(NSPopen):
     therefor, waits for the sub process to spawn.
     """
     # requests
+    NODE_PUT_REQ              = b"np"
+    NEW_NODE_REQ              = b"nn"
     REMOVE_NODE_REQ           = b"rn"
     SHUTDOWN_NODE_REQ         = b"sdn"
     SHUTDOWN_REPLACE_NODE_REQ = b'sdrn'
@@ -169,7 +176,7 @@ class DhtNetworkSubProcess(NSPopen):
         process.
 
         @param answer_cb: Callback to call when an answer is given after notify.
-                          The function takes a list of lines as argument.
+                          The function takes a list of strings as argument.
         @type  answer_cb:  function
         """
         notified = False
@@ -189,6 +196,17 @@ class DhtNetworkSubProcess(NSPopen):
             else:
                 time.sleep(0.1)
 
+    def _sendRequest(self, request, answer_cb=None):
+        """
+        Sends a request to the sub network and wait for output.
+
+        @param request: The serialized request.
+        @type  request: bytes
+        """
+        self.send(request + b'\n')
+        for line in self.getlinesUntilNotify(answer_cb=answer_cb):
+            DhtNetwork.log(line)
+
     def sendGetMessageStats(self):
         """
         Sends DhtNetwork sub process statistics request about nodes messages
@@ -203,51 +221,45 @@ class DhtNetworkSubProcess(NSPopen):
             Callback fed to getlinesUntilNotify made to recover answer from the
             DhtNetwork sub process.
 
-            :answer: the list of lines answered by the sub process.
+            @param answer: the list of lines answered by the sub process.
+            @type  answer: function
             """
             nonlocal stats
             if answer:
                 stats = [int(v) for v in re.findall("[0-9]+", answer.pop())]
 
-        self.send(DhtNetworkSubProcess.MESSAGE_STATS + b'\n')
-        for line in self.getlinesUntilNotify(answer_cb=cb):
-            DhtNetwork.log(line)
-
+        self._sendRequest(DhtNetworkSubProcess.MESSAGE_STATS, answer_cb=cb)
         return stats
 
-    def sendNodesRequest(self, request, ids):
+    def sendNodePutRequest(self, _hash, value):
         """
-        Shutsdown nodes on the DhtNetwork sub process.
+        Sends a put operation request.
 
-        @param request: The request
-        @type  request: bytes
-        @param     ids: ids of nodes concerned by the request.
-        @type      ids: list
+        @param _hash: the hash of the value.
+        @type  _hash: bytes.
+        @param value: the value.
+        @type  value: bytes.
         """
-        serialized_req = request + b' ' + b' '.join(map(bytes, ids))
-        self.send(serialized_req + b'\n')
-        for line in self.getlinesUntilNotify():
-            DhtNetwork.log(line)
+        self._sendRequest(b_space_join(DhtNetworkSubProcess.NODE_PUT_REQ, _hash,
+            value))
 
-    def sendShutdown(self):
+    def sendNodesRequest(self, request, ids=b''):
         """
-        Shutdown the whole cluster. This does not terminate comunicating thread;
-        use quit().
-        """
-        self.send(DhtNetworkSubProcess.SHUTDOWN_CLUSTER_REQ + b'\n')
-        for line in self.getlinesUntilNotify():
-            DhtNetwork.log(line)
+        Send request to a list of nodes or the whole cluster.
 
-    def sendDumpStorage(self, ids):
+        @param request: The request. Possible values are:
+            DhtNetworkSubProcess.NODE_PUT_REQ
+            DhtNetworkSubProcess.REMOVE_NODE_REQ
+            DhtNetworkSubProcess.SHUTDOWN_NODE_REQ
+            DhtNetworkSubProcess.SHUTDOWN_REPLACE_NODE_REQ
+            DhtNetworkSubProcess.SHUTDOWN_CLUSTER_REQ
+            DhtNetworkSubProcess.DUMP_STORAGE_REQ
+            DhtNetworkSubProcess.MESSAGE_STATS
+        @type request: bytes
+        @param ids: The list of ids concerned by the request.
+        @type  ids: list
         """
-        Dumps storage log from nodes with id in `ids`.
-        """
-        serialized_req = DhtNetworkSubProcess.DUMP_STORAGE_REQ + b' ' + \
-                    b' '.join(map(bytes, ids))
-        self.send(serialized_req + b'\n')
-        for line in self.getlinesUntilNotify():
-            DhtNetwork.log(line)
-
+        self._sendRequest(b_space_join(request, b_space_join(*ids)))
 
 class DhtNetwork(object):
     nodes = []
@@ -261,13 +273,11 @@ class DhtNetwork(object):
     @staticmethod
     def run_node(ip4, ip6, p, bootstrap=[], is_bootstrap=False):
         DhtNetwork.log("run_node", ip4, ip6, p, bootstrap)
-        id = Identity()
-        #id.generate("dhtbench"+str(p), Identity(), 1024)
         n = DhtRunner()
-        n.run(id, ipv4=ip4 if ip4 else "", ipv6=ip6 if ip6 else "", port=p, is_bootstrap=is_bootstrap)
+        n.run(ipv4=ip4 if ip4 else "", ipv6=ip6 if ip6 else "", port=p, is_bootstrap=is_bootstrap)
         for b in bootstrap:
             n.bootstrap(b[0], b[1])
-        #plt.pause(0.02)
+        time.sleep(.01)
         return ((ip4, ip6, p), n, id)
 
     @staticmethod
@@ -298,8 +308,21 @@ class DhtNetwork(object):
             return None
         return self.nodes[0][1]
 
-    def get(self, n):
-        return self.nodes[n][1]
+    def get(self, i=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
+        else:
+            return None
 
     def launch_node(self):
         n = DhtNetwork.run_node(self.ip4, self.ip6, self.port, self.bootstrap)
@@ -329,21 +352,22 @@ class DhtNetwork(object):
 
         if not self.nodes:
             return
-        if id is not None:
-            for n in self.nodes:
-                if n[1].getNodeId() == id:
-                    if shutdown:
-                        with lock:
-                            DhtNetwork.log('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)
-                    DhtNetwork.log(id, 'deleted !')
-                    return True
-            return False
+        elif id is not None:
+            n = self.getNodeInfoById(id)
+            if n:
+                if shutdown:
+                    with lock:
+                        DhtNetwork.log('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)
+                DhtNetwork.log(id, 'deleted !')
+                return True
+            else:
+                return False
         else:
             n = self.nodes.pop()
             n[1].join()
@@ -361,11 +385,11 @@ class DhtNetwork(object):
         if n == l:
             return
         if n > l:
-            DhtNetwork.log("Launching", n-l, "nodes")
+            DhtNetwork.log("Launching", n-l, "nodes", self.ip4, self.ip6)
             for i in range(l, n):
                 self.launch_node()
         else:
-            DhtNetwork.log("Ending", l-n, "nodes")
+            DhtNetwork.log("Ending", l-n, "nodes", self.ip4, self.ip6)
             #random.shuffle(self.nodes)
             for i in range(n, l):
                 self.end_node()
@@ -385,14 +409,11 @@ if __name__ == '__main__':
     lock = threading.Condition()
     quit = False
 
-    def notify_benchmark(answer=None):
-        NOTIFY_TOKEN     = 'notify'
-        NOTIFY_END_TOKEN = 'notifyend'
-
-        sys.stdout.write('%s\n' % NOTIFY_TOKEN)
-        for line in answer if answer else []:
+    def notify_benchmark(answer=[]):
+        sys.stdout.write('%s\n' % DhtNetworkSubProcess.NOTIFY_TOKEN)
+        for line in answer:
             sys.stdout.write(str(line)+'\n')
-        sys.stdout.write('%s\n' % NOTIFY_END_TOKEN)
+        sys.stdout.write('%s\n' % DhtNetworkSubProcess.NOTIFY_END_TOKEN)
         sys.stdout.flush()
 
     def listen_to_mother_nature(stdin, q):
@@ -461,28 +482,42 @@ if __name__ == '__main__':
                 except queue.Empty:
                     pass
                 else:
-                    REMOVE_NODE_REQ           = 'rn'
-                    SHUTDOWN_NODE_REQ         = 'sdn'
-                    SHUTDOWN_REPLACE_NODE_REQ = 'sdrn'
-                    SHUTDOWN_CLUSTER_REQ      = 'sdc'
-                    DUMP_STORAGE_REQ          = 'strl'
-                    MESSAGE_STATS             = 'gms'
+                    NODE_PUT_REQ              = DhtNetworkSubProcess.NODE_PUT_REQ.decode()
+                    NEW_NODE_REQ              = DhtNetworkSubProcess.NEW_NODE_REQ.decode()
+                    REMOVE_NODE_REQ           = DhtNetworkSubProcess.REMOVE_NODE_REQ.decode()
+                    SHUTDOWN_NODE_REQ         = DhtNetworkSubProcess.SHUTDOWN_NODE_REQ.decode()
+                    SHUTDOWN_REPLACE_NODE_REQ = DhtNetworkSubProcess.SHUTDOWN_REPLACE_NODE_REQ.decode()
+                    SHUTDOWN_CLUSTER_REQ      = DhtNetworkSubProcess.SHUTDOWN_CLUSTER_REQ.decode()
+                    DUMP_STORAGE_REQ          = DhtNetworkSubProcess.DUMP_STORAGE_REQ.decode()
+                    MESSAGE_STATS             = DhtNetworkSubProcess.MESSAGE_STATS.decode()
 
                     if req in [SHUTDOWN_NODE_REQ,
                                SHUTDOWN_REPLACE_NODE_REQ,
                                REMOVE_NODE_REQ]:
-                        DhtNetwork.log('got node deletion request.')
-                        for n in req_args:
+                        def delete_request(req, n):
+                            global msg_stats
                             if req == SHUTDOWN_NODE_REQ:
                                 net.end_node(id=n, shutdown=True, last_msg_stats=msg_stats)
                             elif req == SHUTDOWN_REPLACE_NODE_REQ:
                                 net.replace_node(id=n, shutdown=True, last_msg_stats=msg_stats)
                             elif req == REMOVE_NODE_REQ:
                                 net.end_node(id=n, last_msg_stats=msg_stats)
+
+                        if len(req) > 0:
+                            for n in req_args:
+                                delete_request(req, n)
+                        else:
+                            delete_request(req, net.get().getNodeId())
                     elif req == SHUTDOWN_CLUSTER_REQ:
                         for n in net.nodes:
-                            n.end_node(shutdown=True, last_msg_stats=msg_stats)
+                            net.end_node(id=n[2], shutdown=True, last_msg_stats=msg_stats)
                         quit = True
+                    elif req == NEW_NODE_REQ:
+                        net.launch_node()
+                    elif req == NODE_PUT_REQ:
+                        _hash, v = req_args[:2]
+                        net.get().put(InfoHash(_hash), Value(v))
+
                     elif req == DUMP_STORAGE_REQ:
                         for n in [m[1] for m in net.nodes if m[1].getNodeId() in req_args]:
                             net.log(n.getStorageLog())

python/tools/dht/tests.py

@@ -1,26 +1,35 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2015 Savoir-Faire Linux Inc.
 # Author(s): Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #            Simon Désaulniers <sim.desaulniers@gmail.com>
 
+import os
 import threading
 import random
 import string
 import time
+import subprocess
+import re
 
 import numpy as np
 import matplotlib.pyplot as plt
+from matplotlib.ticker import FuncFormatter
 
 from opendht import *
 from dht.network import DhtNetwork, DhtNetworkSubProcess
 
-######################
-#  Common functions  #
-######################
+############
+#  Common  #
+############
+
+# matplotlib display format for bits (b, Kb, Mb)
+bit_format = None
+Kbit_format = FuncFormatter(lambda x, pos: '%1.1f' % (x*1024**-1) + 'Kb')
+Mbit_format = FuncFormatter(lambda x, pos: '%1.1f' % (x*1024**-2) + 'Mb')
 
 def random_hash():
     return InfoHash(''.join(random.SystemRandom().choice(string.hexdigits) for _ in range(40)).encode())
 
-
 def reset_before_test(featureTestMethod):
     """
     This is a decorator for all test methods needing reset().
@@ -36,6 +45,84 @@ def reset_before_test(featureTestMethod):
         return featureTestMethod(*args, **kwargs)
     return call
 
+def display_plot(yvals, xvals=None, yformatter=None, display_time=3, **kwargs):
+    """
+    Displays a plot of data in interactive mode. This method is made to be
+    called successively for plot refreshing.
+
+    @param yvals:  Ordinate values (float).
+    @type  yvals:  list
+    @param xvals:  Abscissa values (float).
+    @type  xvals:  list
+    @param yformatter:  The matplotlib FuncFormatter to use for y values.
+    @type  yformatter:  matplotlib.ticker.FuncFormatter
+    @param displaytime:  The time matplotlib can take to refresht the plot.
+    @type  displaytime:  int
+    """
+    plt.ion()
+    plt.clf()
+    plt.show()
+    if yformatter:
+        plt.axes().yaxis.set_major_formatter(Kbit_format)
+    if xvals:
+        plt.plot(xvals, yvals, **kwargs)
+    else:
+        plt.plot(yvals, **kwargs)
+    plt.pause(display_time)
+
+def iftop_traffic_data(ifname, interval=2, rate_type='send_receive'):
+    """
+    Generator (yields data) function collecting traffic data from iftop
+    subprocess.
+
+    @param ifname: Interface to listen to.
+    @type  ifname: string
+    @param interval: Interval of time between to data collections. Possible
+                     values are 2, 10 or 40.
+    @type  interval: int
+    @param rates: (default: send_receive) Wether to pick "send", "receive"
+                  or "send and receive" rates. Possible values : "send",
+                  "receive" and "send_receive".
+    @type  rates: string
+    @param _format: Format in which to display data on the y axis.
+                    Possible values: Mb, Kb or b.
+    @type  _format: string
+    """
+    # iftop stdout string format
+    SEND_RATE_STR               = "Total send rate"
+    RECEIVE_RATE_STR            = "Total receive rate"
+    SEND_RECEIVE_RATE_STR       = "Total send and receive rate"
+    RATE_STR = {
+            "send"         : SEND_RATE_STR,
+            "receive"      : RECEIVE_RATE_STR,
+            "send_receive" : SEND_RECEIVE_RATE_STR
+    }
+    TWO_SECONDS_RATE_COL    = 0
+    TEN_SECONDS_RATE_COL    = 1
+    FOURTY_SECONDS_RATE_COL = 2
+    COLS = {
+            2  : TWO_SECONDS_RATE_COL,
+            10 : TEN_SECONDS_RATE_COL,
+            40 : FOURTY_SECONDS_RATE_COL
+    }
+    FLOAT_REGEX = "[0-9]+[.]*[0-9]*"
+    BIT_REGEX = "[KM]*b"
+
+    iftop = subprocess.Popen(["iftop", "-i", ifname, "-t"], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    while True:
+        line = iftop.stdout.readline().decode()
+        if RATE_STR[rate_type] in line:
+            rate, unit = re.findall("("+FLOAT_REGEX+")("+BIT_REGEX+")", line)[COLS[interval]]
+            rate = float(rate)
+            if unit == "Kb":
+                rate *= 1024
+            elif unit == "Mb":
+                rate *= 1024**2
+            yield rate
+
+###########
+#  Tests  #
+###########
 
 class FeatureTest(object):
     done = 0
@@ -95,7 +182,8 @@ class DhtFeatureTest(FeatureTest):
 
     @staticmethod
     def getcb(value):
-        DhtNetwork.log('[GET]: %s' % value)
+        vstr = value.__str__()[:100]
+        DhtNetwork.log('[GET]: %s' % vstr + ("..." if len(vstr) > 100 else ""))
         DhtFeatureTest.foreignValues.append(value)
         return True
 
@@ -120,30 +208,39 @@ class DhtFeatureTest(FeatureTest):
             FeatureTest.lock.notify()
 
     def _dhtPut(self, producer, _hash, *values):
-        for val in values:
-            with FeatureTest.lock:
-                DhtNetwork.log('[PUT]: %s' % val)
-                FeatureTest.done += 1
-                producer.put(_hash, val, DhtFeatureTest.putDoneCb)
-                while FeatureTest.done > 0:
-                    FeatureTest.lock.wait()
+        with FeatureTest.lock:
+            for val in values:
+                    vstr = val.__str__()[:100]
+                    DhtNetwork.log('[PUT]:', _hash.toString(), '->', vstr + ("..." if len(vstr) > 100 else ""))
+                    FeatureTest.done += 1
+                    producer.put(_hash, val, DhtFeatureTest.putDoneCb)
+            while FeatureTest.done > 0:
+                FeatureTest.lock.wait()
 
     def _dhtGet(self, consumer, _hash):
         DhtFeatureTest.foreignValues = []
         DhtFeatureTest.foreignNodes = []
         with FeatureTest.lock:
             FeatureTest.done += 1
+            DhtNetwork.log('[GET]:', _hash.toString())
             consumer.get(_hash, DhtFeatureTest.getcb, DhtFeatureTest.getDoneCb)
             while FeatureTest.done > 0:
                 FeatureTest.lock.wait()
 
+    def _gottaGetThemAllPokeNodes(self, consumer, hashes, nodes=None):
+        for h in hashes:
+            self._dhtGet(consumer, h)
+            if nodes is not None:
+                for n in DhtFeatureTest.foreignNodes:
+                    nodes.add(n)
+
 
 class PersistenceTest(DhtFeatureTest):
     """
     This tests persistence of data on the network.
     """
 
-    def __init__(self, test, workbench, *opts):
+    def __init__(self, test, workbench, opts):
         """
         @param test: is one of the following:
                      - 'mult_time': test persistence of data based on internal
@@ -156,13 +253,53 @@ class PersistenceTest(DhtFeatureTest):
 
         OPTIONS
 
-        - dump_str_log: enables storage log at test ending.
+        - dump_str_log:  Enables storage log at test ending.
+        - keep_alive:    Keeps the test running indefinately. This may be useful
+                         to manually analyse the network traffic during a longer
+                         period.
+        - num_producers: Number of producers of data during a DHT test.
+        - num_values:    Number of values to initialize the DHT with.
         """
 
         # opts
         super(PersistenceTest, self).__init__(test, workbench)
-        self._dump_storage = True if 'dump_str_log' in opts else False
-        self._plot = True if 'plot' in opts else False
+        self._traffic_plot  = True if 'traffic_plot' in opts else False
+        self._dump_storage  = True if 'dump_str_log' in opts else False
+        self._op_plot       = True if 'op_plot' in opts else False
+        self._keep_alive    = True if 'keep_alive' in opts else False
+        self._num_producers = opts['num_producers'] if 'num_producers' in opts else None
+        self._num_values    = opts['num_values'] if 'num_values' in opts else None
+
+    def _trigger_dp(self, trigger_nodes, _hash, count=1):
+        """
+        Triggers the data persistence over time. In order to this, `count` nodes
+        are created with an id around the hash of a value.
+
+        @param trigger_nodes: List of created nodes. The nodes created in this
+                              function are append to this list.
+        @type  trigger_nodes: list
+        @param _hash: Is the id of the value around which creating nodes.
+        @type  _hash: InfoHash
+        @param count: The number of nodes to create with id around the id of
+                      value.
+        @type  count: int
+        """
+        _hash_str = _hash.toString().decode()
+        _hash_int = int(_hash_str, 16)
+        for i in range(int(-count/2), int(count/2)+1):
+            _hash_str = '{:40x}'.format(_hash_int + i)
+            config = DhtConfig()
+            config.setNodeId(InfoHash(_hash_str.encode()))
+            n = DhtRunner()
+            n.run(config=config)
+            n.bootstrap(self.bootstrap.ip4,
+                        str(self.bootstrap.port))
+            DhtNetwork.log('Node','['+_hash_str+']',
+                           'started around', _hash.toString().decode()
+                           if n.isRunning() else
+                           'failed to start...'
+            )
+            trigger_nodes.append(n)
 
     def _result(self, local_values, new_nodes):
         bootstrap = self.bootstrap
@@ -179,29 +316,114 @@ class PersistenceTest(DhtFeatureTest):
                 if self._dump_storage:
                     DhtNetwork.log('Dumping all storage log from '\
                                   'hosting nodes.')
-
                     for proc in self._workbench.procs:
-                        proc.sendDumpStorage(DhtFeatureTest.foreignNodes)
+                        proc.sendNodesRequest(DhtNetworkSubProcess.DUMP_STORAGE_REQ, DhtFeatureTest.foreignNodes)
             else:
                 DhtNetwork.log("Values didn't reach new hosting nodes after shutdown.")
 
     def run(self):
         try:
-            if self._test == 'delete':
+            if self._test == 'normal':
+                self._totallyNormalTest()
+            elif self._test == 'delete':
                 self._deleteTest()
             elif self._test == 'replace':
                 self._replaceClusterTest()
             elif self._test == 'mult_time':
                 self._multTimeTest()
+            else:
+                raise NameError("This test is not defined '" + self._test + "'")
         except Exception as e:
             print(e)
         finally:
+            if self._traffic_plot or self._op_plot:
+                plot_fname = "traffic-plot"
+                print('plot saved to', plot_fname)
+                plt.savefig(plot_fname)
             self.bootstrap.resize(1)
 
     ###########
     #  Tests  #
     ###########
 
+    @reset_before_test
+    def _totallyNormalTest(self):
+        """
+        Reproduces a network in a realistic state.
+        """
+        trigger_nodes = []
+        wb = self._workbench
+        bootstrap = self.bootstrap
+        # Value representing an ICE packet. Each ICE packet is around 1KB.
+        VALUE_SIZE = 1024
+        NUM_VALUES = self._num_values/wb.node_num if self._num_values else 5
+        nr_values = NUM_VALUES * wb.node_num
+        nr_nodes = wb.node_num
+        nr_nodes_cv = threading.Condition()
+
+        values = [b''.join(random.choice(string.hexdigits).encode() for _ in range(VALUE_SIZE)) for __ in range(NUM_VALUES)]
+        hashes = [random_hash() for _ in range(wb.node_num)]
+
+        # initial set of values
+        i = 0
+        for h in hashes:
+           self._dhtPut(bootstrap.front(), h, *[Value(v) for v in values])
+           print("at: ", i)
+           i += 1
+
+        def normalBehavior(do, t, log=None):
+            nonlocal nr_values
+            while True:
+                do()
+                time.sleep(random.choice(range(t)))
+
+        def putRequest():
+            nonlocal hashes, values, nr_values
+            nr_values += 1
+            DhtNetwork.log("Random value put on the DHT.", "(now "+ str(nr_values)+" values on the dht)")
+            random.choice(wb.procs).sendNodePutRequest(random.choice(hashes).toString(), random.choice(values))
+        puts = threading.Thread(target=normalBehavior, args=(putRequest, 30))
+        puts.daemon = True
+        puts.start()
+        def newNodeRequest():
+            nonlocal nr_nodes
+            with nr_nodes_cv:
+                nr_nodes += 1
+                DhtNetwork.log("Node joining the DHT.", "(now "+str(nr_nodes)+" nodes on the dht)")
+                nr_nodes_cv.notify()
+            random.choice(wb.procs).sendNodesRequest(DhtNetworkSubProcess.NEW_NODE_REQ)
+        connections = threading.Thread(target=normalBehavior, args=(newNodeRequest, 1*60))
+        connections.daemon = True
+        connections.start()
+        def shutdownNodeRequest():
+            nonlocal nr_nodes
+            with nr_nodes_cv:
+                nr_nodes -= 1
+                DhtNetwork.log("Node quitting the DHT.", "(now "+str(nr_nodes)+" nodes on the dht)")
+                nr_nodes_cv.notify()
+            random.choice(wb.procs).sendNodesRequest(DhtNetworkSubProcess.SHUTDOWN_NODE_REQ)
+        shutdowns = threading.Thread(target=normalBehavior, args=(shutdownNodeRequest, 1*60))
+        shutdowns.daemon = True
+        shutdowns.start()
+
+        for h in hashes:
+           self._trigger_dp(trigger_nodes, h)
+
+        if self._traffic_plot:
+            ydata = []
+            xdata = []
+            # warning: infinite loop
+            interval = 2
+            for rate in iftop_traffic_data("br"+wb.ifname, interval=interval):
+                ydata.append(rate)
+                xdata.append((xdata[-1] if len(xdata) > 0 else 0) + interval)
+                display_plot(ydata, xvals=xdata, yformatter=Kbit_format, color='blue')
+        else:
+            # blocks in matplotlib thread
+            while True:
+                plt.pause(3600)
+
+
     @reset_before_test
     def _deleteTest(self):
         """
@@ -236,9 +458,6 @@ class PersistenceTest(DhtFeatureTest):
             for node in DhtFeatureTest.foreignNodes:
                 DhtNetwork.log(node)
 
-            #DhtNetwork.log("Waiting a minute for the network to settle down.")
-            #time.sleep(60)
-
             for _ in range(max(1, int(self._workbench.node_num/32))):
                 DhtNetwork.log('Removing all nodes hosting target values...')
                 cluster_ops_count = 0
@@ -251,8 +470,8 @@ class PersistenceTest(DhtFeatureTest):
                     DhtNetwork.log('sending message stats request')
                     stats = proc.sendGetMessageStats()
                     cluster_ops_count += sum(stats[1:])
-                    DhtNetwork.log("3 seconds wait...")
-                    time.sleep(3)
+                    DhtNetwork.log("5 seconds wait...")
+                    time.sleep(5)
                 ops_count.append(cluster_ops_count/self._workbench.node_num)
 
                 # checking if values were transfered to new nodes
@@ -263,23 +482,17 @@ class PersistenceTest(DhtFeatureTest):
 
                 self._result(local_values, new_nodes)
 
-            if self._plot:
-                plt.plot(ops_count, color='blue')
-                plt.draw()
-                plt.ioff()
-                plt.show()
+            if self._op_plot:
+                display_plot(ops_count, color='blue')
         else:
             DhtNetwork.log("[GET]: either couldn't fetch values or nodes hosting values...")
 
-    #TODO: complete this test.
     @reset_before_test
     def _replaceClusterTest(self):
         """
         It replaces all clusters one after the other.
         """
-
-        #clusters = opts['clusters'] if 'clusters' in opts else 5
-        clusters = 5
+        clusters = 8
 
         bootstrap = self.bootstrap
 
@@ -299,7 +512,7 @@ class PersistenceTest(DhtFeatureTest):
             i = random.randint(0, len(self._workbench.procs)-1)
             proc = self._workbench.procs[i]
             DhtNetwork.log('Replacing', proc)
-            proc.sendShutdown()
+            proc.sendNodesRequest(DhtNetworkSubProcess.SHUTDOWN_CLUSTER_REQ)
             self._workbench.stop_cluster(i)
             self._workbench.start_cluster(i)
 
@@ -309,7 +522,6 @@ class PersistenceTest(DhtFeatureTest):
 
         self._result(local_values, new_nodes)
 
-    #TODO: complete this test.
     @reset_before_test
     def _multTimeTest(self):
         """
@@ -318,75 +530,59 @@ class PersistenceTest(DhtFeatureTest):
         enable storage maintenance each nodes. Therefor, this tests will wait 10
         minutes for the nodes to trigger storage maintenance.
         """
+        trigger_nodes = []
         bootstrap = self.bootstrap
 
-        N_PRODUCERS = 16
+        N_PRODUCERS = self._num_producers if self._num_values else 16
+        DP_TIMEOUT = 1
 
         hashes = []
-        values = [Value(b'foo')]
-        nodes = set([])
 
-        # prevents garbage collecting of unused flood nodes during the test.
-        flood_nodes = []
-
-        def gottaGetThemAllPokeNodes(nodes=None):
-            nonlocal consumer, hashes
-            for h in hashes:
-                self._dhtGet(consumer, h)
-                if nodes is not None:
-                    for n in DhtFeatureTest.foreignNodes:
-                        nodes.add(n)
-
-        def createNodesAroundHash(_hash, radius=4):
-            nonlocal flood_nodes
-
-            _hash_str = _hash.toString().decode()
-            _hash_int = int(_hash_str, 16)
-            for i in range(-radius, radius+1):
-                _hash_str = '{:40x}'.format(_hash_int + i)
-                config = DhtConfig()
-                config.setNodeId(InfoHash(_hash_str.encode()))
-                n = DhtRunner()
-                n.run(config=config)
-                n.bootstrap(self.bootstrap.ip4,
-                            str(self.bootstrap.port))
-                flood_nodes.append(n)
+        # Generating considerable amount of values of size 1KB.
+        VALUE_SIZE = 1024
+        NUM_VALUES = self._num_values if self._num_values else 50
+        values = [Value(''.join(random.choice(string.hexdigits) for _ in range(VALUE_SIZE)).encode()) for _ in range(NUM_VALUES)]
 
         bootstrap.resize(N_PRODUCERS+2)
-        consumer = bootstrap.get(1)
-        producers = (bootstrap.get(n) for n in range(2,N_PRODUCERS+2))
+        consumer = bootstrap.get(N_PRODUCERS+1)
+        producers = (bootstrap.get(n) for n in range(1,N_PRODUCERS+1))
         for p in producers:
             hashes.append(random_hash())
             self._dhtPut(p, hashes[-1], *values)
 
-        gottaGetThemAllPokeNodes(nodes=nodes)
+        once = True
+        while self._keep_alive or once:
+            nodes = set([])
+            self._gottaGetThemAllPokeNodes(consumer, hashes, nodes=nodes)
 
-        DhtNetwork.log("Values are found on:")
-        for n in nodes:
-            DhtNetwork.log(n)
+            DhtNetwork.log("Values are found on:")
+            for n in nodes:
+                DhtNetwork.log(n)
 
-        DhtNetwork.log("Creating 8 nodes around all of these nodes...")
-        for _hash in hashes:
-            createNodesAroundHash(_hash)
+            DhtNetwork.log("Creating 8 nodes around all of these hashes...")
+            for _hash in hashes:
+                self._trigger_dp(trigger_nodes, _hash, count=8)
 
-        DhtNetwork.log('Waiting 10 minutes for normal storage maintenance.')
-        time.sleep(10*60)
+            DhtNetwork.log('Waiting', DP_TIMEOUT+1, 'minutes for normal storage maintenance.')
+            time.sleep((DP_TIMEOUT+1)*60)
 
-        DhtNetwork.log('Deleting old nodes from previous search.')
-        for proc in self._workbench.procs:
-            DhtNetwork.log('[REMOVE]: sending shutdown request to', proc)
-            proc.sendNodesRequest(
-                DhtNetworkSubProcess.REMOVE_NODE_REQ,
-                nodes
-            )
+            DhtNetwork.log('Deleting old nodes from previous search.')
+            for proc in self._workbench.procs:
+                DhtNetwork.log('[REMOVE]: sending delete request to', proc)
+                proc.sendNodesRequest(
+                    DhtNetworkSubProcess.REMOVE_NODE_REQ,
+                    nodes)
 
-        # new consumer (fresh cache)
-        bootstrap.resize(N_PRODUCERS+3)
-        consumer = bootstrap.get(N_PRODUCERS+2)
+            # new consumer (fresh cache)
+            bootstrap.resize(N_PRODUCERS+1)
+            bootstrap.resize(N_PRODUCERS+2)
+            consumer = bootstrap.get(N_PRODUCERS+1)
 
-        nodes_after_time = set([])
-        gottaGetThemAllPokeNodes(nodes=nodes_after_time)
-        self._result(values, nodes_after_time - nodes)
+            nodes_after_time = set([])
+            self._gottaGetThemAllPokeNodes(consumer, hashes, nodes=nodes_after_time)
+            self._result(values, nodes_after_time - nodes)
+
+            once = False
 
 
 class PerformanceTest(DhtFeatureTest):
@@ -394,7 +590,7 @@ class PerformanceTest(DhtFeatureTest):
     Tests for general performance of dht operations.
     """
 
-    def __init__(self, test, workbench, *opts):
+    def __init__(self, test, workbench, opts):
         """
         @param test: is one of the following:
                      - 'gets': multiple get operations and statistical results.
@@ -411,6 +607,8 @@ class PerformanceTest(DhtFeatureTest):
                 self._getsTimesTest()
             elif self._test == 'delete':
                 self._delete()
+            else:
+                raise NameError("This test is not defined '" + self._test + "'")
         except Exception as e:
             print(e)
         finally:
@@ -441,7 +639,7 @@ class PerformanceTest(DhtFeatureTest):
         hax.set_ylim(0, 2)
 
         # let the network stabilise
-        plt.pause(60)
+        plt.pause(20)
 
         #start = time.time()
         times = []
@@ -454,7 +652,7 @@ class PerformanceTest(DhtFeatureTest):
             DhtNetwork.log("found", v)
             return True
 
-        def donecb(ok, nodes):
+        def donecb(ok, nodes, start):
             nonlocal bootstrap, lock, done, times
             t = time.time()-start
             with lock:
@@ -470,7 +668,10 @@ class PerformanceTest(DhtFeatureTest):
                 l = lines.pop()
                 l.remove()
                 del l
-            lines = plt.plot(times, color='blue')
+            if len(times) > 1:
+                n, bins, lines = hax.hist(times, 100, normed=1, histtype='stepfilled', color='g')
+                hax.set_ylim(min(n), max(n))
+                lines.extend(lax.plot(times, color='blue'))
             plt.draw()
 
         def run_get():
@@ -491,12 +692,12 @@ class PerformanceTest(DhtFeatureTest):
             DhtNetwork.log("Getting 50 random hashes succesively.")
             for i in range(50):
                 with lock:
-                    done += 1
-                    start = time.time()
-                    bootstrap.front().get(InfoHash.getRandom(), getcb, donecb)
+                    for _ in range(1):
+                        run_get()
                     while done > 0:
                         lock.wait()
                         update_plot()
+                        plt.pause(.1)
                 update_plot()
             print("Took", np.sum(times), "mean", np.mean(times), "std", np.std(times), "min", np.min(times), "max", np.max(times))
 

python/tools/dht/virtual_network_builder.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 # Copyright (c) 2015-2016 Savoir-faire Linux Inc.
 # Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 #

python/tools/scanner.py

@@ -20,6 +20,7 @@ from pprint import pprint
 from math import cos, sin, pi
 from urllib import request
 import gzip
+import asyncio
 
 sys.path.append('..')
 from opendht import *
@@ -86,16 +87,15 @@ def gcb(v):
     return True
 
 r = DhtRunner()
-i = Identity()
-i.generate(bits = 1024)
-
-r.run(i, port=4112)
+r.run(port=4112)
 r.bootstrap("bootstrap.ring.cx", "4222")
 
 all_lines = []
 
 plt.pause(2)
 
+loop = asyncio.get_event_loop()
+
 def step(cur_h, cur_depth):
     global done, all_nodes, all_lines
     done += 1
@@ -105,7 +105,7 @@ def step(cur_h, cur_depth):
     arc = ringx.add_patch(mpatches.Wedge([0.,0,], 1., a*180/pi, b*180/pi, fill=True, color="blue", alpha=0.5))
     lines = ringx.plot([0, cos(a)], [0, sin(a)], 'k-', lw=1.2)
     all_lines.extend(lines)
-    r.get(cur_h, gcb, lambda d, nodes: nextstep(cur_h, cur_depth, d, nodes, arc=arc, lines=lines))
+    r.get(cur_h, gcb, lambda d, nodes: loop.call_soon_threadsafe(nextstep, cur_h, cur_depth, d, nodes, arc, lines))
 
 def nextstep(cur_h, cur_depth, ok, nodes, arc=None, lines=[]):
     global done, all_nodes
@@ -118,7 +118,7 @@ def nextstep(cur_h, cur_depth, ok, nodes, arc=None, lines=[]):
         snodes = NodeSet()
         snodes.extend(nodes)
         all_nodes.extend(nodes)
-        depth = min(6, InfoHash.commonBits(snodes.first(), snodes.last())+4)
+        depth = min(8, InfoHash.commonBits(snodes.first(), snodes.last())+6)
         if cur_depth < depth:
             for b in range(cur_depth, depth):
                 new_h = InfoHash(cur_h.toString());
@@ -164,6 +164,9 @@ not_found = []
 infos = [ringx.text(1.2, -0.8, ""),
          ringx.text(1.2, -0.9, "")]
 
+def num_nodes(node_set):
+    return sorted([x for x in node_set.items()], key=lambda ip: ip[1][1])
+
 def generate_set():
     node_ipv4 = {}
     node_ipv6 = {}
@@ -174,13 +177,13 @@ def generate_set():
             if addr in node_ipv6:
                 node_ipv6[addr][1] += 1
             else:
-                node_ipv6[addr] = [n, 1]
+                node_ipv6[addr] = [n, 1, gi6.record_by_name_v6(addr)]
         else:
             if addr in node_ipv4:
                 node_ipv4[addr][1] += 1
             else:
-                node_ipv4[addr] = [n, 1]
-    return node_ipv4, node_ipv6
+                node_ipv4[addr] = [n, 1, gi.record_by_name(addr)]
+    return num_nodes(node_ipv4), num_nodes(node_ipv6)
 
 def update_plot():
     global done, m, collection, not_found, points
@@ -195,10 +198,10 @@ def update_plot():
     not_found.clear()
     ip4s, ip6s = generate_set()
     ares = []
-    for addr, n in ip4s.items():
-        ares.append((addr, n[0].getNode(), gi.record_by_name(addr)))
-    for addr, n in ip6s.items():
-        ares.append((addr, n[0].getNode(), gi6.record_by_name_v6(addr)))
+    for addr, n in ip4s:
+        ares.append((addr, n[0].getNode(), n[2]))
+    for addr, n in ip6s:
+        ares.append((addr, n[0].getNode(), n[2]))
     for r in ares:
         res = r[2]
         n = r[1]
@@ -239,6 +242,8 @@ def d(arg):
 
 while run:
     while run and done > 0:
+        loop.stop()
+        loop.run_forever()
         update_plot()
         plt.draw()
         plt.pause(.5)
@@ -257,12 +262,12 @@ while run:
         print(n)
     print('')
     print(len(node_ip4s), " different IPv4s :")
-    for ip in node_ip4s.items():
-        print(ip[0] + " : " + str(ip[1][1]) + " nodes")
+    for ip in node_ip4s:
+        print(ip[0], ":", str(ip[1][1]), "nodes",  ("(" + ip[1][2]['city'] + ")") if ip[1][2] and ip[1][2]['city'] else "")
     print('')
     print(len(node_ip6s), " different IPv6s :")
-    for ip in node_ip6s.items():
-        print(ip[0] + " : " + str(ip[1][1]) + " nodes")
+    for ip in node_ip6s:
+        print(ip[0], ":", str(ip[1][1]), "nodes",  ("(" + ip[1][2]['city'] + ")") if ip[1][2] and ip[1][2]['city'] else "")
 
     while run and done == 0:
         plt.pause(.5)

src/Makefile.am

@@ -1,13 +1,20 @@
+SUBDIRS = argon2
+
 lib_LTLIBRARIES = libopendht.la
 
 AM_CPPFLAGS = -I../include/opendht
-libopendht_la_CXXFLAGS = @CXXFLAGS@
-libopendht_la_LDFLAGS = @LDFLAGS@ @GNUTLS_LIBS@ @nettle_LIBS@
+libopendht_la_LDFLAGS = @LDFLAGS@ @GnuTLS_LIBS@ @Nettle_LIBS@
+libopendht_la_LIBADD = ./argon2/libargon2.la
 
 libopendht_la_SOURCES = \
         dht.cpp \
+        node_cache.cpp \
+        callbacks.cpp \
+        routing_table.cpp \
+        network_engine.cpp \
         utils.cpp \
         infohash.cpp \
+        node.cpp \
         value.cpp \
         crypto.cpp \
         securedht.cpp \
@@ -21,11 +28,18 @@ endif
 nobase_include_HEADERS = \
         ../include/opendht.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/scheduler.h \
         ../include/opendht/utils.h \
         ../include/opendht/infohash.h \
+        ../include/opendht/node.h \
         ../include/opendht/value.h \
         ../include/opendht/crypto.h \
         ../include/opendht/securedht.h \
         ../include/opendht/dhtrunner.h \
         ../include/opendht/default_types.h \
+        ../include/opendht/log.h \
         ../include/opendht/rng.h

src/argon2/LICENSE

@@ -0,0 +1,31 @@
+     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER. 
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+    the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+    moral rights retained by the original author(s) and/or performer(s);
+    publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+    rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+    rights protecting the extraction, dissemination, use and reuse of data in a Work;
+    database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+    other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+    No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+    Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+    Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+    Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+

src/argon2/Makefile.am

@@ -0,0 +1,13 @@
+noinst_LTLIBRARIES = libargon2.la
+
+libargon2_la_CFLAGS = -std=c89 -fPIC -pthread -O3 -Wall
+
+libargon2_la_SOURCES = \
+        argon2.c \
+        core.c \
+        blake2/blake2b.c \
+        thread.c \
+        encoding.c \
+        ref.c
+
+EXTRA_libargon2_la_SOURCES = opt.c

src/argon2/argon2.c

@@ -0,0 +1,396 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "argon2.h"
+#include "encoding.h"
+#include "core.h"
+
+
+int argon2_ctx(argon2_context *context, argon2_type type) {
+    /* 1. Validate all inputs */
+    int result = validate_inputs(context);
+    uint32_t memory_blocks, segment_length;
+    argon2_instance_t instance;
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    if (Argon2_d != type && Argon2_i != type) {
+        return ARGON2_INCORRECT_TYPE;
+    }
+
+    /* 2. Align memory size */
+    /* Minimum memory_blocks = 8L blocks, where L is the number of lanes */
+    memory_blocks = context->m_cost;
+
+    if (memory_blocks < 2 * ARGON2_SYNC_POINTS * context->lanes) {
+        memory_blocks = 2 * ARGON2_SYNC_POINTS * context->lanes;
+    }
+
+    segment_length = memory_blocks / (context->lanes * ARGON2_SYNC_POINTS);
+    /* Ensure that all segments have equal length */
+    memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
+
+    instance.version = context->version;
+    instance.memory = NULL;
+    instance.passes = context->t_cost;
+    instance.memory_blocks = memory_blocks;
+    instance.segment_length = segment_length;
+    instance.lane_length = segment_length * ARGON2_SYNC_POINTS;
+    instance.lanes = context->lanes;
+    instance.threads = context->threads;
+    instance.type = type;
+
+    /* 3. Initialization: Hashing inputs, allocating memory, filling first
+     * blocks
+     */
+    result = initialize(&instance, context);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    /* 4. Filling memory */
+    result = fill_memory_blocks(&instance);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+    /* 5. Finalization */
+    finalize(context, &instance);
+
+    return ARGON2_OK;
+}
+
+int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
+                const uint32_t parallelism, const void *pwd,
+                const size_t pwdlen, const void *salt, const size_t saltlen,
+                void *hash, const size_t hashlen, char *encoded,
+                const size_t encodedlen, argon2_type type, 
+                const uint32_t version){
+
+    argon2_context context;
+    int result;
+    uint8_t *out;
+
+    /* Detect and reject overflowing sizes */
+    /* TODO: This should probably be fixed in the function signature */
+    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
+        return ARGON2_PWD_TOO_LONG;
+    }
+
+    if (hashlen > ARGON2_MAX_OUTLEN) {
+        return ARGON2_OUTPUT_TOO_LONG;
+    }
+
+    if (saltlen > ARGON2_MAX_SALT_LENGTH) {
+        return ARGON2_SALT_TOO_LONG;
+    }
+
+    out = malloc(hashlen);
+    if (!out) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    context.out = (uint8_t *)out;
+    context.outlen = (uint32_t)hashlen;
+    context.pwd = CONST_CAST(uint8_t *)pwd;
+    context.pwdlen = (uint32_t)pwdlen;
+    context.salt = CONST_CAST(uint8_t *)salt;
+    context.saltlen = (uint32_t)saltlen;
+    context.secret = NULL;
+    context.secretlen = 0;
+    context.ad = NULL;
+    context.adlen = 0;
+    context.t_cost = t_cost;
+    context.m_cost = m_cost;
+    context.lanes = parallelism;
+    context.threads = parallelism;
+    context.allocate_cbk = NULL;
+    context.free_cbk = NULL;
+    context.flags = ARGON2_DEFAULT_FLAGS;
+    context.version = version;
+
+    result = argon2_ctx(&context, type);
+
+    if (result != ARGON2_OK) {
+        secure_wipe_memory(out, hashlen);
+        free(out);
+        return result;
+    }
+
+    /* if raw hash requested, write it */
+    if (hash) {
+        memcpy(hash, out, hashlen);
+    }
+
+    /* if encoding requested, write it */
+    if (encoded && encodedlen) {
+        if (encode_string(encoded, encodedlen, &context, type) != ARGON2_OK) {
+            secure_wipe_memory(out, hashlen); /* wipe buffers if error */
+            secure_wipe_memory(encoded, encodedlen);
+            free(out);
+            return ARGON2_ENCODING_FAIL;
+        }
+    }
+    secure_wipe_memory(out, hashlen);
+    free(out);
+
+    return ARGON2_OK;
+}
+
+int argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                         const uint32_t parallelism, const void *pwd,
+                         const size_t pwdlen, const void *salt,
+                         const size_t saltlen, const size_t hashlen,
+                         char *encoded, const size_t encodedlen) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_i,
+                       ARGON2_VERSION_NUMBER);
+}
+
+int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                     const uint32_t parallelism, const void *pwd,
+                     const size_t pwdlen, const void *salt,
+                     const size_t saltlen, void *hash, const size_t hashlen) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_i, ARGON2_VERSION_NUMBER);
+}
+
+int argon2d_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                         const uint32_t parallelism, const void *pwd,
+                         const size_t pwdlen, const void *salt,
+                         const size_t saltlen, const size_t hashlen,
+                         char *encoded, const size_t encodedlen) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_d,
+                       ARGON2_VERSION_NUMBER);
+}
+
+int argon2d_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                     const uint32_t parallelism, const void *pwd,
+                     const size_t pwdlen, const void *salt,
+                     const size_t saltlen, void *hash, const size_t hashlen) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_d, ARGON2_VERSION_NUMBER);
+}
+
+static int argon2_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
+    size_t i;
+    uint8_t d = 0U;
+
+    for (i = 0U; i < len; i++) {
+        d |= b1[i] ^ b2[i];
+    }
+    return (int)((1 & ((d - 1) >> 8)) - 1);
+}
+
+int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
+                  argon2_type type) {
+
+    argon2_context ctx;
+    uint8_t *out;
+    int ret;
+    int decode_result;
+    uint32_t encoded_len;
+
+    if(encoded == NULL) {
+        return ARGON2_DECODING_FAIL;
+    }
+
+    /* max values, to be updated in decode_string */
+    encoded_len = strlen(encoded);
+    ctx.adlen = encoded_len;
+    ctx.saltlen = encoded_len;
+    ctx.outlen = encoded_len;
+    ctx.allocate_cbk = NULL;
+    ctx.free_cbk = NULL;
+    ctx.secret = NULL;
+    ctx.secretlen = 0;
+    ctx.ad = malloc(ctx.adlen);
+    ctx.salt = malloc(ctx.saltlen);
+    ctx.out = malloc(ctx.outlen);
+    if (!ctx.out || !ctx.salt || !ctx.ad) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+    out = malloc(ctx.outlen);
+    if (!out) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+    decode_result = decode_string(&ctx, encoded, type);
+    if (decode_result != ARGON2_OK) {
+        free(ctx.ad);
+        free(ctx.salt);
+        free(ctx.out);
+        free(out);
+        return decode_result;
+    }
+
+    ret = argon2_hash(ctx.t_cost, ctx.m_cost, ctx.threads, pwd, pwdlen,
+                      ctx.salt, ctx.saltlen, out, ctx.outlen, NULL, 0, type,
+                      ctx.version);
+
+    free(ctx.ad);
+    free(ctx.salt);
+
+    if (ret == ARGON2_OK && argon2_compare(out, ctx.out, ctx.outlen)) {
+        ret = ARGON2_VERIFY_MISMATCH;
+    }
+    free(out);
+    free(ctx.out);
+
+    return ret;
+}
+
+int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_i);
+}
+
+int argon2d_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_d);
+}
+
+int argon2d_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_d);
+}
+
+int argon2i_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_i);
+}
+
+int argon2_verify_ctx(argon2_context *context, const char *hash,
+                      argon2_type type) {
+    int result;
+    if (0 == context->outlen || NULL == hash) {
+        return ARGON2_OUT_PTR_MISMATCH;
+    }
+
+    result = argon2_ctx(context, type);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    return 0 == memcmp(hash, context->out, context->outlen);
+}
+
+int argon2d_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_d);
+}
+
+int argon2i_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_i);
+}
+
+const char *argon2_error_message(int error_code) {
+    switch (error_code) {
+    case ARGON2_OK:
+        return "OK";
+    case ARGON2_OUTPUT_PTR_NULL:
+        return "Output pointer is NULL";
+    case ARGON2_OUTPUT_TOO_SHORT:
+        return "Output is too short";
+    case ARGON2_OUTPUT_TOO_LONG:
+        return "Output is too long";
+    case ARGON2_PWD_TOO_SHORT:
+        return "Password is too short";
+    case ARGON2_PWD_TOO_LONG:
+        return "Password is too long";
+    case ARGON2_SALT_TOO_SHORT:
+        return "Salt is too short";
+    case ARGON2_SALT_TOO_LONG:
+        return "Salt is too long";
+    case ARGON2_AD_TOO_SHORT:
+        return "Associated data is too short";
+    case ARGON2_AD_TOO_LONG:
+        return "Associated data is too long";
+    case ARGON2_SECRET_TOO_SHORT:
+        return "Secret is too short";
+    case ARGON2_SECRET_TOO_LONG:
+        return "Secret is too long";
+    case ARGON2_TIME_TOO_SMALL:
+        return "Time cost is too small";
+    case ARGON2_TIME_TOO_LARGE:
+        return "Time cost is too large";
+    case ARGON2_MEMORY_TOO_LITTLE:
+        return "Memory cost is too small";
+    case ARGON2_MEMORY_TOO_MUCH:
+        return "Memory cost is too large";
+    case ARGON2_LANES_TOO_FEW:
+        return "Too few lanes";
+    case ARGON2_LANES_TOO_MANY:
+        return "Too many lanes";
+    case ARGON2_PWD_PTR_MISMATCH:
+        return "Password pointer is NULL, but password length is not 0";
+    case ARGON2_SALT_PTR_MISMATCH:
+        return "Salt pointer is NULL, but salt length is not 0";
+    case ARGON2_SECRET_PTR_MISMATCH:
+        return "Secret pointer is NULL, but secret length is not 0";
+    case ARGON2_AD_PTR_MISMATCH:
+        return "Associated data pointer is NULL, but ad length is not 0";
+    case ARGON2_MEMORY_ALLOCATION_ERROR:
+        return "Memory allocation error";
+    case ARGON2_FREE_MEMORY_CBK_NULL:
+        return "The free memory callback is NULL";
+    case ARGON2_ALLOCATE_MEMORY_CBK_NULL:
+        return "The allocate memory callback is NULL";
+    case ARGON2_INCORRECT_PARAMETER:
+        return "Argon2_Context context is NULL";
+    case ARGON2_INCORRECT_TYPE:
+        return "There is no such version of Argon2";
+    case ARGON2_OUT_PTR_MISMATCH:
+        return "Output pointer mismatch";
+    case ARGON2_THREADS_TOO_FEW:
+        return "Not enough threads";
+    case ARGON2_THREADS_TOO_MANY:
+        return "Too many threads";
+    case ARGON2_MISSING_ARGS:
+        return "Missing arguments";
+    case ARGON2_ENCODING_FAIL:
+        return "Encoding failed";
+    case ARGON2_DECODING_FAIL:
+        return "Decoding failed";
+    case ARGON2_THREAD_FAIL:
+        return "Threading failure";
+    case ARGON2_DECODING_LENGTH_FAIL:
+        return "Some of encoded parameters are too long or too short";
+    case ARGON2_VERIFY_MISMATCH:
+        return "The password does not match the supplied hash";
+    default:
+        return "Unknown error code";
+    }
+}
+
+size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost, uint32_t parallelism,
+                         uint32_t saltlen, uint32_t hashlen) {
+    return strlen("$argon2x$v=$m=,t=,p=$$") + numlen(t_cost) + numlen(m_cost)
+        + numlen(parallelism) + b64len(saltlen) + b64len(hashlen)
+        + numlen(ARGON2_VERSION_NUMBER);
+}

src/argon2/argon2.h

@@ -0,0 +1,372 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication
+ * along with this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#ifndef ARGON2_H
+#define ARGON2_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <limits.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Symbols visibility control */
+#ifdef A2_VISCTL
+#define ARGON2_PUBLIC __attribute__((visibility("default")))
+#else
+#define ARGON2_PUBLIC
+#endif
+
+/*
+ * Argon2 input parameter restrictions
+ */
+
+/* Minimum and maximum number of lanes (degree of parallelism) */
+#define ARGON2_MIN_LANES UINT32_C(1)
+#define ARGON2_MAX_LANES UINT32_C(0xFFFFFF)
+
+/* Minimum and maximum number of threads */
+#define ARGON2_MIN_THREADS UINT32_C(1)
+#define ARGON2_MAX_THREADS UINT32_C(0xFFFFFF)
+
+/* Number of synchronization points between lanes per pass */
+#define ARGON2_SYNC_POINTS UINT32_C(4)
+
+/* Minimum and maximum digest size in bytes */
+#define ARGON2_MIN_OUTLEN UINT32_C(4)
+#define ARGON2_MAX_OUTLEN UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum number of memory blocks (each of BLOCK_SIZE bytes) */
+#define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */
+
+#define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b))
+/* Max memory size is addressing-space/2, topping at 2^32 blocks (4 TB) */
+#define ARGON2_MAX_MEMORY_BITS                                                 \
+    ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1))
+#define ARGON2_MAX_MEMORY                                                      \
+    ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS)
+
+/* Minimum and maximum number of passes */
+#define ARGON2_MIN_TIME UINT32_C(1)
+#define ARGON2_MAX_TIME UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum password length in bytes */
+#define ARGON2_MIN_PWD_LENGTH UINT32_C(0)
+#define ARGON2_MAX_PWD_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum associated data length in bytes */
+#define ARGON2_MIN_AD_LENGTH UINT32_C(0)
+#define ARGON2_MAX_AD_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum salt length in bytes */
+#define ARGON2_MIN_SALT_LENGTH UINT32_C(8)
+#define ARGON2_MAX_SALT_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum key length in bytes */
+#define ARGON2_MIN_SECRET UINT32_C(0)
+#define ARGON2_MAX_SECRET UINT32_C(0xFFFFFFFF)
+
+#define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0)
+#define ARGON2_FLAG_CLEAR_SECRET (UINT32_C(1) << 1)
+#define ARGON2_FLAG_CLEAR_MEMORY (UINT32_C(1) << 2)
+#define ARGON2_DEFAULT_FLAGS (ARGON2_FLAG_CLEAR_MEMORY)
+
+/* Error codes */
+typedef enum Argon2_ErrorCodes {
+    ARGON2_OK = 0,
+
+    ARGON2_OUTPUT_PTR_NULL = -1,
+
+    ARGON2_OUTPUT_TOO_SHORT = -2,
+    ARGON2_OUTPUT_TOO_LONG = -3,
+
+    ARGON2_PWD_TOO_SHORT = -4,
+    ARGON2_PWD_TOO_LONG = -5,
+
+    ARGON2_SALT_TOO_SHORT = -6,
+    ARGON2_SALT_TOO_LONG = -7,
+
+    ARGON2_AD_TOO_SHORT = -8,
+    ARGON2_AD_TOO_LONG = -9,
+
+    ARGON2_SECRET_TOO_SHORT = -10,
+    ARGON2_SECRET_TOO_LONG = -11,
+
+    ARGON2_TIME_TOO_SMALL = -12,
+    ARGON2_TIME_TOO_LARGE = -13,
+
+    ARGON2_MEMORY_TOO_LITTLE = -14,
+    ARGON2_MEMORY_TOO_MUCH = -15,
+
+    ARGON2_LANES_TOO_FEW = -16,
+    ARGON2_LANES_TOO_MANY = -17,
+
+    ARGON2_PWD_PTR_MISMATCH = -18,    /* NULL ptr with non-zero length */
+    ARGON2_SALT_PTR_MISMATCH = -19,   /* NULL ptr with non-zero length */
+    ARGON2_SECRET_PTR_MISMATCH = -20, /* NULL ptr with non-zero length */
+    ARGON2_AD_PTR_MISMATCH = -21,     /* NULL ptr with non-zero length */
+
+    ARGON2_MEMORY_ALLOCATION_ERROR = -22,
+
+    ARGON2_FREE_MEMORY_CBK_NULL = -23,
+    ARGON2_ALLOCATE_MEMORY_CBK_NULL = -24,
+
+    ARGON2_INCORRECT_PARAMETER = -25,
+    ARGON2_INCORRECT_TYPE = -26,
+
+    ARGON2_OUT_PTR_MISMATCH = -27,
+
+    ARGON2_THREADS_TOO_FEW = -28,
+    ARGON2_THREADS_TOO_MANY = -29,
+
+    ARGON2_MISSING_ARGS = -30,
+
+    ARGON2_ENCODING_FAIL = -31,
+
+    ARGON2_DECODING_FAIL = -32,
+
+    ARGON2_THREAD_FAIL = -33,
+
+    ARGON2_DECODING_LENGTH_FAIL = -34,
+
+    ARGON2_VERIFY_MISMATCH = -35
+} argon2_error_codes;
+
+/* Memory allocator types --- for external allocation */
+typedef int (*allocate_fptr)(uint8_t **memory, size_t bytes_to_allocate);
+typedef void (*deallocate_fptr)(uint8_t *memory, size_t bytes_to_allocate);
+
+/* Argon2 external data structures */
+
+/*
+ *****
+ * Context: structure to hold Argon2 inputs:
+ *  output array and its length,
+ *  password and its length,
+ *  salt and its length,
+ *  secret and its length,
+ *  associated data and its length,
+ *  number of passes, amount of used memory (in KBytes, can be rounded up a bit)
+ *  number of parallel threads that will be run.
+ * All the parameters above affect the output hash value.
+ * Additionally, two function pointers can be provided to allocate and
+ * deallocate the memory (if NULL, memory will be allocated internally).
+ * Also, three flags indicate whether to erase password, secret as soon as they
+ * are pre-hashed (and thus not needed anymore), and the entire memory
+ *****
+ * Simplest situation: you have output array out[8], password is stored in
+ * pwd[32], salt is stored in salt[16], you do not have keys nor associated
+ * data. You need to spend 1 GB of RAM and you run 5 passes of Argon2d with
+ * 4 parallel lanes.
+ * You want to erase the password, but you're OK with last pass not being
+ * erased. You want to use the default memory allocator.
+ * Then you initialize:
+ Argon2_Context(out,8,pwd,32,salt,16,NULL,0,NULL,0,5,1<<20,4,4,NULL,NULL,true,false,false,false)
+ */
+typedef struct Argon2_Context {
+    uint8_t *out;    /* output array */
+    uint32_t outlen; /* digest length */
+
+    uint8_t *pwd;    /* password array */
+    uint32_t pwdlen; /* password length */
+
+    uint8_t *salt;    /* salt array */
+    uint32_t saltlen; /* salt length */
+
+    uint8_t *secret;    /* key array */
+    uint32_t secretlen; /* key length */
+
+    uint8_t *ad;    /* associated data array */
+    uint32_t adlen; /* associated data length */
+
+    uint32_t t_cost;  /* number of passes */
+    uint32_t m_cost;  /* amount of memory requested (KB) */
+    uint32_t lanes;   /* number of lanes */
+    uint32_t threads; /* maximum number of threads */
+
+    uint32_t version; /* version number */
+
+    allocate_fptr allocate_cbk; /* pointer to memory allocator */
+    deallocate_fptr free_cbk;   /* pointer to memory deallocator */
+
+    uint32_t flags; /* array of bool options */
+} argon2_context;
+
+/* Argon2 primitive type */
+typedef enum Argon2_type { Argon2_d = 0, Argon2_i = 1 } argon2_type;
+
+/* Version of the algorithm */
+typedef enum Argon2_version {
+    ARGON2_VERSION_10 = 0x10,
+    ARGON2_VERSION_13 = 0x13,
+    ARGON2_VERSION_NUMBER = ARGON2_VERSION_13
+} argon2_version;
+
+/*
+ * Function that performs memory-hard hashing with certain degree of parallelism
+ * @param  context  Pointer to the Argon2 internal structure
+ * @return Error code if smth is wrong, ARGON2_OK otherwise
+ */
+ARGON2_PUBLIC int argon2_ctx(argon2_context *context, argon2_type type);
+
+/**
+ * Hashes a password with Argon2i, producing an encoded hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hashlen Desired length of the hash in bytes
+ * @param encoded Buffer where to write the encoded hash
+ * @param encodedlen Size of the buffer (thus max size of the encoded hash)
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_hash_encoded(const uint32_t t_cost,
+                                       const uint32_t m_cost,
+                                       const uint32_t parallelism,
+                                       const void *pwd, const size_t pwdlen,
+                                       const void *salt, const size_t saltlen,
+                                       const size_t hashlen, char *encoded,
+                                       const size_t encodedlen);
+
+/**
+ * Hashes a password with Argon2i, producing a raw hash by allocating memory at
+ * @hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hash Buffer where to write the raw hash - updated by the function
+ * @param hashlen Desired length of the hash in bytes
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                                   const uint32_t parallelism, const void *pwd,
+                                   const size_t pwdlen, const void *salt,
+                                   const size_t saltlen, void *hash,
+                                   const size_t hashlen);
+
+ARGON2_PUBLIC int argon2d_hash_encoded(const uint32_t t_cost,
+                                       const uint32_t m_cost,
+                                       const uint32_t parallelism,
+                                       const void *pwd, const size_t pwdlen,
+                                       const void *salt, const size_t saltlen,
+                                       const size_t hashlen, char *encoded,
+                                       const size_t encodedlen);
+
+ARGON2_PUBLIC int argon2d_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                                   const uint32_t parallelism, const void *pwd,
+                                   const size_t pwdlen, const void *salt,
+                                   const size_t saltlen, void *hash,
+                                   const size_t hashlen);
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
+                              const uint32_t parallelism, const void *pwd,
+                              const size_t pwdlen, const void *salt,
+                              const size_t saltlen, void *hash,
+                              const size_t hashlen, char *encoded,
+                              const size_t encodedlen, argon2_type type,
+                              const uint32_t version);
+
+/**
+ * Verifies a password against an encoded string
+ * Encoded string is restricted as in validate_inputs()
+ * @param encoded String encoding parameters, salt, hash
+ * @param pwd Pointer to password
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_verify(const char *encoded, const void *pwd,
+                                 const size_t pwdlen);
+
+ARGON2_PUBLIC int argon2d_verify(const char *encoded, const void *pwd,
+                                 const size_t pwdlen);
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_verify(const char *encoded, const void *pwd,
+                                const size_t pwdlen, argon2_type type);
+
+/**
+ * Argon2d: Version of Argon2 that picks memory blocks depending
+ * on the password and salt. Only for side-channel-free
+ * environment!!
+ *****
+ * @param  context  Pointer to current Argon2 context
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2d_ctx(argon2_context *context);
+
+/**
+ * Argon2i: Version of Argon2 that picks memory blocks
+ * independent on the password and salt. Good for side-channels,
+ * but worse w.r.t. tradeoff attacks if only one pass is used.
+ *****
+ * @param  context  Pointer to current Argon2 context
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2i_ctx(argon2_context *context);
+
+/**
+ * Verify if a given password is correct for Argon2d hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2d_verify_ctx(argon2_context *context, const char *hash);
+
+/**
+ * Verify if a given password is correct for Argon2i hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2i_verify_ctx(argon2_context *context, const char *hash);
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_verify_ctx(argon2_context *context, const char *hash,
+                                    argon2_type type);
+
+/**
+ * Get the associated error message for given error code
+ * @return  The error message associated with the given error code
+ */
+ARGON2_PUBLIC const char *argon2_error_message(int error_code);
+
+/**
+ * Returns the encoded hash length for the given input parameters
+ * @param t_cost  Number of iterations
+ * @param m_cost  Memory usage in kibibytes
+ * @param parallelism  Number of threads; used to compute lanes
+ * @param saltlen  Salt size in bytes
+ * @param hashlen  Hash size in bytes
+ * @return  The encoded hash length in bytes
+ */
+ARGON2_PUBLIC size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost,
+                                       uint32_t parallelism, uint32_t saltlen,
+                                       uint32_t hashlen);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

src/argon2/blake2/blake2-impl.h

@@ -0,0 +1,143 @@
+#ifndef PORTABLE_BLAKE2_IMPL_H
+#define PORTABLE_BLAKE2_IMPL_H
+
+#include <stdint.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+#define BLAKE2_INLINE __inline
+#elif defined(__GNUC__) || defined(__clang__)
+#define BLAKE2_INLINE __inline__
+#else
+#define BLAKE2_INLINE
+#endif
+
+/* Argon2 Team - Begin Code */
+/*
+   Not an exhaustive list, but should cover the majority of modern platforms
+   Additionally, the code will always be correct---this is only a performance
+   tweak.
+*/
+#if (defined(__BYTE_ORDER__) &&                                                \
+     (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) ||                           \
+    defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \
+    defined(__AARCH64EL__) || defined(__amd64__) || defined(__i386__) ||       \
+    defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) ||                \
+    defined(_M_ARM)
+#define NATIVE_LITTLE_ENDIAN
+#endif
+/* Argon2 Team - End Code */
+
+static BLAKE2_INLINE uint32_t load32(const void *src) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    uint32_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    const uint8_t *p = (const uint8_t *)src;
+    uint32_t w = *p++;
+    w |= (uint32_t)(*p++) << 8;
+    w |= (uint32_t)(*p++) << 16;
+    w |= (uint32_t)(*p++) << 24;
+    return w;
+#endif
+}
+
+static BLAKE2_INLINE uint64_t load64(const void *src) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    uint64_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    const uint8_t *p = (const uint8_t *)src;
+    uint64_t w = *p++;
+    w |= (uint64_t)(*p++) << 8;
+    w |= (uint64_t)(*p++) << 16;
+    w |= (uint64_t)(*p++) << 24;
+    w |= (uint64_t)(*p++) << 32;
+    w |= (uint64_t)(*p++) << 40;
+    w |= (uint64_t)(*p++) << 48;
+    w |= (uint64_t)(*p++) << 56;
+    return w;
+#endif
+}
+
+static BLAKE2_INLINE void store32(void *dst, uint32_t w) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    memcpy(dst, &w, sizeof w);
+#else
+    uint8_t *p = (uint8_t *)dst;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+#endif
+}
+
+static BLAKE2_INLINE void store64(void *dst, uint64_t w) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    memcpy(dst, &w, sizeof w);
+#else
+    uint8_t *p = (uint8_t *)dst;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+#endif
+}
+
+static BLAKE2_INLINE uint64_t load48(const void *src) {
+    const uint8_t *p = (const uint8_t *)src;
+    uint64_t w = *p++;
+    w |= (uint64_t)(*p++) << 8;
+    w |= (uint64_t)(*p++) << 16;
+    w |= (uint64_t)(*p++) << 24;
+    w |= (uint64_t)(*p++) << 32;
+    w |= (uint64_t)(*p++) << 40;
+    return w;
+}
+
+static BLAKE2_INLINE void store48(void *dst, uint64_t w) {
+    uint8_t *p = (uint8_t *)dst;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+}
+
+static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c) {
+    return (w >> c) | (w << (32 - c));
+}
+
+static BLAKE2_INLINE uint64_t rotr64(const uint64_t w, const unsigned c) {
+    return (w >> c) | (w << (64 - c));
+}
+
+/* prevents compiler optimizing out memset() */
+static BLAKE2_INLINE void burn(void *v, size_t n) {
+    static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
+    memset_v(v, 0, n);
+}
+
+#endif

src/argon2/blake2/blake2.h

@@ -0,0 +1,74 @@
+#ifndef PORTABLE_BLAKE2_H
+#define PORTABLE_BLAKE2_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+enum blake2b_constant {
+    BLAKE2B_BLOCKBYTES = 128,
+    BLAKE2B_OUTBYTES = 64,
+    BLAKE2B_KEYBYTES = 64,
+    BLAKE2B_SALTBYTES = 16,
+    BLAKE2B_PERSONALBYTES = 16
+};
+
+#pragma pack(push, 1)
+typedef struct __blake2b_param {
+    uint8_t digest_length;                   /* 1 */
+    uint8_t key_length;                      /* 2 */
+    uint8_t fanout;                          /* 3 */
+    uint8_t depth;                           /* 4 */
+    uint32_t leaf_length;                    /* 8 */
+    uint64_t node_offset;                    /* 16 */
+    uint8_t node_depth;                      /* 17 */
+    uint8_t inner_length;                    /* 18 */
+    uint8_t reserved[14];                    /* 32 */
+    uint8_t salt[BLAKE2B_SALTBYTES];         /* 48 */
+    uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
+} blake2b_param;
+#pragma pack(pop)
+
+typedef struct __blake2b_state {
+    uint64_t h[8];
+    uint64_t t[2];
+    uint64_t f[2];
+    uint8_t buf[BLAKE2B_BLOCKBYTES];
+    unsigned buflen;
+    unsigned outlen;
+    uint8_t last_node;
+} blake2b_state;
+
+/* Ensure param structs have not been wrongly padded */
+/* Poor man's static_assert */
+enum {
+    blake2_size_check_0 = 1 / !!(CHAR_BIT == 8),
+    blake2_size_check_2 =
+        1 / !!(sizeof(blake2b_param) == sizeof(uint64_t) * CHAR_BIT)
+};
+
+/* Streaming API */
+int blake2b_init(blake2b_state *S, size_t outlen);
+int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
+                     size_t keylen);
+int blake2b_init_param(blake2b_state *S, const blake2b_param *P);
+int blake2b_update(blake2b_state *S, const void *in, size_t inlen);
+int blake2b_final(blake2b_state *S, void *out, size_t outlen);
+
+/* Simple API */
+int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
+            const void *key, size_t keylen);
+
+/* Argon2 Team - Begin Code */
+int blake2b_long(void *out, size_t outlen, const void *in, size_t inlen);
+/* Argon2 Team - End Code */
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

src/argon2/blake2/blake2b.c

@@ -0,0 +1,372 @@
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "blake2.h"
+#include "blake2-impl.h"
+
+static const uint64_t blake2b_IV[8] = {
+    UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
+    UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
+    UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
+    UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179)};
+
+static const unsigned int blake2b_sigma[12][16] = {
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
+    {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
+    {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
+    {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
+    {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
+    {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
+    {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
+    {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
+    {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
+};
+
+static BLAKE2_INLINE void blake2b_set_lastnode(blake2b_state *S) {
+    S->f[1] = (uint64_t)-1;
+}
+
+static BLAKE2_INLINE void blake2b_set_lastblock(blake2b_state *S) {
+    if (S->last_node) {
+        blake2b_set_lastnode(S);
+    }
+    S->f[0] = (uint64_t)-1;
+}
+
+static BLAKE2_INLINE void blake2b_increment_counter(blake2b_state *S,
+                                                    uint64_t inc) {
+    S->t[0] += inc;
+    S->t[1] += (S->t[0] < inc);
+}
+
+static BLAKE2_INLINE void blake2b_invalidate_state(blake2b_state *S) {
+    burn(S, sizeof(*S));      /* wipe */
+    blake2b_set_lastblock(S); /* invalidate for further use */
+}
+
+static BLAKE2_INLINE void blake2b_init0(blake2b_state *S) {
+    memset(S, 0, sizeof(*S));
+    memcpy(S->h, blake2b_IV, sizeof(S->h));
+}
+
+int blake2b_init_param(blake2b_state *S, const blake2b_param *P) {
+    const unsigned char *p = (const unsigned char *)P;
+    unsigned int i;
+
+    if (NULL == P || NULL == S) {
+        return -1;
+    }
+
+    blake2b_init0(S);
+    /* IV XOR Parameter Block */
+    for (i = 0; i < 8; ++i) {
+        S->h[i] ^= load64(&p[i * sizeof(S->h[i])]);
+    }
+    S->outlen = P->digest_length;
+    return 0;
+}
+
+/* Sequential blake2b initialization */
+int blake2b_init(blake2b_state *S, size_t outlen) {
+    blake2b_param P;
+
+    if (S == NULL) {
+        return -1;
+    }
+
+    if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    /* Setup Parameter Block for unkeyed BLAKE2 */
+    P.digest_length = (uint8_t)outlen;
+    P.key_length = 0;
+    P.fanout = 1;
+    P.depth = 1;
+    P.leaf_length = 0;
+    P.node_offset = 0;
+    P.node_depth = 0;
+    P.inner_length = 0;
+    memset(P.reserved, 0, sizeof(P.reserved));
+    memset(P.salt, 0, sizeof(P.salt));
+    memset(P.personal, 0, sizeof(P.personal));
+
+    return blake2b_init_param(S, &P);
+}
+
+int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
+                     size_t keylen) {
+    blake2b_param P;
+
+    if (S == NULL) {
+        return -1;
+    }
+
+    if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    if ((key == 0) || (keylen == 0) || (keylen > BLAKE2B_KEYBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    /* Setup Parameter Block for keyed BLAKE2 */
+    P.digest_length = (uint8_t)outlen;
+    P.key_length = (uint8_t)keylen;
+    P.fanout = 1;
+    P.depth = 1;
+    P.leaf_length = 0;
+    P.node_offset = 0;
+    P.node_depth = 0;
+    P.inner_length = 0;
+    memset(P.reserved, 0, sizeof(P.reserved));
+    memset(P.salt, 0, sizeof(P.salt));
+    memset(P.personal, 0, sizeof(P.personal));
+
+    if (blake2b_init_param(S, &P) < 0) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    {
+        uint8_t block[BLAKE2B_BLOCKBYTES];
+        memset(block, 0, BLAKE2B_BLOCKBYTES);
+        memcpy(block, key, keylen);
+        blake2b_update(S, block, BLAKE2B_BLOCKBYTES);
+        burn(block, BLAKE2B_BLOCKBYTES); /* Burn the key from stack */
+    }
+    return 0;
+}
+
+static void blake2b_compress(blake2b_state *S, const uint8_t *block) {
+    uint64_t m[16];
+    uint64_t v[16];
+    unsigned int i, r;
+
+    for (i = 0; i < 16; ++i) {
+        m[i] = load64(block + i * sizeof(m[i]));
+    }
+
+    for (i = 0; i < 8; ++i) {
+        v[i] = S->h[i];
+    }
+
+    v[8] = blake2b_IV[0];
+    v[9] = blake2b_IV[1];
+    v[10] = blake2b_IV[2];
+    v[11] = blake2b_IV[3];
+    v[12] = blake2b_IV[4] ^ S->t[0];
+    v[13] = blake2b_IV[5] ^ S->t[1];
+    v[14] = blake2b_IV[6] ^ S->f[0];
+    v[15] = blake2b_IV[7] ^ S->f[1];
+
+#define G(r, i, a, b, c, d)                                                    \
+    do {                                                                       \
+        a = a + b + m[blake2b_sigma[r][2 * i + 0]];                            \
+        d = rotr64(d ^ a, 32);                                                 \
+        c = c + d;                                                             \
+        b = rotr64(b ^ c, 24);                                                 \
+        a = a + b + m[blake2b_sigma[r][2 * i + 1]];                            \
+        d = rotr64(d ^ a, 16);                                                 \
+        c = c + d;                                                             \
+        b = rotr64(b ^ c, 63);                                                 \
+    } while ((void)0, 0)
+
+#define ROUND(r)                                                               \
+    do {                                                                       \
+        G(r, 0, v[0], v[4], v[8], v[12]);                                      \
+        G(r, 1, v[1], v[5], v[9], v[13]);                                      \
+        G(r, 2, v[2], v[6], v[10], v[14]);                                     \
+        G(r, 3, v[3], v[7], v[11], v[15]);                                     \
+        G(r, 4, v[0], v[5], v[10], v[15]);                                     \
+        G(r, 5, v[1], v[6], v[11], v[12]);                                     \
+        G(r, 6, v[2], v[7], v[8], v[13]);                                      \
+        G(r, 7, v[3], v[4], v[9], v[14]);                                      \
+    } while ((void)0, 0)
+
+    for (r = 0; r < 12; ++r) {
+        ROUND(r);
+    }
+
+    for (i = 0; i < 8; ++i) {
+        S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
+    }
+
+#undef G
+#undef ROUND
+}
+
+int blake2b_update(blake2b_state *S, const void *in, size_t inlen) {
+    const uint8_t *pin = (const uint8_t *)in;
+
+    if (inlen == 0) {
+        return 0;
+    }
+
+    /* Sanity check */
+    if (S == NULL || in == NULL) {
+        return -1;
+    }
+
+    /* Is this a reused state? */
+    if (S->f[0] != 0) {
+        return -1;
+    }
+
+    if (S->buflen + inlen > BLAKE2B_BLOCKBYTES) {
+        /* Complete current block */
+        size_t left = S->buflen;
+        size_t fill = BLAKE2B_BLOCKBYTES - left;
+        memcpy(&S->buf[left], pin, fill);
+        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
+        blake2b_compress(S, S->buf);
+        S->buflen = 0;
+        inlen -= fill;
+        pin += fill;
+        /* Avoid buffer copies when possible */
+        while (inlen > BLAKE2B_BLOCKBYTES) {
+            blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
+            blake2b_compress(S, pin);
+            inlen -= BLAKE2B_BLOCKBYTES;
+            pin += BLAKE2B_BLOCKBYTES;
+        }
+    }
+    memcpy(&S->buf[S->buflen], pin, inlen);
+    S->buflen += (unsigned int)inlen;
+    return 0;
+}
+
+int blake2b_final(blake2b_state *S, void *out, size_t outlen) {
+    uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
+    unsigned int i;
+
+    /* Sanity checks */
+    if (S == NULL || out == NULL || outlen < S->outlen) {
+        return -1;
+    }
+
+    /* Is this a reused state? */
+    if (S->f[0] != 0) {
+        return -1;
+    }
+
+    blake2b_increment_counter(S, S->buflen);
+    blake2b_set_lastblock(S);
+    memset(&S->buf[S->buflen], 0, BLAKE2B_BLOCKBYTES - S->buflen); /* Padding */
+    blake2b_compress(S, S->buf);
+
+    for (i = 0; i < 8; ++i) { /* Output full hash to temp buffer */
+        store64(buffer + sizeof(S->h[i]) * i, S->h[i]);
+    }
+
+    memcpy(out, buffer, S->outlen);
+    burn(buffer, sizeof(buffer));
+    burn(S->buf, sizeof(S->buf));
+    burn(S->h, sizeof(S->h));
+    return 0;
+}
+
+int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
+            const void *key, size_t keylen) {
+    blake2b_state S;
+    int ret = -1;
+
+    /* Verify parameters */
+    if (NULL == in && inlen > 0) {
+        goto fail;
+    }
+
+    if (NULL == out || outlen == 0 || outlen > BLAKE2B_OUTBYTES) {
+        goto fail;
+    }
+
+    if ((NULL == key && keylen > 0) || keylen > BLAKE2B_KEYBYTES) {
+        goto fail;
+    }
+
+    if (keylen > 0) {
+        if (blake2b_init_key(&S, outlen, key, keylen) < 0) {
+            goto fail;
+        }
+    } else {
+        if (blake2b_init(&S, outlen) < 0) {
+            goto fail;
+        }
+    }
+
+    if (blake2b_update(&S, in, inlen) < 0) {
+        goto fail;
+    }
+    ret = blake2b_final(&S, out, outlen);
+
+fail:
+    burn(&S, sizeof(S));
+    return ret;
+}
+
+/* Argon2 Team - Begin Code */
+int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen) {
+    uint8_t *out = (uint8_t *)pout;
+    blake2b_state blake_state;
+    uint8_t outlen_bytes[sizeof(uint32_t)] = {0};
+    int ret = -1;
+
+    if (outlen > UINT32_MAX) {
+        goto fail;
+    }
+
+    /* Ensure little-endian byte order! */
+    store32(outlen_bytes, (uint32_t)outlen);
+
+#define TRY(statement)                                                         \
+    do {                                                                       \
+        ret = statement;                                                       \
+        if (ret < 0) {                                                         \
+            goto fail;                                                         \
+        }                                                                      \
+    } while ((void)0, 0)
+
+    if (outlen <= BLAKE2B_OUTBYTES) {
+        TRY(blake2b_init(&blake_state, outlen));
+        TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes)));
+        TRY(blake2b_update(&blake_state, in, inlen));
+        TRY(blake2b_final(&blake_state, out, outlen));
+    } else {
+        uint32_t toproduce;
+        uint8_t out_buffer[BLAKE2B_OUTBYTES];
+        uint8_t in_buffer[BLAKE2B_OUTBYTES];
+        TRY(blake2b_init(&blake_state, BLAKE2B_OUTBYTES));
+        TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes)));
+        TRY(blake2b_update(&blake_state, in, inlen));
+        TRY(blake2b_final(&blake_state, out_buffer, BLAKE2B_OUTBYTES));
+        memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2);
+        out += BLAKE2B_OUTBYTES / 2;
+        toproduce = (uint32_t)outlen - BLAKE2B_OUTBYTES / 2;
+
+        while (toproduce > BLAKE2B_OUTBYTES) {
+            memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES);
+            TRY(blake2b(out_buffer, BLAKE2B_OUTBYTES, in_buffer,
+                        BLAKE2B_OUTBYTES, NULL, 0));
+            memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2);
+            out += BLAKE2B_OUTBYTES / 2;
+            toproduce -= BLAKE2B_OUTBYTES / 2;
+        }
+
+        memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES);
+        TRY(blake2b(out_buffer, toproduce, in_buffer, BLAKE2B_OUTBYTES, NULL,
+                    0));
+        memcpy(out, out_buffer, toproduce);
+    }
+fail:
+    burn(&blake_state, sizeof(blake_state));
+    return ret;
+#undef TRY
+}
+/* Argon2 Team - End Code */

src/argon2/blake2/blamka-round-opt.h

@@ -0,0 +1,163 @@
+#ifndef BLAKE_ROUND_MKA_OPT_H
+#define BLAKE_ROUND_MKA_OPT_H
+
+#include "blake2-impl.h"
+
+#include <emmintrin.h>
+#if defined(__SSSE3__)
+#include <tmmintrin.h> /* for _mm_shuffle_epi8 and _mm_alignr_epi8 */
+#endif
+
+#if defined(__XOP__) && (defined(__GNUC__) || defined(__clang__))
+#include <x86intrin.h>
+#endif
+
+#if !defined(__XOP__)
+#if defined(__SSSE3__)
+#define r16                                                                    \
+    (_mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
+#define r24                                                                    \
+    (_mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
+#define _mm_roti_epi64(x, c)                                                   \
+    (-(c) == 32)                                                               \
+        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))                      \
+        : (-(c) == 24)                                                         \
+              ? _mm_shuffle_epi8((x), r24)                                     \
+              : (-(c) == 16)                                                   \
+                    ? _mm_shuffle_epi8((x), r16)                               \
+                    : (-(c) == 63)                                             \
+                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
+                                          _mm_add_epi64((x), (x)))             \
+                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
+                                          _mm_slli_epi64((x), 64 - (-(c))))
+#else /* defined(__SSE2__) */
+#define _mm_roti_epi64(r, c)                                                   \
+    _mm_xor_si128(_mm_srli_epi64((r), -(c)), _mm_slli_epi64((r), 64 - (-(c))))
+#endif
+#else
+#endif
+
+static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {
+    const __m128i z = _mm_mul_epu32(x, y);
+    return _mm_add_epi64(_mm_add_epi64(x, y), _mm_add_epi64(z, z));
+}
+
+#define G1(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
+    do {                                                                       \
+        A0 = fBlaMka(A0, B0);                                                  \
+        A1 = fBlaMka(A1, B1);                                                  \
+                                                                               \
+        D0 = _mm_xor_si128(D0, A0);                                            \
+        D1 = _mm_xor_si128(D1, A1);                                            \
+                                                                               \
+        D0 = _mm_roti_epi64(D0, -32);                                          \
+        D1 = _mm_roti_epi64(D1, -32);                                          \
+                                                                               \
+        C0 = fBlaMka(C0, D0);                                                  \
+        C1 = fBlaMka(C1, D1);                                                  \
+                                                                               \
+        B0 = _mm_xor_si128(B0, C0);                                            \
+        B1 = _mm_xor_si128(B1, C1);                                            \
+                                                                               \
+        B0 = _mm_roti_epi64(B0, -24);                                          \
+        B1 = _mm_roti_epi64(B1, -24);                                          \
+    } while ((void)0, 0)
+
+#define G2(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
+    do {                                                                       \
+        A0 = fBlaMka(A0, B0);                                                  \
+        A1 = fBlaMka(A1, B1);                                                  \
+                                                                               \
+        D0 = _mm_xor_si128(D0, A0);                                            \
+        D1 = _mm_xor_si128(D1, A1);                                            \
+                                                                               \
+        D0 = _mm_roti_epi64(D0, -16);                                          \
+        D1 = _mm_roti_epi64(D1, -16);                                          \
+                                                                               \
+        C0 = fBlaMka(C0, D0);                                                  \
+        C1 = fBlaMka(C1, D1);                                                  \
+                                                                               \
+        B0 = _mm_xor_si128(B0, C0);                                            \
+        B1 = _mm_xor_si128(B1, C1);                                            \
+                                                                               \
+        B0 = _mm_roti_epi64(B0, -63);                                          \
+        B1 = _mm_roti_epi64(B1, -63);                                          \
+    } while ((void)0, 0)
+
+#if defined(__SSSE3__)
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
+    do {                                                                       \
+        __m128i t0 = _mm_alignr_epi8(B1, B0, 8);                               \
+        __m128i t1 = _mm_alignr_epi8(B0, B1, 8);                               \
+        B0 = t0;                                                               \
+        B1 = t1;                                                               \
+                                                                               \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+                                                                               \
+        t0 = _mm_alignr_epi8(D1, D0, 8);                                       \
+        t1 = _mm_alignr_epi8(D0, D1, 8);                                       \
+        D0 = t1;                                                               \
+        D1 = t0;                                                               \
+    } while ((void)0, 0)
+
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
+    do {                                                                       \
+        __m128i t0 = _mm_alignr_epi8(B0, B1, 8);                               \
+        __m128i t1 = _mm_alignr_epi8(B1, B0, 8);                               \
+        B0 = t0;                                                               \
+        B1 = t1;                                                               \
+                                                                               \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+                                                                               \
+        t0 = _mm_alignr_epi8(D0, D1, 8);                                       \
+        t1 = _mm_alignr_epi8(D1, D0, 8);                                       \
+        D0 = t1;                                                               \
+        D1 = t0;                                                               \
+    } while ((void)0, 0)
+#else /* SSE2 */
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
+    do {                                                                       \
+        __m128i t0 = D0;                                                       \
+        __m128i t1 = B0;                                                       \
+        D0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = D0;                                                               \
+        D0 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t0, t0));               \
+        D1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(D1, D1));               \
+        B0 = _mm_unpackhi_epi64(B0, _mm_unpacklo_epi64(B1, B1));               \
+        B1 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(t1, t1));               \
+    } while ((void)0, 0)
+
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
+    do {                                                                       \
+        __m128i t0, t1;                                                        \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+        t0 = B0;                                                               \
+        t1 = D0;                                                               \
+        B0 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(B0, B0));               \
+        B1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(B1, B1));               \
+        D0 = _mm_unpackhi_epi64(D0, _mm_unpacklo_epi64(D1, D1));               \
+        D1 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t1, t1));               \
+    } while ((void)0, 0)
+#endif
+
+#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1)                           \
+    do {                                                                       \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+                                                                               \
+        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                           \
+                                                                               \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+                                                                               \
+        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                         \
+    } while ((void)0, 0)
+
+#endif

src/argon2/blake2/blamka-round-ref.h

@@ -0,0 +1,39 @@
+#ifndef BLAKE_ROUND_MKA_H
+#define BLAKE_ROUND_MKA_H
+
+#include "blake2.h"
+#include "blake2-impl.h"
+
+/*designed by the Lyra PHC team */
+static BLAKE2_INLINE uint64_t fBlaMka(uint64_t x, uint64_t y) {
+    const uint64_t m = UINT64_C(0xFFFFFFFF);
+    const uint64_t xy = (x & m) * (y & m);
+    return x + y + 2 * xy;
+}
+
+#define G(a, b, c, d)                                                          \
+    do {                                                                       \
+        a = fBlaMka(a, b);                                                     \
+        d = rotr64(d ^ a, 32);                                                 \
+        c = fBlaMka(c, d);                                                     \
+        b = rotr64(b ^ c, 24);                                                 \
+        a = fBlaMka(a, b);                                                     \
+        d = rotr64(d ^ a, 16);                                                 \
+        c = fBlaMka(c, d);                                                     \
+        b = rotr64(b ^ c, 63);                                                 \
+    } while ((void)0, 0)
+
+#define BLAKE2_ROUND_NOMSG(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,   \
+                           v12, v13, v14, v15)                                 \
+    do {                                                                       \
+        G(v0, v4, v8, v12);                                                    \
+        G(v1, v5, v9, v13);                                                    \
+        G(v2, v6, v10, v14);                                                   \
+        G(v3, v7, v11, v15);                                                   \
+        G(v0, v5, v10, v15);                                                   \
+        G(v1, v6, v11, v12);                                                   \
+        G(v2, v7, v8, v13);                                                    \
+        G(v3, v4, v9, v14);                                                    \
+    } while ((void)0, 0)
+
+#endif

src/argon2/core.c

@@ -0,0 +1,607 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+/*For memory wiping*/
+#ifdef _MSC_VER
+#include <windows.h>
+#include <winbase.h> /* For SecureZeroMemory */
+#endif
+#if defined __STDC_LIB_EXT1__
+#define __STDC_WANT_LIB_EXT1__ 1
+#endif
+#define VC_GE_2005(version) (version >= 1400)
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "core.h"
+#include "thread.h"
+#include "blake2/blake2.h"
+#include "blake2/blake2-impl.h"
+
+#ifdef GENKAT
+#include "genkat.h"
+#endif
+
+#if defined(__clang__)
+#if __has_attribute(optnone)
+#define NOT_OPTIMIZED __attribute__((optnone))
+#endif
+#elif defined(__GNUC__)
+#define GCC_VERSION                                                            \
+    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION >= 40400
+#define NOT_OPTIMIZED __attribute__((optimize("O0")))
+#endif
+#endif
+#ifndef NOT_OPTIMIZED
+#define NOT_OPTIMIZED
+#endif
+
+/***************Instance and Position constructors**********/
+void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
+
+void copy_block(block *dst, const block *src) {
+    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_QWORDS_IN_BLOCK);
+}
+
+void xor_block(block *dst, const block *src) {
+    int i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        dst->v[i] ^= src->v[i];
+    }
+}
+
+static void load_block(block *dst, const void *input) {
+    unsigned i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        dst->v[i] = load64((const uint8_t *)input + i * sizeof(dst->v[i]));
+    }
+}
+
+static void store_block(void *output, const block *src) {
+    unsigned i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        store64((uint8_t *)output + i * sizeof(src->v[i]), src->v[i]);
+    }
+}
+
+/***************Memory allocators*****************/
+int allocate_memory(block **memory, uint32_t m_cost) {
+    if (memory != NULL) {
+        size_t memory_size = sizeof(block) * m_cost;
+        if (m_cost != 0 &&
+            memory_size / m_cost !=
+                sizeof(block)) { /*1. Check for multiplication overflow*/
+            return ARGON2_MEMORY_ALLOCATION_ERROR;
+        }
+
+        *memory = (block *)malloc(memory_size); /*2. Try to allocate*/
+
+        if (!*memory) {
+            return ARGON2_MEMORY_ALLOCATION_ERROR;
+        }
+        return ARGON2_OK;
+    } else {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+}
+
+void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) {
+#if defined(_MSC_VER) && VC_GE_2005(_MSC_VER)
+    SecureZeroMemory(v, n);
+#elif defined memset_s
+    memset_s(v, n, 0, n);
+#elif defined(__OpenBSD__)
+    explicit_bzero(v, n);
+#else
+    static void *(*const volatile memset_sec)(void *, int, size_t) = &memset;
+    memset_sec(v, 0, n);
+#endif
+}
+
+/*********Memory functions*/
+
+void clear_memory(argon2_instance_t *instance, int clear) {
+    if (instance->memory != NULL && clear) {
+        secure_wipe_memory(instance->memory,
+                           sizeof(block) * instance->memory_blocks);
+    }
+}
+
+void free_memory(block *memory) { free(memory); }
+
+void finalize(const argon2_context *context, argon2_instance_t *instance) {
+    if (context != NULL && instance != NULL) {
+        block blockhash;
+        uint32_t l;
+
+        copy_block(&blockhash, instance->memory + instance->lane_length - 1);
+
+        /* XOR the last blocks */
+        for (l = 1; l < instance->lanes; ++l) {
+            uint32_t last_block_in_lane =
+                l * instance->lane_length + (instance->lane_length - 1);
+            xor_block(&blockhash, instance->memory + last_block_in_lane);
+        }
+
+        /* Hash the result */
+        {
+            uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
+            store_block(blockhash_bytes, &blockhash);
+            blake2b_long(context->out, context->outlen, blockhash_bytes,
+                         ARGON2_BLOCK_SIZE);
+            secure_wipe_memory(blockhash.v,
+                               ARGON2_BLOCK_SIZE); /* clear blockhash */
+            secure_wipe_memory(blockhash_bytes,
+                               ARGON2_BLOCK_SIZE); /* clear blockhash_bytes */
+        }
+
+#ifdef GENKAT
+        print_tag(context->out, context->outlen);
+#endif
+
+        /* Clear memory */
+        clear_memory(instance, context->flags & ARGON2_FLAG_CLEAR_PASSWORD);
+
+        /* Deallocate the memory */
+        if (NULL != context->free_cbk) {
+            context->free_cbk((uint8_t *)instance->memory,
+                              instance->memory_blocks * sizeof(block));
+        } else {
+            free_memory(instance->memory);
+        }
+    }
+}
+
+uint32_t index_alpha(const argon2_instance_t *instance,
+                     const argon2_position_t *position, uint32_t pseudo_rand,
+                     int same_lane) {
+    /*
+     * Pass 0:
+     *      This lane : all already finished segments plus already constructed
+     * blocks in this segment
+     *      Other lanes : all already finished segments
+     * Pass 1+:
+     *      This lane : (SYNC_POINTS - 1) last segments plus already constructed
+     * blocks in this segment
+     *      Other lanes : (SYNC_POINTS - 1) last segments
+     */
+    uint32_t reference_area_size;
+    uint64_t relative_position;
+    uint32_t start_position, absolute_position;
+
+    if (0 == position->pass) {
+        /* First pass */
+        if (0 == position->slice) {
+            /* First slice */
+            reference_area_size =
+                position->index - 1; /* all but the previous */
+        } else {
+            if (same_lane) {
+                /* The same lane => add current segment */
+                reference_area_size =
+                    position->slice * instance->segment_length +
+                    position->index - 1;
+            } else {
+                reference_area_size =
+                    position->slice * instance->segment_length +
+                    ((position->index == 0) ? (-1) : 0);
+            }
+        }
+    } else {
+        /* Second pass */
+        if (same_lane) {
+            reference_area_size = instance->lane_length -
+                                  instance->segment_length + position->index -
+                                  1;
+        } else {
+            reference_area_size = instance->lane_length -
+                                  instance->segment_length +
+                                  ((position->index == 0) ? (-1) : 0);
+        }
+    }
+
+    /* 1.2.4. Mapping pseudo_rand to 0..<reference_area_size-1> and produce
+     * relative position */
+    relative_position = pseudo_rand;
+    relative_position = relative_position * relative_position >> 32;
+    relative_position = reference_area_size - 1 -
+                        (reference_area_size * relative_position >> 32);
+
+    /* 1.2.5 Computing starting position */
+    start_position = 0;
+
+    if (0 != position->pass) {
+        start_position = (position->slice == ARGON2_SYNC_POINTS - 1)
+                             ? 0
+                             : (position->slice + 1) * instance->segment_length;
+    }
+
+    /* 1.2.6. Computing absolute position */
+    absolute_position = (start_position + relative_position) %
+                        instance->lane_length; /* absolute position */
+    return absolute_position;
+}
+
+#ifdef _WIN32
+static unsigned __stdcall fill_segment_thr(void *thread_data)
+#else
+static void *fill_segment_thr(void *thread_data)
+#endif
+{
+    argon2_thread_data *my_data = (argon2_thread_data *)thread_data;
+    fill_segment(my_data->instance_ptr, my_data->pos);
+    argon2_thread_exit();
+    return 0;
+}
+
+int fill_memory_blocks(argon2_instance_t *instance) {
+    uint32_t r, s;
+    argon2_thread_handle_t *thread = NULL;
+    argon2_thread_data *thr_data = NULL;
+
+    if (instance == NULL || instance->lanes == 0) {
+        return ARGON2_THREAD_FAIL;
+    }
+
+    /* 1. Allocating space for threads */
+    thread = calloc(instance->lanes, sizeof(argon2_thread_handle_t));
+    if (thread == NULL) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    thr_data = calloc(instance->lanes, sizeof(argon2_thread_data));
+    if (thr_data == NULL) {
+        free(thread);
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    for (r = 0; r < instance->passes; ++r) {
+        for (s = 0; s < ARGON2_SYNC_POINTS; ++s) {
+            int rc;
+            uint32_t l;
+
+            /* 2. Calling threads */
+            for (l = 0; l < instance->lanes; ++l) {
+                argon2_position_t position;
+
+                /* 2.1 Join a thread if limit is exceeded */
+                if (l >= instance->threads) {
+                    rc = argon2_thread_join(thread[l - instance->threads]);
+                    if (rc) {
+                        free(thr_data);
+                        free(thread);
+                        return ARGON2_THREAD_FAIL;
+                    }
+                }
+
+                /* 2.2 Create thread */
+                position.pass = r;
+                position.lane = l;
+                position.slice = (uint8_t)s;
+                position.index = 0;
+                thr_data[l].instance_ptr =
+                    instance; /* preparing the thread input */
+                memcpy(&(thr_data[l].pos), &position,
+                       sizeof(argon2_position_t));
+                rc = argon2_thread_create(&thread[l], &fill_segment_thr,
+                                          (void *)&thr_data[l]);
+                if (rc) {
+                    free(thr_data);
+                    free(thread);
+                    return ARGON2_THREAD_FAIL;
+                }
+
+                /* fill_segment(instance, position); */
+                /*Non-thread equivalent of the lines above */
+            }
+
+            /* 3. Joining remaining threads */
+            for (l = instance->lanes - instance->threads; l < instance->lanes;
+                 ++l) {
+                rc = argon2_thread_join(thread[l]);
+                if (rc) {
+                    return ARGON2_THREAD_FAIL;
+                }
+            }
+        }
+
+#ifdef GENKAT
+        internal_kat(instance, r); /* Print all memory blocks */
+#endif
+    }
+
+    if (thread != NULL) {
+        free(thread);
+    }
+    if (thr_data != NULL) {
+        free(thr_data);
+    }
+    return ARGON2_OK;
+}
+
+int validate_inputs(const argon2_context *context) {
+    if (NULL == context) {
+        return ARGON2_INCORRECT_PARAMETER;
+    }
+
+    if (NULL == context->out) {
+        return ARGON2_OUTPUT_PTR_NULL;
+    }
+
+    /* Validate output length */
+    if (ARGON2_MIN_OUTLEN > context->outlen) {
+        return ARGON2_OUTPUT_TOO_SHORT;
+    }
+
+    if (ARGON2_MAX_OUTLEN < context->outlen) {
+        return ARGON2_OUTPUT_TOO_LONG;
+    }
+
+    /* Validate password length */
+    if (NULL == context->pwd) {
+        if (0 != context->pwdlen) {
+            return ARGON2_PWD_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_PWD_LENGTH > context->pwdlen) {
+            return ARGON2_PWD_TOO_SHORT;
+        }
+
+        if (ARGON2_MAX_PWD_LENGTH < context->pwdlen) {
+            return ARGON2_PWD_TOO_LONG;
+        }
+    }
+
+    /* Validate salt length */
+    if (NULL == context->salt) {
+        if (0 != context->saltlen) {
+            return ARGON2_SALT_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_SALT_LENGTH > context->saltlen) {
+            return ARGON2_SALT_TOO_SHORT;
+        }
+
+        if (ARGON2_MAX_SALT_LENGTH < context->saltlen) {
+            return ARGON2_SALT_TOO_LONG;
+        }
+    }
+
+    /* Validate secret length */
+    if (NULL == context->secret) {
+        if (0 != context->secretlen) {
+            return ARGON2_SECRET_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_SECRET > context->secretlen) {
+            return ARGON2_SECRET_TOO_SHORT;
+        }
+
+        if (ARGON2_MAX_SECRET < context->secretlen) {
+            return ARGON2_SECRET_TOO_LONG;
+        }
+    }
+
+    /* Validate associated data */
+    if (NULL == context->ad) {
+        if (0 != context->adlen) {
+            return ARGON2_AD_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_AD_LENGTH > context->adlen) {
+            return ARGON2_AD_TOO_SHORT;
+        }
+
+        if (ARGON2_MAX_AD_LENGTH < context->adlen) {
+            return ARGON2_AD_TOO_LONG;
+        }
+    }
+
+    /* Validate memory cost */
+    if (ARGON2_MIN_MEMORY > context->m_cost) {
+        return ARGON2_MEMORY_TOO_LITTLE;
+    }
+
+    if (ARGON2_MAX_MEMORY < context->m_cost) {
+        return ARGON2_MEMORY_TOO_MUCH;
+    }
+
+    if (context->m_cost < 8 * context->lanes) {
+        return ARGON2_MEMORY_TOO_LITTLE;
+    }
+
+    /* Validate time cost */
+    if (ARGON2_MIN_TIME > context->t_cost) {
+        return ARGON2_TIME_TOO_SMALL;
+    }
+
+    if (ARGON2_MAX_TIME < context->t_cost) {
+        return ARGON2_TIME_TOO_LARGE;
+    }
+
+    /* Validate lanes */
+    if (ARGON2_MIN_LANES > context->lanes) {
+        return ARGON2_LANES_TOO_FEW;
+    }
+
+    if (ARGON2_MAX_LANES < context->lanes) {
+        return ARGON2_LANES_TOO_MANY;
+    }
+
+    /* Validate threads */
+    if (ARGON2_MIN_THREADS > context->threads) {
+        return ARGON2_THREADS_TOO_FEW;
+    }
+
+    if (ARGON2_MAX_THREADS < context->threads) {
+        return ARGON2_THREADS_TOO_MANY;
+    }
+
+    if (NULL != context->allocate_cbk && NULL == context->free_cbk) {
+        return ARGON2_FREE_MEMORY_CBK_NULL;
+    }
+
+    if (NULL == context->allocate_cbk && NULL != context->free_cbk) {
+        return ARGON2_ALLOCATE_MEMORY_CBK_NULL;
+    }
+
+    return ARGON2_OK;
+}
+
+void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) {
+    uint32_t l;
+    /* Make the first and second block in each lane as G(H0||i||0) or
+       G(H0||i||1) */
+    uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
+    for (l = 0; l < instance->lanes; ++l) {
+
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 0);
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH + 4, l);
+        blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash,
+                     ARGON2_PREHASH_SEED_LENGTH);
+        load_block(&instance->memory[l * instance->lane_length + 0],
+                   blockhash_bytes);
+
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 1);
+        blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash,
+                     ARGON2_PREHASH_SEED_LENGTH);
+        load_block(&instance->memory[l * instance->lane_length + 1],
+                   blockhash_bytes);
+    }
+    secure_wipe_memory(blockhash_bytes, ARGON2_BLOCK_SIZE);
+}
+
+void initial_hash(uint8_t *blockhash, argon2_context *context,
+                  argon2_type type) {
+    blake2b_state BlakeHash;
+    uint8_t value[sizeof(uint32_t)];
+
+    if (NULL == context || NULL == blockhash) {
+        return;
+    }
+
+    blake2b_init(&BlakeHash, ARGON2_PREHASH_DIGEST_LENGTH);
+
+    store32(&value, context->lanes);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->outlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->m_cost);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->t_cost);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->version);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, (uint32_t)type);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->pwdlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->pwd != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->pwd,
+                       context->pwdlen);
+
+        if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
+            secure_wipe_memory(context->pwd, context->pwdlen);
+            context->pwdlen = 0;
+        }
+    }
+
+    store32(&value, context->saltlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->salt != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->salt,
+                       context->saltlen);
+    }
+
+    store32(&value, context->secretlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->secret != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->secret,
+                       context->secretlen);
+
+        if (context->flags & ARGON2_FLAG_CLEAR_SECRET) {
+            secure_wipe_memory(context->secret, context->secretlen);
+            context->secretlen = 0;
+        }
+    }
+
+    store32(&value, context->adlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->ad != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->ad,
+                       context->adlen);
+    }
+
+    blake2b_final(&BlakeHash, blockhash, ARGON2_PREHASH_DIGEST_LENGTH);
+}
+
+int initialize(argon2_instance_t *instance, argon2_context *context) {
+    uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH];
+    int result = ARGON2_OK;
+
+    if (instance == NULL || context == NULL)
+        return ARGON2_INCORRECT_PARAMETER;
+
+    /* 1. Memory allocation */
+
+    if (NULL != context->allocate_cbk) {
+        uint8_t *p;
+        result = context->allocate_cbk(&p, instance->memory_blocks *
+                                               ARGON2_BLOCK_SIZE);
+        if (ARGON2_OK != result) {
+            return result;
+        }
+        memcpy(&(instance->memory), p, sizeof(instance->memory));
+    } else {
+        result = allocate_memory(&(instance->memory), instance->memory_blocks);
+        if (ARGON2_OK != result) {
+            return result;
+        }
+    }
+
+    /* 2. Initial hashing */
+    /* H_0 + 8 extra bytes to produce the first blocks */
+    /* uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH]; */
+    /* Hashing all inputs */
+    initial_hash(blockhash, context, instance->type);
+    /* Zeroing 8 extra bytes */
+    secure_wipe_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH,
+                       ARGON2_PREHASH_SEED_LENGTH -
+                           ARGON2_PREHASH_DIGEST_LENGTH);
+
+#ifdef GENKAT
+    initial_kat(blockhash, context, instance->type);
+#endif
+
+    /* 3. Creating first blocks, we always have at least two blocks in a slice
+     */
+    fill_first_blocks(blockhash, instance);
+    /* Clearing the hash */
+    secure_wipe_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH);
+
+    return ARGON2_OK;
+}

src/argon2/core.h

@@ -0,0 +1,219 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#ifndef ARGON2_CORE_H
+#define ARGON2_CORE_H
+
+#include "argon2.h"
+
+#if defined(_MSC_VER)
+#define ALIGN(n) __declspec(align(16))
+#elif defined(__GNUC__) || defined(__clang)
+#define ALIGN(x) __attribute__((__aligned__(x)))
+#else
+#define ALIGN(x)
+#endif
+
+#define CONST_CAST(x) (x)(uintptr_t)
+
+/*************************Argon2 internal
+ * constants**************************************************/
+
+enum argon2_core_constants {
+    /* Memory block size in bytes */
+    ARGON2_BLOCK_SIZE = 1024,
+    ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
+    ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16,
+
+    /* Number of pseudo-random values generated by one call to Blake in Argon2i
+       to
+       generate reference block positions */
+    ARGON2_ADDRESSES_IN_BLOCK = 128,
+
+    /* Pre-hashing digest length and its extension*/
+    ARGON2_PREHASH_DIGEST_LENGTH = 64,
+    ARGON2_PREHASH_SEED_LENGTH = 72
+};
+
+/*************************Argon2 internal data
+ * types**************************************************/
+
+/*
+ * Structure for the (1KB) memory block implemented as 128 64-bit words.
+ * Memory blocks can be copied, XORed. Internal words can be accessed by [] (no
+ * bounds checking).
+ */
+typedef struct block_ { uint64_t v[ARGON2_QWORDS_IN_BLOCK]; } block;
+
+/*****************Functions that work with the block******************/
+
+/* Initialize each byte of the block with @in */
+void init_block_value(block *b, uint8_t in);
+
+/* Copy block @src to block @dst */
+void copy_block(block *dst, const block *src);
+
+/* XOR @src onto @dst bytewise */
+void xor_block(block *dst, const block *src);
+
+/*
+ * Argon2 instance: memory pointer, number of passes, amount of memory, type,
+ * and derived values.
+ * Used to evaluate the number and location of blocks to construct in each
+ * thread
+ */
+typedef struct Argon2_instance_t {
+    block *memory;          /* Memory pointer */
+    uint32_t version;
+    uint32_t passes;        /* Number of passes */
+    uint32_t memory_blocks; /* Number of blocks in memory */
+    uint32_t segment_length;
+    uint32_t lane_length;
+    uint32_t lanes;
+    uint32_t threads;
+    argon2_type type;
+    int print_internals; /* whether to print the memory blocks */
+} argon2_instance_t;
+
+/*
+ * Argon2 position: where we construct the block right now. Used to distribute
+ * work between threads.
+ */
+typedef struct Argon2_position_t {
+    uint32_t pass;
+    uint32_t lane;
+    uint8_t slice;
+    uint32_t index;
+} argon2_position_t;
+
+/*Struct that holds the inputs for thread handling FillSegment*/
+typedef struct Argon2_thread_data {
+    argon2_instance_t *instance_ptr;
+    argon2_position_t pos;
+} argon2_thread_data;
+
+/*************************Argon2 core
+ * functions**************************************************/
+
+/* Allocates memory to the given pointer
+ * @param memory pointer to the pointer to the memory
+ * @param m_cost number of blocks to allocate in the memory
+ * @return ARGON2_OK if @memory is a valid pointer and memory is allocated
+ */
+int allocate_memory(block **memory, uint32_t m_cost);
+
+/* Function that securely cleans the memory
+ * @param mem Pointer to the memory
+ * @param s Memory size in bytes
+ */
+void secure_wipe_memory(void *v, size_t n);
+
+/* Clears memory
+ * @param instance pointer to the current instance
+ * @param clear_memory indicates if we clear the memory with zeros.
+ */
+void clear_memory(argon2_instance_t *instance, int clear);
+
+/* Deallocates memory
+ * @param memory pointer to the blocks
+ */
+void free_memory(block *memory);
+
+/*
+ * Computes absolute position of reference block in the lane following a skewed
+ * distribution and using a pseudo-random value as input
+ * @param instance Pointer to the current instance
+ * @param position Pointer to the current position
+ * @param pseudo_rand 32-bit pseudo-random value used to determine the position
+ * @param same_lane Indicates if the block will be taken from the current lane.
+ * If so we can reference the current segment
+ * @pre All pointers must be valid
+ */
+uint32_t index_alpha(const argon2_instance_t *instance,
+                     const argon2_position_t *position, uint32_t pseudo_rand,
+                     int same_lane);
+
+/*
+ * Function that validates all inputs against predefined restrictions and return
+ * an error code
+ * @param context Pointer to current Argon2 context
+ * @return ARGON2_OK if everything is all right, otherwise one of error codes
+ * (all defined in <argon2.h>
+ */
+int validate_inputs(const argon2_context *context);
+
+/*
+ * Hashes all the inputs into @a blockhash[PREHASH_DIGEST_LENGTH], clears
+ * password and secret if needed
+ * @param  context  Pointer to the Argon2 internal structure containing memory
+ * pointer, and parameters for time and space requirements.
+ * @param  blockhash Buffer for pre-hashing digest
+ * @param  type Argon2 type
+ * @pre    @a blockhash must have at least @a PREHASH_DIGEST_LENGTH bytes
+ * allocated
+ */
+void initial_hash(uint8_t *blockhash, argon2_context *context,
+                  argon2_type type);
+
+/*
+ * Function creates first 2 blocks per lane
+ * @param instance Pointer to the current instance
+ * @param blockhash Pointer to the pre-hashing digest
+ * @pre blockhash must point to @a PREHASH_SEED_LENGTH allocated values
+ */
+void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
+
+/*
+ * Function allocates memory, hashes the inputs with Blake,  and creates first
+ * two blocks. Returns the pointer to the main memory with 2 blocks per lane
+ * initialized
+ * @param  context  Pointer to the Argon2 internal structure containing memory
+ * pointer, and parameters for time and space requirements.
+ * @param  instance Current Argon2 instance
+ * @return Zero if successful, -1 if memory failed to allocate. @context->state
+ * will be modified if successful.
+ */
+int initialize(argon2_instance_t *instance, argon2_context *context);
+
+/*
+ * XORing the last block of each lane, hashing it, making the tag. Deallocates
+ * the memory.
+ * @param context Pointer to current Argon2 context (use only the out parameters
+ * from it)
+ * @param instance Pointer to current instance of Argon2
+ * @pre instance->state must point to necessary amount of memory
+ * @pre context->out must point to outlen bytes of memory
+ * @pre if context->free_cbk is not NULL, it should point to a function that
+ * deallocates memory
+ */
+void finalize(const argon2_context *context, argon2_instance_t *instance);
+
+/*
+ * Function that fills the segment using previous segments also from other
+ * threads
+ * @param instance Pointer to the current instance
+ * @param position Current position
+ * @pre all block pointers must be valid
+ */
+void fill_segment(const argon2_instance_t *instance,
+                  argon2_position_t position);
+
+/*
+ * Function that fills the entire memory t_cost times based on the first two
+ * blocks in each lane
+ * @param instance Pointer to the current instance
+ * @return ARGON2_OK if successful, @context->state
+ */
+int fill_memory_blocks(argon2_instance_t *instance);
+
+#endif

src/argon2/encoding.c

@@ -0,0 +1,426 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "encoding.h"
+#include "core.h"
+
+/*
+ * Example code for a decoder and encoder of "hash strings", with Argon2
+ * parameters.
+ *
+ * This code comprises three sections:
+ *
+ *   -- The first section contains generic Base64 encoding and decoding
+ *   functions. It is conceptually applicable to any hash function
+ *   implementation that uses Base64 to encode and decode parameters,
+ *   salts and outputs. It could be made into a library, provided that
+ *   the relevant functions are made public (non-static) and be given
+ *   reasonable names to avoid collisions with other functions.
+ *
+ *   -- The second section is specific to Argon2. It encodes and decodes
+ *   the parameters, salts and outputs. It does not compute the hash
+ *   itself.
+ *
+ *   -- The third section is test code, with a main() function. With
+ *   this section, the whole file compiles as a stand-alone program
+ *   that exercises the encoding and decoding functions with some
+ *   test vectors.
+ *
+ * The code was originally written by Thomas Pornin <pornin@bolet.org>,
+ * to whom comments and remarks may be sent. It is released under what
+ * should amount to Public Domain or its closest equivalent; the
+ * following mantra is supposed to incarnate that fact with all the
+ * proper legal rituals:
+ *
+ * ---------------------------------------------------------------------
+ * This file is provided under the terms of Creative Commons CC0 1.0
+ * Public Domain Dedication. To the extent possible under law, the
+ * author (Thomas Pornin) has waived all copyright and related or
+ * neighboring rights to this file. This work is published from: Canada.
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015 Thomas Pornin
+ */
+
+/* ==================================================================== */
+/*
+ * Common code; could be shared between different hash functions.
+ *
+ * Note: the Base64 functions below assume that uppercase letters (resp.
+ * lowercase letters) have consecutive numerical codes, that fit on 8
+ * bits. All modern systems use ASCII-compatible charsets, where these
+ * properties are true. If you are stuck with a dinosaur of a system
+ * that still defaults to EBCDIC then you already have much bigger
+ * interoperability issues to deal with.
+ */
+
+/*
+ * Some macros for constant-time comparisons. These work over values in
+ * the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
+ */
+#define EQ(x, y) ((((0U - ((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 0xFF)
+#define GT(x, y) ((((unsigned)(y) - (unsigned)(x)) >> 8) & 0xFF)
+#define GE(x, y) (GT(y, x) ^ 0xFF)
+#define LT(x, y) GT(y, x)
+#define LE(x, y) GE(y, x)
+
+/*
+ * Convert value x (0..63) to corresponding Base64 character.
+ */
+static int b64_byte_to_char(unsigned x) {
+    return (LT(x, 26) & (x + 'A')) |
+           (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
+           (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
+           (EQ(x, 63) & '/');
+}
+
+/*
+ * Convert character c to the corresponding 6-bit value. If character c
+ * is not a Base64 character, then 0xFF (255) is returned.
+ */
+static unsigned b64_char_to_byte(int c) {
+    unsigned x;
+
+    x = (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
+        (GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) |
+        (GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '+') & 62) |
+        (EQ(c, '/') & 63);
+    return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF));
+}
+
+/*
+ * Convert some bytes to Base64. 'dst_len' is the length (in characters)
+ * of the output buffer 'dst'; if that buffer is not large enough to
+ * receive the result (including the terminating 0), then (size_t)-1
+ * is returned. Otherwise, the zero-terminated Base64 string is written
+ * in the buffer, and the output length (counted WITHOUT the terminating
+ * zero) is returned.
+ */
+static size_t to_base64(char *dst, size_t dst_len, const void *src,
+                        size_t src_len) {
+    size_t olen;
+    const unsigned char *buf;
+    unsigned acc, acc_len;
+
+    olen = (src_len / 3) << 2;
+    switch (src_len % 3) {
+    case 2:
+        olen++;
+    /* fall through */
+    case 1:
+        olen += 2;
+        break;
+    }
+    if (dst_len <= olen) {
+        return (size_t)-1;
+    }
+    acc = 0;
+    acc_len = 0;
+    buf = (const unsigned char *)src;
+    while (src_len-- > 0) {
+        acc = (acc << 8) + (*buf++);
+        acc_len += 8;
+        while (acc_len >= 6) {
+            acc_len -= 6;
+            *dst++ = (char)b64_byte_to_char((acc >> acc_len) & 0x3F);
+        }
+    }
+    if (acc_len > 0) {
+        *dst++ = (char)b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
+    }
+    *dst++ = 0;
+    return olen;
+}
+
+/*
+ * Decode Base64 chars into bytes. The '*dst_len' value must initially
+ * contain the length of the output buffer '*dst'; when the decoding
+ * ends, the actual number of decoded bytes is written back in
+ * '*dst_len'.
+ *
+ * Decoding stops when a non-Base64 character is encountered, or when
+ * the output buffer capacity is exceeded. If an error occurred (output
+ * buffer is too small, invalid last characters leading to unprocessed
+ * buffered bits), then NULL is returned; otherwise, the returned value
+ * points to the first non-Base64 character in the source stream, which
+ * may be the terminating zero.
+ */
+static const char *from_base64(void *dst, size_t *dst_len, const char *src) {
+    size_t len;
+    unsigned char *buf;
+    unsigned acc, acc_len;
+
+    buf = (unsigned char *)dst;
+    len = 0;
+    acc = 0;
+    acc_len = 0;
+    for (;;) {
+        unsigned d;
+
+        d = b64_char_to_byte(*src);
+        if (d == 0xFF) {
+            break;
+        }
+        src++;
+        acc = (acc << 6) + d;
+        acc_len += 6;
+        if (acc_len >= 8) {
+            acc_len -= 8;
+            if ((len++) >= *dst_len) {
+                return NULL;
+            }
+            *buf++ = (acc >> acc_len) & 0xFF;
+        }
+    }
+
+    /*
+     * If the input length is equal to 1 modulo 4 (which is
+     * invalid), then there will remain 6 unprocessed bits;
+     * otherwise, only 0, 2 or 4 bits are buffered. The buffered
+     * bits must also all be zero.
+     */
+    if (acc_len > 4 || (acc & (((unsigned)1 << acc_len) - 1)) != 0) {
+        return NULL;
+    }
+    *dst_len = len;
+    return src;
+}
+
+/*
+ * Decode decimal integer from 'str'; the value is written in '*v'.
+ * Returned value is a pointer to the next non-decimal character in the
+ * string. If there is no digit at all, or the value encoding is not
+ * minimal (extra leading zeros), or the value does not fit in an
+ * 'unsigned long', then NULL is returned.
+ */
+static const char *decode_decimal(const char *str, unsigned long *v) {
+    const char *orig;
+    unsigned long acc;
+
+    acc = 0;
+    for (orig = str;; str++) {
+        int c;
+
+        c = *str;
+        if (c < '0' || c > '9') {
+            break;
+        }
+        c -= '0';
+        if (acc > (ULONG_MAX / 10)) {
+            return NULL;
+        }
+        acc *= 10;
+        if ((unsigned long)c > (ULONG_MAX - acc)) {
+            return NULL;
+        }
+        acc += (unsigned long)c;
+    }
+    if (str == orig || (*orig == '0' && str != (orig + 1))) {
+        return NULL;
+    }
+    *v = acc;
+    return str;
+}
+
+/* ==================================================================== */
+/*
+ * Code specific to Argon2.
+ *
+ * The code below applies the following format:
+ *
+ *  $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>[,keyid=<bin>][,data=<bin>][$<bin>[$<bin>]]
+ *
+ * where <T> is either 'd' or 'i', <num> is a decimal integer (positive, fits in
+ * an 'unsigned long'), and <bin> is Base64-encoded data (no '=' padding
+ * characters, no newline or whitespace).
+ * The "keyid" is a binary identifier for a key (up to 8 bytes);
+ * "data" is associated data (up to 32 bytes). When the 'keyid'
+ * (resp. the 'data') is empty, then it is ommitted from the output.
+ *
+ * The last two binary chunks (encoded in Base64) are, in that order,
+ * the salt and the output. Both are optional, but you cannot have an
+ * output without a salt. The binary salt length is between 8 and 48 bytes.
+ * The output length is always exactly 32 bytes.
+ */
+
+int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
+
+/* check for prefix */
+#define CC(prefix)                                                             \
+    do {                                                                       \
+        size_t cc_len = strlen(prefix);                                        \
+        if (strncmp(str, prefix, cc_len) != 0) {                               \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        str += cc_len;                                                         \
+    } while ((void)0, 0)
+
+/* prefix checking with supplied code */
+#define CC_opt(prefix, code)                                                   \
+    do {                                                                       \
+        size_t cc_len = strlen(prefix);                                        \
+        if (strncmp(str, prefix, cc_len) == 0) {                               \
+            str += cc_len;                                                     \
+            { code; }                                                          \
+        }                                                                      \
+    } while ((void)0, 0)
+
+/* Decoding  prefix into decimal */
+#define DECIMAL(x)                                                             \
+    do {                                                                       \
+        unsigned long dec_x;                                                   \
+        str = decode_decimal(str, &dec_x);                                     \
+        if (str == NULL) {                                                     \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        (x) = dec_x;                                                           \
+    } while ((void)0, 0)
+
+#define BIN(buf, max_len, len)                                                 \
+    do {                                                                       \
+        size_t bin_len = (max_len);                                            \
+        str = from_base64(buf, &bin_len, str);                                 \
+        if (str == NULL || bin_len > UINT32_MAX) {                             \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        (len) = (uint32_t)bin_len;                                             \
+    } while ((void)0, 0)
+
+    size_t maxadlen = ctx->adlen;
+    size_t maxsaltlen = ctx->saltlen;
+    size_t maxoutlen = ctx->outlen;
+    int validation_result;
+
+    ctx->adlen = 0;
+    ctx->saltlen = 0;
+    ctx->outlen = 0;
+    ctx->pwdlen = 0;
+
+    if (type == Argon2_i)
+        CC("$argon2i");
+    else if (type == Argon2_d)
+        CC("$argon2d");
+    else
+        return ARGON2_INCORRECT_TYPE;
+    ctx->version = ARGON2_VERSION_10;
+    /* Reading the version number if the default is suppressed */
+    CC_opt("$v=", DECIMAL(ctx->version));
+    CC("$m=");
+    DECIMAL(ctx->m_cost);
+    CC(",t=");
+    DECIMAL(ctx->t_cost);
+    CC(",p=");
+    DECIMAL(ctx->lanes);
+    ctx->threads = ctx->lanes;
+
+    CC_opt(",data=", BIN(ctx->ad, maxadlen, ctx->adlen));
+    if (*str == 0) {
+        return ARGON2_OK;
+    }
+    CC("$");
+    BIN(ctx->salt, maxsaltlen, ctx->saltlen);
+    if (*str == 0) {
+        return ARGON2_OK;
+    }
+    CC("$");
+    BIN(ctx->out, maxoutlen, ctx->outlen);
+    validation_result = validate_inputs(ctx);
+    if (validation_result != ARGON2_OK) {
+        return validation_result;
+    }
+    if (*str == 0) {
+        return ARGON2_OK;
+    } else {
+        return ARGON2_DECODING_FAIL;
+    }
+#undef CC
+#undef CC_opt
+#undef DECIMAL
+#undef BIN
+}
+
+int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
+                  argon2_type type) {
+#define SS(str)                                                                \
+    do {                                                                       \
+        size_t pp_len = strlen(str);                                           \
+        if (pp_len >= dst_len) {                                               \
+            return ARGON2_ENCODING_FAIL;                                       \
+        }                                                                      \
+        memcpy(dst, str, pp_len + 1);                                          \
+        dst += pp_len;                                                         \
+        dst_len -= pp_len;                                                     \
+    } while ((void)0, 0)
+
+#define SX(x)                                                                  \
+    do {                                                                       \
+        char tmp[30];                                                          \
+        sprintf(tmp, "%lu", (unsigned long)(x));                               \
+        SS(tmp);                                                               \
+    } while ((void)0, 0)
+
+#define SB(buf, len)                                                           \
+    do {                                                                       \
+        size_t sb_len = to_base64(dst, dst_len, buf, len);                     \
+        if (sb_len == (size_t)-1) {                                            \
+            return ARGON2_ENCODING_FAIL;                                       \
+        }                                                                      \
+        dst += sb_len;                                                         \
+        dst_len -= sb_len;                                                     \
+    } while ((void)0, 0)
+
+    if (type == Argon2_i)
+        SS("$argon2i$v=");
+    else if (type == Argon2_d)
+        SS("$argon2d$v=");
+    else
+        return ARGON2_ENCODING_FAIL;
+
+    if (validate_inputs(ctx) != ARGON2_OK) {
+        return validate_inputs(ctx);
+    }
+    SX(ctx->version);
+    SS("$m=");
+    SX(ctx->m_cost);
+    SS(",t=");
+    SX(ctx->t_cost);
+    SS(",p=");
+    SX(ctx->lanes);
+
+    if (ctx->adlen > 0) {
+        SS(",data=");
+        SB(ctx->ad, ctx->adlen);
+    }
+
+    if (ctx->saltlen == 0)
+        return ARGON2_OK;
+
+    SS("$");
+    SB(ctx->salt, ctx->saltlen);
+
+    if (ctx->outlen == 0)
+        return ARGON2_OK;
+
+    SS("$");
+    SB(ctx->out, ctx->outlen);
+    return ARGON2_OK;
+
+#undef SS
+#undef SX
+#undef SB
+}
+
+size_t b64len(uint32_t len) {
+    return (((size_t)len + 2) / 3) * 4;
+}
+
+size_t numlen(uint32_t num) {
+    size_t len = 1;
+    while (num >= 10) {
+        ++len;
+        num = num / 10;
+    }
+    return len;
+}
+

src/argon2/encoding.h

@@ -0,0 +1,40 @@
+#ifndef ENCODING_H
+#define ENCODING_H
+#include "argon2.h"
+
+#define ARGON2_MAX_DECODED_LANES UINT32_C(255)
+#define ARGON2_MIN_DECODED_SALT_LEN UINT32_C(8)
+#define ARGON2_MIN_DECODED_OUT_LEN UINT32_C(12)
+
+/*
+* encode an Argon2 hash string into the provided buffer. 'dst_len'
+* contains the size, in characters, of the 'dst' buffer; if 'dst_len'
+* is less than the number of required characters (including the
+* terminating 0), then this function returns ARGON2_ENCODING_ERROR.
+*
+* if ctx->outlen is 0, then the hash string will be a salt string
+* (no output). if ctx->saltlen is also 0, then the string will be a
+* parameter-only string (no salt and no output).
+*
+* on success, ARGON2_OK is returned.
+*
+* No other parameters are checked
+*/
+int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
+                  argon2_type type);
+
+/*
+* Decodes an Argon2 hash string into the provided structure 'ctx'.
+* The fields ctx.saltlen, ctx.adlen, ctx.outlen set the maximal salt, ad, out
+* length values that are allowed; invalid input string causes an error.
+* Returned value is ARGON2_OK on success, other ARGON2_ codes on error.
+*/
+int decode_string(argon2_context *ctx, const char *str, argon2_type type);
+
+/* Returns the length of the encoded byte stream with length len */
+size_t b64len(uint32_t len);
+
+/* Returns the length of the encoded number num */
+size_t numlen(uint32_t num);
+
+#endif

src/argon2/opt.c

@@ -0,0 +1,220 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "argon2.h"
+#include "opt.h"
+
+#include "blake2/blake2.h"
+#include "blake2/blamka-round-opt.h"
+
+void fill_block(__m128i *state, const uint8_t *ref_block, uint8_t *next_block) {
+    __m128i block_XY[ARGON2_OWORDS_IN_BLOCK];
+    uint32_t i;
+
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
+        block_XY[i] = state[i] = _mm_xor_si128(
+            state[i], _mm_loadu_si128((__m128i const *)(&ref_block[16 * i])));
+    }
+
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND(state[8 * i + 0], state[8 * i + 1], state[8 * i + 2],
+            state[8 * i + 3], state[8 * i + 4], state[8 * i + 5],
+            state[8 * i + 6], state[8 * i + 7]);
+    }
+
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND(state[8 * 0 + i], state[8 * 1 + i], state[8 * 2 + i],
+            state[8 * 3 + i], state[8 * 4 + i], state[8 * 5 + i],
+            state[8 * 6 + i], state[8 * 7 + i]);
+    }
+
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
+        state[i] = _mm_xor_si128(state[i], block_XY[i]);
+        _mm_storeu_si128((__m128i *)(&next_block[16 * i]), state[i]);
+    }
+}
+
+void fill_block_with_xor(__m128i *state, const uint8_t *ref_block,
+                         uint8_t *next_block) {
+    __m128i block_XY[ARGON2_OWORDS_IN_BLOCK];
+    uint32_t i;
+
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) { 
+       state[i] = _mm_xor_si128(
+            state[i], _mm_loadu_si128((__m128i const *)(&ref_block[16 * i])));
+        block_XY[i] =  _mm_xor_si128(
+            state[i], _mm_loadu_si128((__m128i const *)(&next_block[16 * i])));
+    }
+
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND(state[8 * i + 0], state[8 * i + 1], state[8 * i + 2],
+                     state[8 * i + 3], state[8 * i + 4], state[8 * i + 5],
+                     state[8 * i + 6], state[8 * i + 7]);
+    }
+
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND(state[8 * 0 + i], state[8 * 1 + i], state[8 * 2 + i],
+                     state[8 * 3 + i], state[8 * 4 + i], state[8 * 5 + i],
+                     state[8 * 6 + i], state[8 * 7 + i]);
+    }
+
+    for (i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++) {
+        state[i] = _mm_xor_si128(state[i], block_XY[i]);
+        _mm_storeu_si128((__m128i *)(&next_block[16 * i]), state[i]);
+    }
+}
+
+void generate_addresses(const argon2_instance_t *instance,
+                        const argon2_position_t *position,
+                        uint64_t *pseudo_rands) {
+    block address_block, input_block, tmp_block;
+    uint32_t i;
+
+    init_block_value(&address_block, 0);
+    init_block_value(&input_block, 0);
+
+    if (instance != NULL && position != NULL) {
+        input_block.v[0] = position->pass;
+        input_block.v[1] = position->lane;
+        input_block.v[2] = position->slice;
+        input_block.v[3] = instance->memory_blocks;
+        input_block.v[4] = instance->passes;
+        input_block.v[5] = instance->type;
+
+        for (i = 0; i < instance->segment_length; ++i) {
+            if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) {
+                /*Temporary zero-initialized blocks*/
+                __m128i zero_block[ARGON2_OWORDS_IN_BLOCK];
+                __m128i zero2_block[ARGON2_OWORDS_IN_BLOCK];
+                memset(zero_block, 0, sizeof(zero_block));
+                memset(zero2_block, 0, sizeof(zero2_block));
+                init_block_value(&address_block, 0);
+                init_block_value(&tmp_block, 0);
+                /*Increasing index counter*/
+                input_block.v[6]++;
+                /*First iteration of G*/
+                fill_block_with_xor(zero_block, (uint8_t *)&input_block.v,
+                           (uint8_t *)&tmp_block.v);
+                /*Second iteration of G*/
+                fill_block_with_xor(zero2_block, (uint8_t *)&tmp_block.v,
+                           (uint8_t *)&address_block.v);
+            }
+
+            pseudo_rands[i] = address_block.v[i % ARGON2_ADDRESSES_IN_BLOCK];
+        }
+    }
+}
+
+void fill_segment(const argon2_instance_t *instance,
+                  argon2_position_t position) {
+    block *ref_block = NULL, *curr_block = NULL;
+    uint64_t pseudo_rand, ref_index, ref_lane;
+    uint32_t prev_offset, curr_offset;
+    uint32_t starting_index, i;
+    __m128i state[64];
+    int data_independent_addressing;
+
+    /* Pseudo-random values that determine the reference block position */
+    uint64_t *pseudo_rands = NULL;
+
+    if (instance == NULL) {
+        return;
+    }
+
+    data_independent_addressing = (instance->type == Argon2_i);
+
+    pseudo_rands =
+        (uint64_t *)malloc(sizeof(uint64_t) * instance->segment_length);
+    if (pseudo_rands == NULL) {
+        return;
+    }
+
+    if (data_independent_addressing) {
+        generate_addresses(instance, &position, pseudo_rands);
+    }
+
+    starting_index = 0;
+
+    if ((0 == position.pass) && (0 == position.slice)) {
+        starting_index = 2; /* we have already generated the first two blocks */
+    }
+
+    /* Offset of the current block */
+    curr_offset = position.lane * instance->lane_length +
+                  position.slice * instance->segment_length + starting_index;
+
+    if (0 == curr_offset % instance->lane_length) {
+        /* Last block in this lane */
+        prev_offset = curr_offset + instance->lane_length - 1;
+    } else {
+        /* Previous block */
+        prev_offset = curr_offset - 1;
+    }
+
+    memcpy(state, ((instance->memory + prev_offset)->v), ARGON2_BLOCK_SIZE);
+
+    for (i = starting_index; i < instance->segment_length;
+         ++i, ++curr_offset, ++prev_offset) {
+        /*1.1 Rotating prev_offset if needed */
+        if (curr_offset % instance->lane_length == 1) {
+            prev_offset = curr_offset - 1;
+        }
+
+        /* 1.2 Computing the index of the reference block */
+        /* 1.2.1 Taking pseudo-random value from the previous block */
+        if (data_independent_addressing) {
+            pseudo_rand = pseudo_rands[i];
+        } else {
+            pseudo_rand = instance->memory[prev_offset].v[0];
+        }
+
+        /* 1.2.2 Computing the lane of the reference block */
+        ref_lane = ((pseudo_rand >> 32)) % instance->lanes;
+
+        if ((position.pass == 0) && (position.slice == 0)) {
+            /* Can not reference other lanes yet */
+            ref_lane = position.lane;
+        }
+
+        /* 1.2.3 Computing the number of possible reference block within the
+         * lane.
+         */
+        position.index = i;
+        ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
+                                ref_lane == position.lane);
+
+        /* 2 Creating a new block */
+        ref_block =
+            instance->memory + instance->lane_length * ref_lane + ref_index;
+        curr_block = instance->memory + curr_offset;
+        if (ARGON2_VERSION_10 == instance->version) {
+            /* version 1.2.1 and earlier: overwrite, not XOR */
+            fill_block(state, (uint8_t *)ref_block->v,
+                       (uint8_t *)curr_block->v);
+        } else {
+            if(0 == position.pass) {
+                fill_block(state, (uint8_t *)ref_block->v,
+                           (uint8_t *)curr_block->v);
+            } else {
+                fill_block_with_xor(state, (uint8_t *)ref_block->v,
+                                    (uint8_t *)curr_block->v);
+            }
+        }
+    }
+
+    free(pseudo_rands);
+}

src/argon2/opt.h

@@ -0,0 +1,52 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#ifndef ARGON2_OPT_H
+#define ARGON2_OPT_H
+
+#include "core.h"
+#include <emmintrin.h>
+
+/*
+ * Function fills a new memory block by XORing the new block over the old one. Memory must be initialized. 
+ * After finishing, @state is identical to @next_block
+ * @param state Pointer to the just produced block. Content will be updated(!)
+ * @param ref_block Pointer to the reference block
+ * @param next_block Pointer to the block to be XORed over. May coincide with @ref_block
+ * @pre all block pointers must be valid
+ */
+void fill_block_with_xor(__m128i *state, const uint8_t *ref_block, uint8_t *next_block);
+
+/* LEGACY CODE: version 1.2.1 and earlier
+* Function fills a new memory block by overwriting @next_block.
+* @param state Pointer to the just produced block. Content will be updated(!)
+* @param ref_block Pointer to the reference block
+* @param next_block Pointer to the block to be XORed over. May coincide with @ref_block
+* @pre all block pointers must be valid
+*/
+void fill_block(__m128i *state, const uint8_t *ref_block, uint8_t *next_block);
+
+
+/*
+ * Generate pseudo-random values to reference blocks in the segment and puts
+ * them into the array
+ * @param instance Pointer to the current instance
+ * @param position Pointer to the current position
+ * @param pseudo_rands Pointer to the array of 64-bit values
+ * @pre pseudo_rands must point to @a instance->segment_length allocated values
+ */
+void generate_addresses(const argon2_instance_t *instance,
+                        const argon2_position_t *position,
+                        uint64_t *pseudo_rands);
+
+#endif /* ARGON2_OPT_H */

src/argon2/ref.c

@@ -0,0 +1,228 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "argon2.h"
+#include "ref.h"
+
+#include "blake2/blamka-round-ref.h"
+#include "blake2/blake2-impl.h"
+#include "blake2/blake2.h"
+
+
+void fill_block(const block *prev_block, const block *ref_block,
+    block *next_block) {
+    block blockR, block_tmp;
+    unsigned i;
+
+    copy_block(&blockR, ref_block);
+    xor_block(&blockR, prev_block);
+    copy_block(&block_tmp, &blockR);
+            /*Now blockR = ref_block + prev_block and bloc_tmp = ref_block + prev_block */
+                /* Apply Blake2 on columns of 64-bit words: (0,1,...,15) , then
+                (16,17,..31)... finally (112,113,...127) */
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND_NOMSG(
+            blockR.v[16 * i], blockR.v[16 * i + 1], blockR.v[16 * i + 2],
+            blockR.v[16 * i + 3], blockR.v[16 * i + 4], blockR.v[16 * i + 5],
+            blockR.v[16 * i + 6], blockR.v[16 * i + 7], blockR.v[16 * i + 8],
+            blockR.v[16 * i + 9], blockR.v[16 * i + 10], blockR.v[16 * i + 11],
+            blockR.v[16 * i + 12], blockR.v[16 * i + 13], blockR.v[16 * i + 14],
+            blockR.v[16 * i + 15]);
+    }
+
+    /* Apply Blake2 on rows of 64-bit words: (0,1,16,17,...112,113), then
+    (2,3,18,19,...,114,115).. finally (14,15,30,31,...,126,127) */
+    for (i = 0; i < 8; i++) {
+        BLAKE2_ROUND_NOMSG(
+            blockR.v[2 * i], blockR.v[2 * i + 1], blockR.v[2 * i + 16],
+            blockR.v[2 * i + 17], blockR.v[2 * i + 32], blockR.v[2 * i + 33],
+            blockR.v[2 * i + 48], blockR.v[2 * i + 49], blockR.v[2 * i + 64],
+            blockR.v[2 * i + 65], blockR.v[2 * i + 80], blockR.v[2 * i + 81],
+            blockR.v[2 * i + 96], blockR.v[2 * i + 97], blockR.v[2 * i + 112],
+            blockR.v[2 * i + 113]);
+    }
+
+    copy_block(next_block, &block_tmp);
+    xor_block(next_block, &blockR);
+}
+
+
+void fill_block_with_xor(const block *prev_block, const block *ref_block,
+                block *next_block) {
+    block blockR, block_tmp;
+    unsigned i;
+
+    copy_block(&blockR, ref_block);
+    xor_block(&blockR, prev_block);
+    copy_block(&block_tmp, &blockR);
+    xor_block(&block_tmp, next_block); /*Saving the next block contents for XOR over*/
+    /*Now blockR = ref_block + prev_block and bloc_tmp = ref_block + prev_block + next_block*/
+    /* Apply Blake2 on columns of 64-bit words: (0,1,...,15) , then
+       (16,17,..31)... finally (112,113,...127) */
+    for (i = 0; i < 8; ++i) {
+        BLAKE2_ROUND_NOMSG(
+            blockR.v[16 * i], blockR.v[16 * i + 1], blockR.v[16 * i + 2],
+            blockR.v[16 * i + 3], blockR.v[16 * i + 4], blockR.v[16 * i + 5],
+            blockR.v[16 * i + 6], blockR.v[16 * i + 7], blockR.v[16 * i + 8],
+            blockR.v[16 * i + 9], blockR.v[16 * i + 10], blockR.v[16 * i + 11],
+            blockR.v[16 * i + 12], blockR.v[16 * i + 13], blockR.v[16 * i + 14],
+            blockR.v[16 * i + 15]);
+    }
+
+    /* Apply Blake2 on rows of 64-bit words: (0,1,16,17,...112,113), then
+       (2,3,18,19,...,114,115).. finally (14,15,30,31,...,126,127) */
+    for (i = 0; i < 8; i++) {
+        BLAKE2_ROUND_NOMSG(
+            blockR.v[2 * i], blockR.v[2 * i + 1], blockR.v[2 * i + 16],
+            blockR.v[2 * i + 17], blockR.v[2 * i + 32], blockR.v[2 * i + 33],
+            blockR.v[2 * i + 48], blockR.v[2 * i + 49], blockR.v[2 * i + 64],
+            blockR.v[2 * i + 65], blockR.v[2 * i + 80], blockR.v[2 * i + 81],
+            blockR.v[2 * i + 96], blockR.v[2 * i + 97], blockR.v[2 * i + 112],
+            blockR.v[2 * i + 113]);
+    }
+
+    copy_block(next_block, &block_tmp);
+    xor_block(next_block, &blockR);
+}
+
+void generate_addresses(const argon2_instance_t *instance,
+                        const argon2_position_t *position,
+                        uint64_t *pseudo_rands) {
+    block zero_block, input_block, address_block,tmp_block;
+    uint32_t i;
+
+    init_block_value(&zero_block, 0);
+    init_block_value(&input_block, 0);
+
+    if (instance != NULL && position != NULL) {
+        input_block.v[0] = position->pass;
+        input_block.v[1] = position->lane;
+        input_block.v[2] = position->slice;
+        input_block.v[3] = instance->memory_blocks;
+        input_block.v[4] = instance->passes;
+        input_block.v[5] = instance->type;
+
+        for (i = 0; i < instance->segment_length; ++i) {
+            if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) {
+                input_block.v[6]++;
+                init_block_value(&tmp_block, 0);
+                init_block_value(&address_block, 0);
+                fill_block_with_xor(&zero_block, &input_block, &tmp_block);
+                fill_block_with_xor(&zero_block, &tmp_block, &address_block);
+            }
+
+            pseudo_rands[i] = address_block.v[i % ARGON2_ADDRESSES_IN_BLOCK];
+        }
+    }
+}
+
+void fill_segment(const argon2_instance_t *instance,
+                  argon2_position_t position) {
+    block *ref_block = NULL, *curr_block = NULL;
+    uint64_t pseudo_rand, ref_index, ref_lane;
+    uint32_t prev_offset, curr_offset;
+    uint32_t starting_index;
+    uint32_t i;
+    int data_independent_addressing;
+    /* Pseudo-random values that determine the reference block position */
+    uint64_t *pseudo_rands = NULL;
+
+    if (instance == NULL) {
+        return;
+    }
+
+    data_independent_addressing = (instance->type == Argon2_i);
+
+    pseudo_rands =
+        (uint64_t *)malloc(sizeof(uint64_t) * (instance->segment_length));
+
+    if (pseudo_rands == NULL) {
+        return;
+    }
+
+    if (data_independent_addressing) {
+        generate_addresses(instance, &position, pseudo_rands);
+    }
+
+    starting_index = 0;
+
+    if ((0 == position.pass) && (0 == position.slice)) {
+        starting_index = 2; /* we have already generated the first two blocks */
+    }
+
+    /* Offset of the current block */
+    curr_offset = position.lane * instance->lane_length +
+                  position.slice * instance->segment_length + starting_index;
+
+    if (0 == curr_offset % instance->lane_length) {
+        /* Last block in this lane */
+        prev_offset = curr_offset + instance->lane_length - 1;
+    } else {
+        /* Previous block */
+        prev_offset = curr_offset - 1;
+    }
+
+    for (i = starting_index; i < instance->segment_length;
+         ++i, ++curr_offset, ++prev_offset) {
+        /*1.1 Rotating prev_offset if needed */
+        if (curr_offset % instance->lane_length == 1) {
+            prev_offset = curr_offset - 1;
+        }
+
+        /* 1.2 Computing the index of the reference block */
+        /* 1.2.1 Taking pseudo-random value from the previous block */
+        if (data_independent_addressing) {
+            pseudo_rand = pseudo_rands[i];
+        } else {
+            pseudo_rand = instance->memory[prev_offset].v[0];
+        }
+
+        /* 1.2.2 Computing the lane of the reference block */
+        ref_lane = ((pseudo_rand >> 32)) % instance->lanes;
+
+        if ((position.pass == 0) && (position.slice == 0)) {
+            /* Can not reference other lanes yet */
+            ref_lane = position.lane;
+        }
+
+        /* 1.2.3 Computing the number of possible reference block within the
+         * lane.
+         */
+        position.index = i;
+        ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
+                                ref_lane == position.lane);
+
+        /* 2 Creating a new block */
+        ref_block =
+            instance->memory + instance->lane_length * ref_lane + ref_index;
+        curr_block = instance->memory + curr_offset;
+        if (ARGON2_VERSION_10 == instance->version) {
+            /* version 1.2.1 and earlier: overwrite, not XOR */
+            fill_block(instance->memory + prev_offset, ref_block, curr_block);
+        } else {
+            if(0 == position.pass) {
+                fill_block(instance->memory + prev_offset, ref_block,
+                           curr_block);
+            } else {
+                fill_block_with_xor(instance->memory + prev_offset, ref_block,
+                                    curr_block);
+            }
+        }
+    }
+
+    free(pseudo_rands);
+}

src/argon2/ref.h

@@ -0,0 +1,51 @@
+/*
+ * Argon2 source code package
+ *
+ * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ *
+ * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with
+ * this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#ifndef ARGON2_REF_H
+#define ARGON2_REF_H
+
+#include "core.h"
+
+/*
+ * Function fills a new memory block by XORing over @next_block. @next_block must be initialized
+ * @param prev_block Pointer to the previous block
+ * @param ref_block Pointer to the reference block
+ * @param next_block Pointer to the block to be constructed
+ * @pre all block pointers must be valid
+ */
+void fill_block_with_xor(const block *prev_block, const block *ref_block,
+                block *next_block);
+
+/* LEGACY CODE: version 1.2.1 and earlier
+* Function fills a new memory block by overwriting @next_block. 
+* @param prev_block Pointer to the previous block
+* @param ref_block Pointer to the reference block
+* @param next_block Pointer to the block to be constructed
+* @pre all block pointers must be valid
+*/
+void fill_block(const block *prev_block, const block *ref_block,
+    block *next_block);
+
+/*
+ * Generate pseudo-random values to reference blocks in the segment and puts
+ * them into the array
+ * @param instance Pointer to the current instance
+ * @param position Pointer to the current position
+ * @param pseudo_rands Pointer to the array of 64-bit values
+ * @pre pseudo_rands must point to @a instance->segment_length allocated values
+ */
+void generate_addresses(const argon2_instance_t *instance,
+                        const argon2_position_t *position,
+                        uint64_t *pseudo_rands);
+
+#endif /* ARGON2_REF_H */

src/argon2/thread.c

@@ -0,0 +1,36 @@
+#include "thread.h"
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+int argon2_thread_create(argon2_thread_handle_t *handle,
+                         argon2_thread_func_t func, void *args) {
+    if (NULL == handle || func == NULL) {
+        return -1;
+    }
+#if defined(_WIN32)
+    *handle = _beginthreadex(NULL, 0, func, args, 0, NULL);
+    return *handle != 0 ? 0 : -1;
+#else
+    return pthread_create(handle, NULL, func, args);
+#endif
+}
+
+int argon2_thread_join(argon2_thread_handle_t handle) {
+#if defined(_WIN32)
+    if (WaitForSingleObject((HANDLE)handle, INFINITE) == WAIT_OBJECT_0) {
+        return CloseHandle((HANDLE)handle) != 0 ? 0 : -1;
+    }
+    return -1;
+#else
+    return pthread_join(handle, NULL);
+#endif
+}
+
+void argon2_thread_exit(void) {
+#if defined(_WIN32)
+    _endthreadex(0);
+#else
+    pthread_exit(NULL);
+#endif
+}

src/argon2/thread.h

@@ -0,0 +1,46 @@
+#ifndef ARGON2_THREAD_H
+#define ARGON2_THREAD_H
+/*
+        Here we implement an abstraction layer for the simpĺe requirements
+        of the Argon2 code. We only require 3 primitives---thread creation,
+        joining, and termination---so full emulation of the pthreads API
+        is unwarranted. Currently we wrap pthreads and Win32 threads.
+
+        The API defines 2 types: the function pointer type,
+   argon2_thread_func_t,
+        and the type of the thread handle---argon2_thread_handle_t.
+*/
+#if defined(_WIN32)
+#include <process.h>
+typedef unsigned(__stdcall *argon2_thread_func_t)(void *);
+typedef uintptr_t argon2_thread_handle_t;
+#else
+#include <pthread.h>
+typedef void *(*argon2_thread_func_t)(void *);
+typedef pthread_t argon2_thread_handle_t;
+#endif
+
+/* Creates a thread
+ * @param handle pointer to a thread handle, which is the output of this
+ * function. Must not be NULL.
+ * @param func A function pointer for the thread's entry point. Must not be
+ * NULL.
+ * @param args Pointer that is passed as an argument to @func. May be NULL.
+ * @return 0 if @handle and @func are valid pointers and a thread is successfuly
+ * created.
+ */
+int argon2_thread_create(argon2_thread_handle_t *handle,
+                         argon2_thread_func_t func, void *args);
+
+/* Waits for a thread to terminate
+ * @param handle Handle to a thread created with argon2_thread_create.
+ * @return 0 if @handle is a valid handle, and joining completed successfully.
+*/
+int argon2_thread_join(argon2_thread_handle_t handle);
+
+/* Terminate the current thread. Must be run inside a thread created by
+ * argon2_thread_create.
+*/
+void argon2_thread_exit(void);
+
+#endif

src/callbacks.cpp

@@ -0,0 +1,50 @@
+#include "callbacks.h"
+
+namespace dht {
+
+
+GetCallbackSimple
+bindGetCb(GetCallbackRaw raw_cb, void* user_data)
+{
+    if (not raw_cb) return {};
+    return [=](const std::shared_ptr<Value>& value) {
+        return raw_cb(value, user_data);
+    };
+}
+
+GetCallback
+bindGetCb(GetCallbackSimple cb)
+{
+    if (not cb) return {};
+    return [=](const std::vector<std::shared_ptr<Value>>& values) {
+        for (const auto& v : values)
+            if (not cb(v))
+                return false;
+        return true;
+    };
+}
+
+ShutdownCallback
+bindShutdownCb(ShutdownCallbackRaw shutdown_cb_raw, void* user_data)
+{
+    return [=]() { shutdown_cb_raw(user_data); };
+}
+
+DoneCallback
+bindDoneCb(DoneCallbackSimple donecb)
+{
+    if (not donecb) return {};
+    using namespace std::placeholders;
+    return std::bind(donecb, _1);
+}
+
+DoneCallback
+bindDoneCb(DoneCallbackRaw raw_cb, void* user_data)
+{
+    if (not raw_cb) return {};
+    return [=](bool success, const std::vector<std::shared_ptr<Node>>& nodes) {
+        raw_cb(success, (std::vector<std::shared_ptr<Node>>*)&nodes, user_data);
+    };
+}
+
+}

src/crypto.cpp

@@ -26,6 +26,8 @@ extern "C" {
 #include <gnutls/x509.h>
 #include <nettle/gcm.h>
 #include <nettle/aes.h>
+
+#include "argon2/argon2.h"
 }
 
 #include <random>
@@ -33,7 +35,11 @@ extern "C" {
 #include <stdexcept>
 #include <cassert>
 
+#ifdef _WIN32
+static std::uniform_int_distribution<int> rand_byte{ 0, std::numeric_limits<uint8_t>::max() };
+#else
 static std::uniform_int_distribution<uint8_t> rand_byte;
+#endif
 
 static gnutls_digest_algorithm_t get_dig_for_pub(gnutls_pubkey_t pubkey)
 {
@@ -75,13 +81,13 @@ namespace dht {
 namespace crypto {
 
 static constexpr std::array<size_t, 3> AES_LENGTHS {{128/8, 192/8, 256/8}};
+static constexpr size_t PASSWORD_SALT_LENGTH {16};
 
 size_t aesKeySize(size_t max)
 {
     size_t aes_key_len = 0;
-    for (size_t s = 0; s < AES_LENGTHS.size(); s++) {
-        if (AES_LENGTHS[s] <= max)
-            aes_key_len = AES_LENGTHS[s];
+    for (size_t s : AES_LENGTHS) {
+        if (s <= max) aes_key_len = s;
         else break;
     }
     return aes_key_len;
@@ -99,9 +105,11 @@ bool aesKeySizeGood(size_t key_size)
 #define GCM_DIGEST_SIZE GCM_BLOCK_SIZE
 #endif
 
-Blob
-aesEncrypt(const Blob& data, const Blob& key)
+Blob aesEncrypt(const Blob& data, const Blob& key)
 {
+    if (not aesKeySizeGood(key.size()))
+        throw DecryptError("Wrong key size");
+
     Blob ret(data.size() + GCM_IV_SIZE + GCM_DIGEST_SIZE);
     {
         crypto::random_device rdev;
@@ -117,8 +125,17 @@ aesEncrypt(const Blob& data, const Blob& key)
     return ret;
 }
 
-Blob
-aesDecrypt(const Blob& data, const Blob& key)
+Blob aesEncrypt(const Blob& data, const std::string& password)
+{
+    Blob salt;
+    Blob key = stretchKey(password, salt);
+    key.resize(256 / 8);
+    Blob encrypted = aesEncrypt(data, key);
+    encrypted.insert(encrypted.begin(), salt.begin(), salt.end());
+    return encrypted;
+}
+
+Blob aesDecrypt(const Blob& data, const Blob& key)
 {
     if (not aesKeySizeGood(key.size()))
         throw DecryptError("Wrong key size");
@@ -143,7 +160,7 @@ aesDecrypt(const Blob& data, const Blob& key)
     struct gcm_aes_ctx aes_d;
     gcm_aes_set_key(&aes_d, key.size(), key.data());
     gcm_aes_set_iv(&aes_d, GCM_IV_SIZE, data.data());
-    gcm_aes_update(&aes_d, ret.size() , ret.data());
+    gcm_aes_update(&aes_d, ret.size(), ret.data());
     gcm_aes_encrypt(&aes_d, ret.size(), ret_tmp.data(), ret.data());
     gcm_aes_digest(&aes_d, GCM_DIGEST_SIZE, digest.data());
 
@@ -153,6 +170,44 @@ aesDecrypt(const Blob& data, const Blob& key)
     return ret;
 }
 
+Blob aesDecrypt(const Blob& data, const std::string& password)
+{
+    if (data.size() <= PASSWORD_SALT_LENGTH)
+        throw DecryptError("Wrong data size");    
+    Blob salt {data.begin(), data.begin()+PASSWORD_SALT_LENGTH};
+    Blob key = stretchKey(password, salt);
+    key.resize(256 / 8);
+    Blob encrypted {data.begin()+PASSWORD_SALT_LENGTH, data.end()};
+    return aesDecrypt(encrypted, key);
+}
+
+Blob stretchKey(const std::string& password, Blob& salt)
+{
+    if (salt.empty()) {
+        salt.resize(PASSWORD_SALT_LENGTH);
+        crypto::random_device rdev;
+        std::generate_n(salt.begin(), salt.size(), std::bind(rand_byte, std::ref(rdev)));
+    }
+    Blob res;
+    res.resize(32);
+    auto ret = argon2i_hash_raw(16, 64*1024, 1, password.data(), password.size(), salt.data(), salt.size(), res.data(), res.size());
+    if (ret != ARGON2_OK)
+        throw CryptoException("Can't compute argon2i !");
+    return hash(res);
+}
+
+Blob hash(const Blob& data)
+{
+    Blob res;
+    size_t res_size = 64;
+    res.resize(res_size);
+    const gnutls_datum_t gdat {(uint8_t*)data.data(), (unsigned)data.size()};
+    if (gnutls_fingerprint(GNUTLS_DIG_SHA512, &gdat, res.data(), &res_size))
+        throw CryptoException("Can't compute hash !");
+    res.resize(res_size);
+    return res;
+}
+
 PrivateKey::PrivateKey()
 {
 #if GNUTLS_VERSION_NUMBER < 0x030300
@@ -696,23 +751,40 @@ PrivateKey::generate(unsigned key_length)
     return PrivateKey{key};
 }
 
-crypto::Identity
-generateIdentity(const std::string& name, crypto::Identity ca, unsigned key_length)
+Identity
+generateIdentity(const std::string& name, crypto::Identity ca, unsigned key_length, bool is_ca)
 {
 #if GNUTLS_VERSION_NUMBER < 0x030300
     if (gnutls_global_init() != GNUTLS_E_SUCCESS)
         return {};
 #endif
-    auto shared_key = std::make_shared<PrivateKey>(PrivateKey::generate(key_length));
+    auto key = std::make_shared<PrivateKey>(PrivateKey::generate(key_length));
 
+    auto cert = std::make_shared<Certificate>(Certificate::generate(*key, name, ca, is_ca));
+
+#if GNUTLS_VERSION_NUMBER < 0x030300
+    gnutls_global_deinit();
+#endif
+    return {std::move(key), std::move(cert)};
+}
+
+
+Identity
+generateIdentity(const std::string& name, Identity ca, unsigned key_length) {
+    return generateIdentity(name, ca, key_length, !ca.first || !ca.second);
+}
+
+Certificate
+Certificate::generate(const PrivateKey& key, const std::string& name, Identity ca, bool is_ca)
+{
     gnutls_x509_crt_t cert;
-    if (gnutls_x509_crt_init(&cert) != GNUTLS_E_SUCCESS)
+    if (not key.x509_key or gnutls_x509_crt_init(&cert) != GNUTLS_E_SUCCESS)
         return {};
-    auto shared_crt = std::make_shared<Certificate>(cert);
+    Certificate ret {cert};
 
     gnutls_x509_crt_set_activation_time(cert, time(NULL));
-    gnutls_x509_crt_set_expiration_time(cert, time(NULL) + (5 * 365 * 24 * 60 * 60));
-    if (gnutls_x509_crt_set_key(cert, shared_key->x509_key) != GNUTLS_E_SUCCESS) {
+    gnutls_x509_crt_set_expiration_time(cert, time(NULL) + (20 * 365 * 24 * 60 * 60));
+    if (gnutls_x509_crt_set_key(cert, key.x509_key) != GNUTLS_E_SUCCESS) {
         std::cerr << "Error when setting certificate key" << std::endl;
         return {};
     }
@@ -722,7 +794,7 @@ generateIdentity(const std::string& name, crypto::Identity ca, unsigned key_leng
     }
 
     // TODO: compute the subject key using the recommended RFC method
-    auto pk_id = shared_key->getPublicKey().getId();
+    auto pk_id = key.getPublicKey().getId();
     const std::string uid_str = pk_id.toString();
 
     gnutls_x509_crt_set_subject_key_id(cert, &pk_id, sizeof(pk_id));
@@ -736,31 +808,30 @@ generateIdentity(const std::string& name, crypto::Identity ca, unsigned key_leng
         gnutls_x509_crt_set_serial(cert, &cert_serial, sizeof(cert_serial));
     }
 
+    unsigned key_usage = GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_DATA_ENCIPHERMENT;
+    if (is_ca) {
+        gnutls_x509_crt_set_ca_status(cert, 1);
+        key_usage |= GNUTLS_KEY_KEY_CERT_SIGN | GNUTLS_KEY_CRL_SIGN;
+    }
+    gnutls_x509_crt_set_key_usage(cert, key_usage);
+
     if (ca.first && ca.second) {
-        gnutls_x509_crt_set_key_usage (cert, GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_DATA_ENCIPHERMENT);
         //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;
             return {};
         }
-        shared_crt->issuer = ca.second;
+        ret.issuer = ca.second;
     } else {
-        gnutls_x509_crt_set_ca_status(cert, 1);
-        gnutls_x509_crt_set_key_usage (cert, GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_CERT_SIGN);
         //if (gnutls_x509_crt_sign2(cert, cert, key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
-        if (gnutls_x509_crt_privkey_sign(cert, cert, shared_key->key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
+        if (gnutls_x509_crt_privkey_sign(cert, cert, key.key, get_dig(cert), 0) != GNUTLS_E_SUCCESS) {
             std::cerr << "Error when signing certificate" << std::endl;
             return {};
         }
     }
 
-#if GNUTLS_VERSION_NUMBER < 0x030300
-    gnutls_global_deinit();
-#endif
-
-    return {shared_key, shared_crt};
+    return ret;
 }
 
 }
-
 }

src/default_types.cpp

@@ -83,8 +83,8 @@ IpServiceAnnouncement::storePolicy(InfoHash h, std::shared_ptr<Value>& v, InfoHa
     return false;
 }
 
-const ValueType DhtMessage::TYPE = {1, "DHT message", std::chrono::minutes(5), DhtMessage::storePolicy, ValueType::DEFAULT_EDIT_POLICY};
-const ValueType IpServiceAnnouncement::TYPE = {2, "Internet Service Announcement", std::chrono::minutes(15), IpServiceAnnouncement::storePolicy, ValueType::DEFAULT_EDIT_POLICY};
+const ValueType DhtMessage::TYPE(1, "DHT message", std::chrono::minutes(5), DhtMessage::storePolicy);
+const ValueType IpServiceAnnouncement::TYPE(2, "Internet Service Announcement", std::chrono::minutes(15), IpServiceAnnouncement::storePolicy);
 const ValueType ImMessage::TYPE = {3, "IM message", std::chrono::minutes(5)};
 const ValueType TrustRequest::TYPE = {4, "Certificate trust request", std::chrono::hours(24*7)};
 const ValueType IceCandidates::TYPE = {5, "ICE candidates", std::chrono::minutes(5)};

src/dhtrunner.cpp

@@ -19,8 +19,13 @@
  */
 
 #include "dhtrunner.h"
+#include "securedht.h"
 
-#include <unistd.h> // close(fd)
+#ifndef _WIN32
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
 
 #ifndef _WIN32
 #include <sys/socket.h>
@@ -32,7 +37,7 @@
 
 namespace dht {
 
-DhtRunner::DhtRunner()
+DhtRunner::DhtRunner() : dht_()
 {
 #ifdef _WIN32
     WSADATA wsd;
@@ -99,7 +104,7 @@ DhtRunner::run(const sockaddr_in* local4, const sockaddr_in6* local6, DhtRunner:
                     std::lock_guard<std::mutex> lck(storage_mtx);
                     if (not pending_ops_prio.empty())
                         return true;
-                    if (not pending_ops.empty() and getStatus() >= Dht::Status::Connecting)
+                    if (not pending_ops.empty() and getStatus() >= NodeStatus::Connecting)
                         return true;
                 }
                 return false;
@@ -109,7 +114,7 @@ DhtRunner::run(const sockaddr_in* local4, const sockaddr_in6* local6, DhtRunner:
 }
 
 void
-DhtRunner::shutdown(Dht::ShutdownCallback cb) {
+DhtRunner::shutdown(ShutdownCallback cb) {
     std::lock_guard<std::mutex> lck(storage_mtx);
     pending_ops_prio.emplace([=](SecureDht& dht) mutable {
         dht.shutdown(cb);
@@ -134,13 +139,145 @@ DhtRunner::join()
     {
         std::lock_guard<std::mutex> lck(dht_mtx);
         dht_.reset();
-        status4 = Dht::Status::Disconnected;
-        status6 = Dht::Status::Disconnected;
+        status4 = NodeStatus::Disconnected;
+        status6 = NodeStatus::Disconnected;
         bound4 = {};
         bound6 = {};
     }
 }
 
+void
+DhtRunner::dumpTables() const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->dumpTables();
+}
+
+InfoHash
+DhtRunner::getId() const
+{
+    if (!dht_)
+        return {};
+    return dht_->getId();
+}
+
+InfoHash
+DhtRunner::getNodeId() const
+{
+    if (!dht_)
+        return {};
+    return dht_->getNodeId();
+}
+
+
+std::pair<size_t, size_t>
+DhtRunner::getStoreSize() const {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (!dht_)
+        return {};
+    return dht_->getStoreSize();
+}
+
+void
+DhtRunner::setStorageLimit(size_t limit) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (!dht_)
+        throw std::runtime_error("dht is not running");
+    return dht_->setStorageLimit(limit);
+}
+
+std::vector<NodeExport>
+DhtRunner::exportNodes() const {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (!dht_)
+        return {};
+    return dht_->exportNodes();
+}
+
+std::vector<ValuesExport>
+DhtRunner::exportValues() const {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    if (!dht_)
+        return {};
+    return dht_->exportValues();
+}
+
+void
+DhtRunner::setLoggers(LogMethod error, LogMethod warn, LogMethod debug) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->setLoggers(std::forward<LogMethod>(error), std::forward<LogMethod>(warn), std::forward<LogMethod>(debug));
+}
+
+void
+DhtRunner::registerType(const ValueType& type) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->registerType(type);
+}
+
+void
+DhtRunner::importValues(const std::vector<ValuesExport>& values) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->importValues(values);
+}
+
+int
+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);
+}
+
+std::vector<unsigned>
+DhtRunner::getNodeMessageStats(bool in) const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getNodeMessageStats(in);
+}
+
+std::string
+DhtRunner::getStorageLog() const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getStorageLog();
+}
+std::string
+DhtRunner::getRoutingTablesLog(sa_family_t af) const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getRoutingTablesLog(af);
+}
+std::string
+DhtRunner::getSearchesLog(sa_family_t af) const
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getSearchesLog(af);
+}
+std::vector<Address>
+DhtRunner::getPublicAddress(sa_family_t af)
+{
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    return dht_->getPublicAddress(af);
+}
+std::vector<std::string>
+DhtRunner::getPublicAddressStr(sa_family_t af)
+{
+    auto addrs = getPublicAddress(af);
+    std::vector<std::string> ret(addrs.size());
+    std::transform(addrs.begin(), addrs.end(), ret.begin(), dht::printAddr);
+    return ret;
+}
+
+void
+DhtRunner::registerCertificate(std::shared_ptr<crypto::Certificate> cert) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->registerCertificate(cert);
+}
+void
+DhtRunner::setLocalCertificateStore(CertificateStoreQuery&& query_method) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+    dht_->setLocalCertificateStore(std::forward<CertificateStoreQuery>(query_method));
+}
+
 time_point
 DhtRunner::loop_()
 {
@@ -156,7 +293,7 @@ DhtRunner::loop_()
         ops.front()(*dht_);
         ops.pop();
     }
-    if (getStatus() >= Dht::Status::Connecting) {
+    if (getStatus() >= NodeStatus::Connecting) {
         {
             std::lock_guard<std::mutex> lck(storage_mtx);
             ops = std::move(pending_ops);
@@ -185,8 +322,8 @@ DhtRunner::loop_()
         wakeup = dht_->periodic(nullptr, 0, nullptr, 0);
     }
 
-    Dht::Status nstatus4 = dht_->getStatus(AF_INET);
-    Dht::Status nstatus6 = dht_->getStatus(AF_INET6);
+    NodeStatus nstatus4 = dht_->getStatus(AF_INET);
+    NodeStatus nstatus6 = dht_->getStatus(AF_INET6);
     if (nstatus4 != status4 || nstatus6 != status6) {
         status4 = nstatus4;
         status6 = nstatus6;
@@ -241,11 +378,7 @@ DhtRunner::doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDht::C
     rcv_thread = std::thread([this,s4,s6]() {
         try {
             while (true) {
-                std::array<uint8_t, 1024 * 64> buf;
-                sockaddr_storage from;
-                socklen_t fromlen;
-
-                struct timeval tv {.tv_sec = 0, .tv_usec = 250000};
+                struct timeval tv {/*.tv_sec = */0, /*.tv_usec = */250000};
                 fd_set readfds;
 
                 FD_ZERO(&readfds);
@@ -266,7 +399,10 @@ DhtRunner::doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDht::C
                     break;
 
                 if(rc > 0) {
-                    fromlen = sizeof(from);
+                    std::array<uint8_t, 1024 * 64> buf;
+                    sockaddr_storage from;
+                    socklen_t fromlen {sizeof(from)};
+
                     if(s4 >= 0 && FD_ISSET(s4, &readfds))
                         rc = recvfrom(s4, (char*)buf.data(), buf.size(), 0, (struct sockaddr*)&from, &fromlen);
                     else if(s6 >= 0 && FD_ISSET(s6, &readfds))
@@ -293,7 +429,7 @@ DhtRunner::doRun(const sockaddr_in* sin4, const sockaddr_in6* sin6, SecureDht::C
 }
 
 void
-DhtRunner::get(InfoHash hash, Dht::GetCallback vcb, Dht::DoneCallback dcb, Value::Filter f)
+DhtRunner::get(InfoHash hash, GetCallback vcb, DoneCallback dcb, Value::Filter f)
 {
     std::lock_guard<std::mutex> lck(storage_mtx);
     pending_ops.emplace([=](SecureDht& dht) mutable {
@@ -303,13 +439,13 @@ DhtRunner::get(InfoHash hash, Dht::GetCallback vcb, Dht::DoneCallback dcb, Value
 }
 
 void
-DhtRunner::get(const std::string& key, Dht::GetCallback vcb, Dht::DoneCallbackSimple dcb, Value::Filter f)
+DhtRunner::get(const std::string& key, GetCallback vcb, DoneCallbackSimple dcb, Value::Filter f)
 {
     get(InfoHash::get(key), vcb, dcb, f);
 }
 
 std::future<size_t>
-DhtRunner::listen(InfoHash hash, Dht::GetCallback vcb, Value::Filter f)
+DhtRunner::listen(InfoHash hash, GetCallback vcb, Value::Filter f)
 {
     std::lock_guard<std::mutex> lck(storage_mtx);
     auto ret_token = std::make_shared<std::promise<size_t>>();
@@ -321,7 +457,7 @@ DhtRunner::listen(InfoHash hash, Dht::GetCallback vcb, Value::Filter f)
 }
 
 std::future<size_t>
-DhtRunner::listen(const std::string& key, Dht::GetCallback vcb, Value::Filter f)
+DhtRunner::listen(const std::string& key, GetCallback vcb, Value::Filter f)
 {
     return listen(InfoHash::get(key), vcb, f);
 }
@@ -348,30 +484,30 @@ DhtRunner::cancelListen(InfoHash h, std::shared_future<size_t> token)
 }
 
 void
-DhtRunner::put(InfoHash hash, Value&& value, Dht::DoneCallback cb)
+DhtRunner::put(InfoHash hash, Value&& value, DoneCallback cb, bool permanent)
 {
     std::lock_guard<std::mutex> lck(storage_mtx);
     auto sv = std::make_shared<Value>(std::move(value));
     pending_ops.emplace([=](SecureDht& dht) {
-        dht.put(hash, sv, cb);
+        dht.put(hash, sv, cb, {}, permanent);
     });
     cv.notify_all();
 }
 
 void
-DhtRunner::put(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallback cb)
+DhtRunner::put(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb, bool permanent)
 {
     std::lock_guard<std::mutex> lck(storage_mtx);
     pending_ops.emplace([=](SecureDht& dht) {
-        dht.put(hash, value, cb);
+        dht.put(hash, value, cb, {}, permanent);
     });
     cv.notify_all();
 }
 
 void
-DhtRunner::put(const std::string& key, Value&& value, Dht::DoneCallbackSimple cb)
+DhtRunner::put(const std::string& key, Value&& value, DoneCallbackSimple cb, bool permanent)
 {
-    put(InfoHash::get(key), std::forward<Value>(value), cb);
+    put(InfoHash::get(key), std::forward<Value>(value), cb, permanent);
 }
 
 void
@@ -385,7 +521,7 @@ DhtRunner::cancelPut(const InfoHash& h , const Value::Id& id)
 }
 
 void
-DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallback cb)
+DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, DoneCallback cb)
 {
     std::lock_guard<std::mutex> lck(storage_mtx);
     pending_ops.emplace([=](SecureDht& dht) {
@@ -395,21 +531,21 @@ DhtRunner::putSigned(InfoHash hash, std::shared_ptr<Value> value, Dht::DoneCallb
 }
 
 void
-DhtRunner::putSigned(InfoHash hash, Value&& value, Dht::DoneCallback cb)
+DhtRunner::putSigned(InfoHash hash, Value&& value, DoneCallback cb)
 {
     putSigned(hash, std::make_shared<Value>(std::move(value)), cb);
 }
 
 void
-DhtRunner::putSigned(const std::string& key, Value&& value, Dht::DoneCallbackSimple cb)
+DhtRunner::putSigned(const std::string& key, Value&& value, DoneCallbackSimple cb)
 {
     putSigned(InfoHash::get(key), std::forward<Value>(value), cb);
 }
 
 void
-DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, Dht::DoneCallback cb)
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value, DoneCallback cb)
 {
-    std::lock_guard<std::mutex> lck(storage_mtx);    
+    std::lock_guard<std::mutex> lck(storage_mtx);
     pending_ops.emplace([=](SecureDht& dht) {
         dht.putEncrypted(hash, to, value, cb);
     });
@@ -417,13 +553,13 @@ DhtRunner::putEncrypted(InfoHash hash, InfoHash to, std::shared_ptr<Value> value
 }
 
 void
-DhtRunner::putEncrypted(InfoHash hash, InfoHash to, Value&& value, Dht::DoneCallback cb)
+DhtRunner::putEncrypted(InfoHash hash, InfoHash to, Value&& value, DoneCallback cb)
 {
     putEncrypted(hash, to, std::make_shared<Value>(std::move(value)), cb);
 }
 
 void
-DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, Dht::DoneCallback cb)
+DhtRunner::putEncrypted(const std::string& key, InfoHash to, Value&& value, DoneCallback cb)
 {
     putEncrypted(InfoHash::get(key), to, std::forward<Value>(value), cb);
 }

src/infohash.cpp

@@ -65,7 +65,11 @@ InfoHash::getRandom()
 {
     InfoHash h;
     crypto::random_device rdev;
-    std::uniform_int_distribution<uint8_t> rand_byte;
+#ifdef _WIN32
+    static std::uniform_int_distribution<int> rand_byte{ 0, std::numeric_limits<uint8_t>::max() };
+#else
+    static std::uniform_int_distribution<uint8_t> rand_byte;
+#endif
     std::generate(h.begin(), h.end(), std::bind(rand_byte, std::ref(rdev)));
     return h;
 }

src/node.cpp

@@ -0,0 +1,126 @@
+/*
+ *  Copyright (C) 2014-2016 Savoir-faire Linux Inc.
+ *  Author(s) : Adrien Béraud <adrien.beraud@savoirfairelinux.com>
+ *              Simon Désaulniers <sim.desaulniers@gmail.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 "node.h"
+#include "request.h"
+
+#include <sstream>
+
+namespace dht {
+
+constexpr std::chrono::minutes Node::NODE_EXPIRE_TIME;
+constexpr std::chrono::minutes Node::NODE_GOOD_TIME;
+constexpr std::chrono::seconds Node::MAX_RESPONSE_TIME;
+
+/* This is our definition of a known-good node. */
+bool
+Node::isGood(time_point now) const
+{
+    return not expired_ &&
+        reply_time >= now - NODE_GOOD_TIME &&
+        time >= now - NODE_EXPIRE_TIME;
+}
+
+bool
+Node::isPendingMessage() const
+{
+    for (auto w : requests_) {
+        if (auto r = w.lock()) {
+            if (r->pending())
+                return true;
+        }
+    }
+    return false;
+}
+
+size_t
+Node::getPendingMessageCount() const
+{
+    size_t count {0};
+    for (auto w : requests_) {
+        if (auto r = w.lock()) {
+            if (r->pending())
+                count++;
+        }
+    }
+    return count;
+}
+
+void
+Node::update(const sockaddr* sa, socklen_t salen)
+{
+    std::copy_n((const uint8_t*)sa, salen, (uint8_t*)&ss);
+    sslen = salen;
+}
+
+/** To be called when a message was sent to the node */
+void
+Node::requested(std::shared_ptr<Request>& req)
+{
+    requests_.emplace_back(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)
+{
+    time = now;
+    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)
+                it = requests_.erase(it);
+            else
+                ++it;
+        }
+    }
+}
+
+void
+Node::setExpired()
+{
+    expired_ = true;
+    for (auto w : requests_) {
+        if (auto r = w.lock())
+            r->setExpired();
+    }
+    requests_.clear();
+}
+
+
+std::string
+Node::toString() const
+{
+    std::stringstream ss;
+    ss << (*this);
+    return ss.str();
+}
+
+std::ostream& operator<< (std::ostream& s, const Node& h)
+{
+    s << h.id << " " << print_addr(h.ss, h.sslen);
+    return s;
+}
+
+}

src/node_cache.cpp

@@ -0,0 +1,85 @@
+/*
+ *  Copyright (C) 2014-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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#include "node_cache.h"
+
+namespace dht {
+
+std::shared_ptr<Node>
+NodeCache::getNode(const InfoHash& id, sa_family_t family) {
+    return (family == AF_INET ? cache_4 : cache_6).getNode(id);
+}
+
+std::shared_ptr<Node>
+NodeCache::getNode(const InfoHash& id, const sockaddr* sa, socklen_t sa_len, time_point now, int confirm) {
+    if (id == zeroes)
+        return std::make_shared<Node>(id, sa, sa_len);
+    return (sa->sa_family == AF_INET ? cache_4 : cache_6).getNode(id, sa, sa_len, now, confirm);
+}
+
+void
+NodeCache::clearBadNodes(sa_family_t family)
+{
+    if (family == 0) {
+        clearBadNodes(AF_INET);
+        clearBadNodes(AF_INET6);
+    } else {
+        (family == AF_INET ? cache_4 : cache_6).clearBadNodes();
+    }
+}
+
+std::shared_ptr<Node>
+NodeCache::NodeMap::getNode(const InfoHash& id)
+{
+    auto wn = find(id);
+    if (wn == end())
+        return {};
+    if (auto n = wn->second.lock())
+        return n;
+    erase(wn);
+    return {};
+}
+
+std::shared_ptr<Node>
+NodeCache::NodeMap::getNode(const InfoHash& id, const sockaddr* sa, socklen_t sa_len, time_point now, int confirm)
+{
+    auto it = emplace(id, std::weak_ptr<Node>{});
+    auto node = it.first->second.lock();
+    if (not node) {
+        node = std::make_shared<Node>(id, sa, sa_len);
+        it.first->second = node;
+    } else if (confirm || node->time < now - Node::NODE_EXPIRE_TIME) {
+        node->update(sa, sa_len);
+    }
+    return node;
+}
+
+void
+NodeCache::NodeMap::clearBadNodes() {
+    for (auto it = cbegin(); it != cend();) {
+        if (auto n = it->second.lock()) {
+            n->reset();
+            ++it;
+        } else {
+            erase(it++);
+        }
+    }
+}
+
+}

src/routing_table.cpp

@@ -0,0 +1,165 @@
+#include "routing_table.h"
+#include "rng.h"
+
+#include <memory>
+
+namespace dht {
+
+static std::mt19937 rd{ dht::crypto::random_device{}() };
+#ifdef _WIN32
+static std::uniform_int_distribution<int> rand_byte{ 0, std::numeric_limits<uint8_t>::max() };
+#else
+static std::uniform_int_distribution<uint8_t> rand_byte;
+#endif
+
+std::shared_ptr<Node>
+Bucket::randomNode()
+{
+    if (nodes.empty())
+        return nullptr;
+    std::uniform_int_distribution<unsigned> rand_node(0, nodes.size()-1);
+    unsigned nn = rand_node(rd);
+    for (auto& n : nodes)
+        if (not nn--) return n;
+    return nodes.back();
+}
+
+InfoHash
+RoutingTable::randomId(const RoutingTable::const_iterator& it) const
+{
+    int bit1 = it->first.lowbit();
+    int bit2 = std::next(it) != end() ? std::next(it)->first.lowbit() : -1;
+    int bit = std::max(bit1, bit2) + 1;
+
+    if (bit >= 8*(int)HASH_LEN)
+        return it->first;
+
+    int b = bit/8;
+    InfoHash id_return;
+    std::copy_n(it->first.begin(), b, id_return.begin());
+    id_return[b] = it->first[b] & (0xFF00 >> (bit % 8));
+    id_return[b] |= rand_byte(rd) >> (bit % 8);
+    for (unsigned i = b + 1; i < HASH_LEN; i++)
+        id_return[i] = rand_byte(rd);
+    return id_return;
+}
+
+InfoHash
+RoutingTable::middle(const RoutingTable::const_iterator& it) const
+{
+    unsigned bit = depth(it);
+    if (bit >= 8*HASH_LEN)
+        throw std::out_of_range("End of table");
+
+    InfoHash id = it->first;
+    id.setBit(bit, 1);
+    return id;
+}
+
+unsigned
+RoutingTable::depth(const RoutingTable::const_iterator& it) const
+{
+    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>>
+RoutingTable::findClosestNodes(const InfoHash id, time_point now, size_t count) const
+{
+    std::vector<std::shared_ptr<Node>> nodes {};
+    auto bucket = findBucket(id);
+
+    if (bucket == end()) { return nodes; }
+
+    auto sortedBucketInsert = [&](const Bucket &b) {
+        for (auto n : b.nodes) {
+            if (not n->isGood(now))
+                continue;
+
+            auto here = std::find_if(nodes.begin(), nodes.end(),
+                [&id,&n](std::shared_ptr<Node> &node) {
+                    return id.xorCmp(n->id, node->id) < 0;
+                }
+            );
+            nodes.insert(here, n);
+        }
+    };
+
+    auto itn = bucket;
+    auto itp = std::prev(bucket);
+    while (nodes.size() < count && (itn != end() || itp != end())) {
+        if (itn != end()) {
+            sortedBucketInsert(*itn);
+            itn = std::next(itn);
+        }
+        if (itp != end()) {
+            sortedBucketInsert(*itp);
+            if (itp == begin()) {
+                itp = end();
+                continue;
+            }
+            itp = std::prev(itp);
+        }
+    }
+
+    // shrink to the count closest nodes.
+    if (nodes.size() > count) {
+        nodes.resize(count);
+    }
+    return nodes;
+}
+
+RoutingTable::iterator
+RoutingTable::findBucket(const InfoHash& id)
+{
+    if (empty())
+        return end();
+    auto b = begin();
+    while (true) {
+        auto next = std::next(b);
+        if (next == end())
+            return b;
+        if (InfoHash::cmp(id, next->first) < 0)
+            return b;
+        b = next;
+    }
+}
+
+RoutingTable::const_iterator
+RoutingTable::findBucket(const InfoHash& id) const
+{
+    /* Avoid code duplication for the const version */
+    const_iterator it = const_cast<RoutingTable*>(this)->findBucket(id);
+    return it;
+}
+
+/* Split a bucket into two equal parts. */
+bool
+RoutingTable::split(const RoutingTable::iterator& b)
+{
+    InfoHash new_id;
+    try {
+        new_id = middle(b);
+    } catch (const std::out_of_range& e) {
+        return false;
+    }
+
+    // Insert new bucket
+    insert(std::next(b), Bucket {b->af, new_id, b->time});
+
+    // Re-assign nodes
+    std::list<std::shared_ptr<Node>> nodes {};
+    nodes.splice(nodes.begin(), b->nodes);
+    while (!nodes.empty()) {
+        auto n = nodes.begin();
+        auto b = findBucket((*n)->id);
+        if (b == end())
+            nodes.erase(n);
+        else
+            b->nodes.splice(b->nodes.begin(), nodes, n);
+    }
+    return true;
+}
+
+}

src/securedht.cpp

@@ -32,7 +32,7 @@ extern "C" {
 
 namespace dht {
 
-Dht::Config& getConfig(SecureDht::Config& conf)
+Config& getConfig(SecureDht::Config& conf)
 {
     auto& c = conf.node_config;
     if (c.node_id == InfoHash()) {
@@ -75,10 +75,10 @@ SecureDht::SecureDht(int s, int s6, SecureDht::Config conf)
             1
         }, [this](bool ok) {
             if (ok)
-                DHT_DEBUG("SecureDht: public key announced successfully");
+                DHT_LOG.DEBUG("SecureDht: public key announced successfully");
             else
-                DHT_ERROR("SecureDht: error while announcing public key!");
-        });
+                DHT_LOG.ERR("SecureDht: error while announcing public key!");
+        }, {}, true);
     }
 }
 
@@ -94,12 +94,12 @@ SecureDht::secureType(ValueType&& type)
 {
     type.storePolicy = [this,type](InfoHash id, std::shared_ptr<Value>& v, InfoHash nid, const sockaddr* a, socklen_t al) {
         if (v->isSigned()) {
-            if (!v->owner.checkSignature(v->getToSign(), v->signature)) {
-                DHT_WARN("Signature verification failed");
+            if (!v->owner or !v->owner->checkSignature(v->getToSign(), v->signature)) {
+                DHT_LOG.WARN("Signature verification failed");
                 return false;
             }
             else
-                DHT_WARN("Signature verification succeded");
+                DHT_LOG.WARN("Signature verification succeded");
         }
         return type.storePolicy(id, v, nid, a, al);
     };
@@ -107,18 +107,18 @@ SecureDht::secureType(ValueType&& type)
         if (!o->isSigned())
             return type.editPolicy(id, o, n, nid, a, al);
         if (o->owner != n->owner) {
-            DHT_WARN("Edition forbidden: owner changed.");
+            DHT_LOG.WARN("Edition forbidden: owner changed.");
             return false;
         }
-        if (!o->owner.checkSignature(n->getToSign(), n->signature)) {
-            DHT_WARN("Edition forbidden: signature verification failed.");
+        if (!o->owner or !o->owner->checkSignature(n->getToSign(), n->signature)) {
+            DHT_LOG.WARN("Edition forbidden: signature verification failed.");
             return false;
         }
         if (o->seq == n->seq) {
             // If the data is exactly the same,
             // it can be reannounced, possibly by someone else.
             if (o->getToSign() != n->getToSign()) {
-                DHT_WARN("Edition forbidden: sequence number must be increasing.");
+                DHT_LOG.WARN("Edition forbidden: sequence number must be increasing.");
                 return false;
             }
         }
@@ -141,6 +141,18 @@ SecureDht::getCertificate(const InfoHash& node) const
         return it->second;
 }
 
+const std::shared_ptr<const crypto::PublicKey>
+SecureDht::getPublicKey(const InfoHash& node) const
+{
+    if (node == getId())
+        return std::make_shared<crypto::PublicKey>(certificate_->getPublicKey());
+    auto it = nodesPubKeys_.find(node);
+    if (it == nodesPubKeys_.end())
+        return nullptr;
+    else
+        return it->second;
+}
+
 const std::shared_ptr<crypto::Certificate>
 SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
 {
@@ -152,7 +164,7 @@ SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
     }
     InfoHash h = crt->getPublicKey().getId();
     if (node == h) {
-        DHT_DEBUG("Registering public key for %s", h.toString().c_str());
+        DHT_LOG.DEBUG("Registering certificate for %s", h.toString().c_str());
         auto it = nodesCertificates_.find(h);
         if (it == nodesCertificates_.end())
             std::tie(it, std::ignore) = nodesCertificates_.emplace(h, std::move(crt));
@@ -160,7 +172,7 @@ SecureDht::registerCertificate(const InfoHash& node, const Blob& data)
             it->second = std::move(crt);
         return it->second;
     } else {
-        DHT_DEBUG("Certificate %s for node %s does not match node id !", h.toString().c_str(), node.toString().c_str());
+        DHT_LOG.DEBUG("Certificate %s for node %s does not match node id !", h.toString().c_str(), node.toString().c_str());
         return nullptr;
     }
 }
@@ -177,7 +189,7 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
 {
     std::shared_ptr<crypto::Certificate> b = getCertificate(node);
     if (b && *b) {
-        DHT_DEBUG("Using public key from cache for %s", node.toString().c_str());
+        DHT_LOG.DEBUG("Using certificate from cache for %s", node.toString().c_str());
         if (cb)
             cb(b);
         return;
@@ -185,7 +197,7 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
     if (localQueryMethod_) {
         auto res = localQueryMethod_(node);
         if (not res.empty()) {
-            DHT_DEBUG("Registering public key from local store for %s", node.toString().c_str());
+            DHT_LOG.DEBUG("Registering certificate from local store for %s", node.toString().c_str());
             nodesCertificates_.emplace(node, res.front());
             if (cb)
                 cb(res.front());
@@ -200,7 +212,7 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
         for (const auto& v : vals) {
             if (auto cert = registerCertificate(node, v->data)) {
                 *found = true;
-                DHT_DEBUG("Found public key for %s", node.toString().c_str());
+                DHT_LOG.DEBUG("Found certificate for %s", node.toString().c_str());
                 if (cb)
                     cb(cert);
                 return false;
@@ -213,8 +225,28 @@ SecureDht::findCertificate(const InfoHash& node, std::function<void(const std::s
     }, Value::TypeFilter(CERTIFICATE_TYPE));
 }
 
+void
+SecureDht::findPublicKey(const InfoHash& node, std::function<void(const std::shared_ptr<const crypto::PublicKey>)> cb)
+{
+    auto pk = getPublicKey(node);
+    if (pk && *pk) {
+        DHT_LOG.DEBUG("Found public key from cache for %s", node.toString().c_str());
+        if (cb)
+            cb(pk);
+        return;
+    }
+    findCertificate(node, [=](const std::shared_ptr<crypto::Certificate> crt) {
+        if (crt && *crt) {
+            auto pk = std::make_shared<crypto::PublicKey>(crt->getPublicKey());
+            nodesPubKeys_[pk->getId()] = pk;
+            if (cb) cb(pk);
+        } else {
+            if (cb) cb(nullptr);
+        }
+    });
+}
 
-Dht::GetCallback
+GetCallback
 SecureDht::getCallbackFilter(GetCallback cb, Value::Filter&& filter)
 {
     return [=](const std::vector<std::shared_ptr<Value>>& values) {
@@ -227,22 +259,24 @@ SecureDht::getCallbackFilter(GetCallback cb, Value::Filter&& filter)
                 try {
                     Value decrypted_val (decrypt(*v));
                     if (decrypted_val.recipient == getId()) {
+                        nodesPubKeys_[decrypted_val.owner->getId()] = decrypted_val.owner;
                         if (not filter or filter(decrypted_val))
                             tmpvals.push_back(std::make_shared<Value>(std::move(decrypted_val)));
                     }
                     // Ignore values belonging to other people
                 } catch (const std::exception& e) {
-                    DHT_WARN("Could not decrypt value %s : %s", v->toString().c_str(), e.what());
+                    DHT_LOG.WARN("Could not decrypt value %s : %s", v->toString().c_str(), e.what());
                 }
             }
             // Check signed values
             else if (v->isSigned()) {
-                if (v->owner.checkSignature(v->getToSign(), v->signature)) {
+                if (v->owner and v->owner->checkSignature(v->getToSign(), v->signature)) {
+                    nodesPubKeys_[v->owner->getId()] = v->owner;
                     if (not filter  or filter(*v))
                         tmpvals.push_back(v);
                 }
                 else
-                    DHT_WARN("Signature verification failed for %s", v->toString().c_str());
+                    DHT_LOG.WARN("Signature verification failed for %s", v->toString().c_str());
             }
             // Forward normal values
             else {
@@ -269,7 +303,7 @@ SecureDht::listen(const InfoHash& id, GetCallback cb, Value::Filter&& f)
 }
 
 void
-SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallback callback)
+SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallback callback, bool permanent)
 {
     if (val->id == Value::INVALID_ID) {
         crypto::random_device rdev;
@@ -279,46 +313,46 @@ SecureDht::putSigned(const InfoHash& hash, std::shared_ptr<Value> val, DoneCallb
     // Check if we are already announcing a value
     auto p = getPut(hash, val->id);
     if (p && val->seq <= p->seq) {
-        DHT_DEBUG("Found previous value being announced.");
+        DHT_LOG.DEBUG("Found previous value being announced.");
         val->seq = p->seq + 1;
     }
 
     // Check if data already exists on the dht
     get(hash,
         [val,this] (const std::vector<std::shared_ptr<Value>>& vals) {
-            DHT_DEBUG("Found online previous value being announced.");
+            DHT_LOG.DEBUG("Found online previous value being announced.");
             for (const auto& v : vals) {
                 if (!v->isSigned())
-                    DHT_ERROR("Existing non-signed value seems to exists at this location.");
-                else if (v->owner.getId() != getId())
-                    DHT_ERROR("Existing signed value belonging to someone else seems to exists at this location.");
+                    DHT_LOG.ERR("Existing non-signed value seems to exists at this location.");
+                else if (not v->owner or v->owner->getId() != getId())
+                    DHT_LOG.ERR("Existing signed value belonging to someone else seems to exists at this location.");
                 else if (val->seq <= v->seq)
                     val->seq = v->seq + 1;
             }
             return true;
         },
-        [hash,val,this,callback] (bool /* ok */) {
+        [hash,val,this,callback,permanent] (bool /* ok */) {
             sign(*val);
-            put(hash, val, callback);
+            put(hash, val, callback, {}, permanent);
         },
         Value::IdFilter(val->id)
     );
 }
 
 void
-SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, std::shared_ptr<Value> val, DoneCallback callback)
+SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, std::shared_ptr<Value> val, DoneCallback callback, bool permanent)
 {
-    findCertificate(to, [=](const std::shared_ptr<crypto::Certificate> crt) {
-        if(!crt || !*crt) {
+    findPublicKey(to, [=](const std::shared_ptr<const crypto::PublicKey> pk) {
+        if(!pk || !*pk) {
             if (callback)
                 callback(false, {});
             return;
         }
-        DHT_WARN("Encrypting data for PK: %s", crt->getPublicKey().getId().toString().c_str());
+        DHT_LOG.WARN("Encrypting data for PK: %s", pk->getId().toString().c_str());
         try {
-            put(hash, encrypt(*val, crt->getPublicKey()), callback);
+            put(hash, encrypt(*val, *pk), callback, {}, permanent);
         } catch (const std::exception& e) {
-            DHT_ERROR("Error putting encrypted data: %s", e.what());
+            DHT_LOG.ERR("Error putting encrypted data: %s", e.what());
             if (callback)
                 callback(false, {});
         }
@@ -328,22 +362,13 @@ SecureDht::putEncrypted(const InfoHash& hash, const InfoHash& to, std::shared_pt
 void
 SecureDht::sign(Value& v) const
 {
-    if (v.isEncrypted())
-        throw DhtException("Can't sign encrypted data.");
-    v.owner = key_->getPublicKey();
-    v.signature = key_->sign(v.getToSign());
+    v.sign(*key_);
 }
 
 Value
 SecureDht::encrypt(Value& v, const crypto::PublicKey& to) const
 {
-    if (v.isEncrypted())
-        throw DhtException("Data is already encrypted.");
-    v.setRecipient(to.getId());
-    sign(v);
-    Value nv {v.id};
-    nv.setCypher(to.encrypt(v.getToEncrypt()));
-    return nv;
+    return v.encrypt(*key_, to);
 }
 
 Value
@@ -360,7 +385,7 @@ SecureDht::decrypt(const Value& v)
 
     if (ret.recipient != getId())
         throw crypto::DecryptError("Recipient mismatch");
-    if (not ret.owner.checkSignature(ret.getToSign(), ret.signature))
+    if (not ret.owner or not ret.owner->checkSignature(ret.getToSign(), ret.signature))
         throw crypto::DecryptError("Signature mismatch");
 
     return ret;

src/utils.cpp

@@ -18,9 +18,39 @@
  */
 
 #include "utils.h"
+#include "default_types.h"
 
 namespace dht {
 
+std::string
+print_addr(const sockaddr* sa, socklen_t slen)
+{
+    char hbuf[NI_MAXHOST];
+    char sbuf[NI_MAXSERV];
+    std::stringstream out;
+    if (!getnameinfo(sa, slen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
+        if (sa->sa_family == AF_INET6)
+            out << "[" << hbuf << "]";
+        else
+            out << hbuf;
+        if (strcmp(sbuf, "0"))
+            out << ":" << sbuf;
+    } else
+        out << "[invalid address]";
+    return out.str();
+}
+
+std::string
+print_addr(const sockaddr_storage& ss, socklen_t sslen)
+{
+    return print_addr((const sockaddr*)&ss, sslen);
+}
+
+std::string
+printAddr(const Address& addr) {
+    return print_addr((const sockaddr*)&addr.first, addr.second);
+}
+
 time_point from_time_t(std::time_t t) {
     return clock::now() + (std::chrono::system_clock::from_time_t(t) - std::chrono::system_clock::now());
 }

src/value.cpp

@@ -142,7 +142,9 @@ Value::msgpack_unpack_body(const msgpack::object& o)
                 seq = rseq->as<decltype(seq)>();
             else
                 throw msgpack::type_error();
-            owner.msgpack_unpack(*rowner);
+            crypto::PublicKey new_owner;
+            new_owner.msgpack_unpack(*rowner);
+            owner = std::make_shared<const crypto::PublicKey>(std::move(new_owner));
             if (auto rrecipient = findMapValue(*rbody, "to")) {
                 recipient = rrecipient->as<InfoHash>();
             }

tools/CMakeLists.txt

@@ -3,12 +3,22 @@ add_executable (dhtnode dhtnode.cpp tools_common.h)
 add_executable (dhtscanner dhtscanner.cpp tools_common.h)
 add_executable (dhtchat dhtchat.cpp tools_common.h)
 
-target_link_libraries (dhtnode LINK_PUBLIC opendht gnutls readline)
-target_link_libraries (dhtscanner LINK_PUBLIC opendht gnutls readline)
-target_link_libraries (dhtchat LINK_PUBLIC opendht gnutls readline)
+target_link_libraries (dhtnode LINK_PUBLIC gnutls readline)
+target_link_libraries (dhtscanner LINK_PUBLIC gnutls readline)
+target_link_libraries (dhtchat LINK_PUBLIC gnutls readline)
+
+if (OPENDHT_SHARED)
+	target_link_libraries (dhtnode LINK_PUBLIC opendht)
+	target_link_libraries (dhtscanner LINK_PUBLIC opendht)
+	target_link_libraries (dhtchat LINK_PUBLIC opendht)
+else ()
+	target_link_libraries (dhtnode LINK_PUBLIC opendht-static)
+	target_link_libraries (dhtscanner LINK_PUBLIC opendht-static)
+	target_link_libraries (dhtchat LINK_PUBLIC opendht-static)
+endif ()
 
 if (NOT DEFINED CMAKE_INSTALL_BINDIR)
-	set(CMAKE_INSTALL_BINDIR bin)
+    set(CMAKE_INSTALL_BINDIR bin)
 endif ()
 
 install (TARGETS dhtnode dhtscanner dhtchat RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

tools/Makefile.am

@@ -3,10 +3,10 @@ bin_PROGRAMS = dhtnode dhtchat dhtscanner
 AM_CPPFLAGS = -I../include
 
 dhtnode_SOURCES = dhtnode.cpp
-dhtnode_LDFLAGS = -lopendht -lreadline -L../src/.libs @GNUTLS_LIBS@
+dhtnode_LDFLAGS = -lopendht -lreadline -L../src/.libs @GnuTLS_LIBS@
 
 dhtchat_SOURCES = dhtchat.cpp
-dhtchat_LDFLAGS = -lopendht -lreadline -L../src/.libs  @GNUTLS_LIBS@
+dhtchat_LDFLAGS = -lopendht -lreadline -L../src/.libs @GnuTLS_LIBS@
 
 dhtscanner_SOURCES = dhtscanner.cpp
-dhtscanner_LDFLAGS = -lopendht -lreadline -L../src/.libs  @GNUTLS_LIBS@
+dhtscanner_LDFLAGS = -lopendht -lreadline -L../src/.libs @GnuTLS_LIBS@

tools/dhtchat.cpp

@@ -38,7 +38,7 @@ const std::string printTime(const std::time_t& now) {
     return buf;
 }
 
-void print_node_info(const DhtRunner& dht, const dht_params& params) {
+void print_node_info(const DhtRunner& dht, const dht_params&) {
     std::cout << "OpenDht node " << dht.getNodeId() << " running on port " <<  dht.getBoundPort() << std::endl;
     std::cout << "Public key ID " << dht.getId() << std::endl;
 }

tools/dhtnode.cpp

@@ -137,9 +137,9 @@ void cmd_loop(DhtRunner& dht, dht_params& params)
         } else if (op == "log") {
             params.log = !params.log;
             if (params.log)
-                enableLogging(dht);
+                log::enableLogging(dht);
             else
-                disableLogging(dht);
+                log::disableLogging(dht);
             continue;
         }
 
@@ -172,7 +172,6 @@ void cmd_loop(DhtRunner& dht, dht_params& params)
             });
         }
         else if (op == "l") {
-            std::cout << id << std::endl;
             dht.listen(id, [](std::shared_ptr<Value> value) {
                 std::cout << "Listen: found value:" << std::endl;
                 std::cout << "\t" << *value << std::endl;
@@ -261,9 +260,9 @@ main(int argc, char **argv)
 
         if (params.log) {
             if (not params.logfile.empty())
-                enableFileLogging(dht, params.logfile);
+                log::enableFileLogging(dht, params.logfile);
             else
-                enableLogging(dht);
+                log::enableLogging(dht);
         }
 
         if (not params.bootstrap.first.empty()) {

tools/dhtscanner.cpp

@@ -19,6 +19,8 @@
  */
 
 #include "tools_common.h"
+#include <opendht/node.h>
+
 extern "C" {
 #include <gnutls/gnutls.h>
 }
@@ -30,7 +32,8 @@ using namespace dht;
 
 struct snode_compare {
     bool operator() (const std::shared_ptr<Node>& lhs, const std::shared_ptr<Node>& rhs) const{
-        return lhs->id < rhs->id;
+        return (lhs->id < rhs->id) ||
+            (lhs->id == rhs->id && lhs->getFamily() == AF_INET && rhs->getFamily() == AF_INET6);
     }
 };
 
@@ -77,7 +80,7 @@ main(int argc, char **argv)
     auto crt_tmp = dht::crypto::generateIdentity("Scanner node", ca_tmp);
 
     DhtRunner dht;
-    dht.run(params.port, crt_tmp, true, [](dht::Dht::Status /* ipv4 */, dht::Dht::Status /* ipv6 */) {});
+    dht.run(params.port, crt_tmp, true, [](dht::NodeStatus /* ipv4 */, dht::NodeStatus /* ipv6 */) {});
 
     if (not params.bootstrap.first.empty())
         dht.bootstrap(params.bootstrap.first.c_str(), params.bootstrap.second.c_str());

tools/tools_common.h

@@ -112,15 +112,6 @@ disableLogging(dht::DhtRunner& dht)
     dht.setLoggers(dht::NOLOG, dht::NOLOG, dht::NOLOG);
 }
 
-/**
- * Converts std::chrono::duration to floating-point seconds.
- */
-template <class DT>
-static double
-print_dt(DT d) {
-    return std::chrono::duration_cast<std::chrono::duration<double>>(d).count();
-}
-
 /**
  * Split "[host]:port" or "host:port" to pair<"host", "port">.
  */
@@ -198,7 +189,7 @@ parseArgs(int argc, char **argv) {
             break;
         case 'v':
             if (optarg)
-                params.logfile = {optarg};
+                params.logfile = optarg;
             params.log = true;
             break;
         case 'i':