Merge pull request #281 from anonimal/master

Catch exception in SSUServer that would dump core.

.dir-locals.el

@@ -1,2 +0,0 @@
-((c++-mode . ((indent-tabs-mode . t)))
- (c-mode . ((mode . c++))))

.gitignore

@@ -1,21 +1,32 @@
 # i2pd
-*.o
 router.info
 router.keys
 i2p
 libi2pd.so
 netDb
-/i2pd
-/libi2pd.a
-/libi2pdclient.a
-i2pd.exe
+tunnels.cfg
+tests/tests
+
+# Build files
+CMakeCache.txt
+build/CMakeFiles/*
+build/tests
+build/client
+build/core
+build/benchmark
+build/i2pd
+build/i2pd-tests
+build/i2pd-benchmark
+*.cmake
+*.a
+*.o
 
 
 # Autotools
 autom4te.cache
 .deps
 stamp-h1
-#Makefile
+Makefile
 config.h
 config.h.in~
 config.log
@@ -52,6 +63,14 @@ local.properties
 # PDT-specific
 .buildpath
 
+#################
+## Netbeans
+#################
+
+# CMake: if "Project with Existing Sources" is properly setup, then only the following needs to be ignored:
+# (e.g., don't select "Automatic" but instead select "Run Configure Script in Subfolder:" into ./build/)
+build/compile_commands.json
+nbproject/
 
 #################
 ## Visual Studio
@@ -235,32 +254,3 @@ pip-log.txt
 
 #Mr Developer
 .mr.developer.cfg
-
-# Sphinx
-docs/_build
-/androidIdea/
-
-# Doxygen
-docs/generated
-
-# emacs files
-*~
-*\#*
-
-# gdb files
-.gdb_history
-
-# cmake makefile
-build/Makefile
-
-# debian stuff
-.pc/
-
-# qt 
-
-qt/i2pd_qt/*.ui.autosave
-qt/i2pd_qt/*.ui.bk*
-qt/i2pd_qt/*.ui_*
-
-#unknown android stuff
-android/libs/

.travis.yml

@@ -1,54 +0,0 @@
-language: cpp
-cache:
-  apt: true
-os:
-- linux
-#- osx
-dist: trusty
-sudo: required
-compiler:
-- g++
-- clang++
-env:
-  global:
-  - MAKEFLAGS="-j 2"
-  matrix:
-  - BUILD_TYPE=make UPNP=ON MAKE_UPNP=yes
-  - BUILD_TYPE=make UPNP=OFF MAKE_UPNP=no
-  - BUILD_TYPE=cmake UPNP=ON MAKE_UPNP=yes
-  - BUILD_TYPE=cmake UPNP=OFF MAKE_UPNP=no
-matrix:
-  exclude:
-  - os: osx
-    env: BUILD_TYPE=cmake UPNP=ON MAKE_UPNP=yes
-  - os: osx
-    env: BUILD_TYPE=cmake UPNP=OFF MAKE_UPNP=no
-  - os: linux
-    compiler: clang++
-    env: BUILD_TYPE=make UPNP=ON MAKE_UPNP=yes
-  - os: linux
-    compiler: clang++
-    env: BUILD_TYPE=make UPNP=OFF MAKE_UPNP=no
-addons:
-  apt:
-    packages:
-    - build-essential
-    - cmake
-    - g++
-    - clang
-    - libboost-chrono-dev
-    - libboost-date-time-dev
-    - libboost-filesystem-dev
-    - libboost-program-options-dev
-    - libboost-system-dev
-    - libboost-thread-dev
-    - libminiupnpc-dev
-    - libssl-dev
-before_install:
-- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi
-- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libressl miniupnpc ; fi
-- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew outdated boost || brew upgrade boost ; fi
-script:
-- if [[ "$TRAVIS_OS_NAME" == "linux" && "$BUILD_TYPE" == "cmake" ]]; then cd build && cmake -DCMAKE_BUILD_TYPE=Release -DWITH_UPNP=${UPNP} && make ; fi
-- if [[ "$TRAVIS_OS_NAME" == "linux" && "$BUILD_TYPE" == "make" ]]; then make USE_UPNP=${MAKE_UPNP} ; fi
-- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then make HOMEBREW=1 USE_UPNP=${MAKE_UPNP} ; fi

CMakeLists.txt

@@ -0,0 +1,195 @@
+cmake_minimum_required ( VERSION 2.8.12 )
+project ( "i2pd" )
+
+# configurale options
+option(WITH_AESNI     "Use AES-NI instructions set" OFF)
+option(WITH_HARDENING "Use hardening compiler flags" OFF)
+option(WITH_LIBRARY   "Build library" ON)
+option(WITH_BINARY    "Build binary" ON)
+option(WITH_STATIC    "Static build" OFF)
+option(WITH_UPNP      "Include support for UPnP client" OFF)
+option(WITH_TESTS     "Build unit tests" OFF)
+option(WITH_BENCHMARK "Build benchmarking code" OFF)
+option(WITH_OPTIMIZE  "Optimization flags" OFF)
+option(I2PD_DATA_PATH "The path to the i2pd data folder")
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake_modules")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+
+# Default build is Debug
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+# compiler flags customization (by vendor)
+if(NOT MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Winvalid-pch")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -pedantic")
+    # TODO: The following is incompatible with static build and enabled hardening
+    #  for OpenWRT.
+    # Multiple definitions of __stack_chk_fail (libssp & libc)
+    set(
+        CMAKE_CXX_FLAGS_MINSIZEREL
+        "${CMAKE_CXX_FLAGS_MINSIZEREL} -flto -s -ffunction-sections -fdata-sections"
+    )
+    # -flto is added from above
+    set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "-Wl,--gc-sections")
+endif()
+
+# Check for c++11 support
+include(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11_SUPPORTED)
+CHECK_CXX_COMPILER_FLAG("-std=c++0x" CXX0X_SUPPORTED)
+if(CXX11_SUPPORTED)
+    add_definitions("-std=c++11")
+elseif(CXX0X_SUPPORTED) # gcc 4.6
+    add_definitions("-std=c++0x")
+elseif(NOT MSVC)
+    message(SEND_ERROR "C++11 standard not supported by compiler. Version too old?")
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(WITH_HARDENING)
+        add_definitions( "-D_FORTIFY_SOURCE=2" )
+        set(
+            CMAKE_CXX_FLAGS
+            "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security -Werror=format-security"
+        )
+        set(
+            CMAKE_CXX_FLAGS
+            "${CMAKE_CXX_FLAGS} -fstack-protector-strong -fPIE --param ssp-buffer-size=4 -z relro -z now"
+        )
+    endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    # TODO: Clang-specific flags 
+endif()
+
+# Compiler flags customization (by system)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+  # "'sleep_for' is not a member of 'std::this_thread'" in gcc 4.7/4.8
+  add_definitions( "-D_GLIBCXX_USE_NANOSLEEP=1" )
+endif ()
+
+if(WITH_UPNP)
+    add_definitions(-DUSE_UPNP)
+    if(NOT MSVC)
+        set(DL_LIB ${CMAKE_DL_LIBS})
+    endif()
+endif()
+
+if(WITH_AESNI)
+    add_definitions( "-maes -DAESNI")
+endif()
+
+if(WITH_OPTIMIZE AND (NOT MSVC))
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+endif()
+
+# Libraries
+# TODO: once CMake 3.1+ becomes mainstream, see e.g.
+#  http://stackoverflow.com/a/29871891/673826 use imported Threads::Threads
+#  instead
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package (Threads REQUIRED)
+if(THREADS_HAVE_PTHREAD_ARG) # compile time flag
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+endif()
+
+if(WITH_STATIC)
+    set(Boost_USE_STATIC_LIBS ON)
+    set(Boost_USE_STATIC_RUNTIME OFF)
+    if(NOT WIN32)
+        set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+    endif()
+
+    set(BUILD_SHARED_LIBS OFF)
+    if(${CMAKE_CXX_COMPILER} MATCHES ".*-openwrt-.*")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+        set(
+            CMAKE_THREAD_LIBS_INIT
+            "gcc_eh -Wl,-u,pthread_create,-u,pthread_once,-u,pthread_mutex_lock,-u,pthread_mutex_unlock,-u,pthread_join,-u,pthread_equal,-u,pthread_detach,-u,pthread_cond_wait,-u,pthread_cond_signal,-u,pthread_cond_destroy,-u,pthread_cond_broadcast,-u,pthread_cancel"
+        )
+    endif()
+elseif(NOT WIN32)
+    # TODO: Consider separate compilation for COMMON_SRC for library.
+    # No need in -fPIC overhead for binary if not interested in library
+    # HINT: revert c266cff CMakeLists.txt: compilation speed up
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+else() # Not a static build
+    add_definitions(-DBOOST_ALL_DYN_LINK)
+endif()
+
+find_package(
+    Boost COMPONENTS
+    system filesystem regex program_options date_time thread chrono REQUIRED
+)
+if(NOT DEFINED Boost_INCLUDE_DIRS)
+    message(SEND_ERROR "Boost not found, or version below 1.46. Please download Boost!")
+endif()
+
+find_package(CryptoPP REQUIRED)
+if(NOT DEFINED CRYPTO++_INCLUDE_DIR)
+  message(SEND_ERROR "Could not find Crypto++. Please download and install it first!")
+endif()
+
+find_package(MiniUPnPc)
+if(NOT ${MINIUPNPC_FOUND})
+    set(WITH_UPNP OFF)
+endif()
+
+# Load includes
+include_directories(
+    ${CMAKE_SOURCE_DIR} ${Boost_INCLUDE_DIRS} ${CRYPTO++_INCLUDE_DIR}
+    "core/"
+)
+
+if(I2PD_DATA_PATH)
+    set(I2PD_DATA_DIR ${I2PD_DATA_PATH})
+    # Using custom path, make sure the code knows about this
+    add_definitions(-DI2PD_CUSTOM_DATA_PATH="${I2PD_DATA_PATH}")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    set(I2PD_DATA_DIR "$ENV{APPDATA}\\i2pd")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    set(I2PD_DATA_DIR "$ENV{HOME}/Library/Application Support/i2pd")
+else()
+    set(I2PD_DATA_DIR "$ENV{HOME}/.i2pd")
+endif()
+
+# Show summary
+message(STATUS "---------------------------------------")
+message(STATUS "Build type         : ${CMAKE_BUILD_TYPE}")
+message(STATUS "Compiler vendor    : ${CMAKE_CXX_COMPILER_ID}")
+message(STATUS "Compiler version   : ${CMAKE_CXX_COMPILER_VERSION}")
+message(STATUS "Compiler path      : ${CMAKE_CXX_COMPILER}")
+message(STATUS "Install prefix:    : ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "I2PD data directory: ${I2PD_DATA_DIR}")
+message(STATUS "Options:")
+message(STATUS "  AESNI            : ${WITH_AESNI}")
+message(STATUS "  HARDENING        : ${WITH_HARDENING}")
+message(STATUS "  LIBRARY          : ${WITH_LIBRARY}")
+message(STATUS "  BINARY           : ${WITH_BINARY}")
+message(STATUS "  STATIC BUILD     : ${WITH_STATIC}")
+message(STATUS "  UPnP             : ${WITH_UPNP}")
+message(STATUS "  TESTS            : ${WITH_TESTS}")
+message(STATUS "  BENCHMARKING     : ${WITH_BENCHMARK}")
+message(STATUS "  OPTIMIZATION     : ${WITH_OPTIMIZE}")
+message(STATUS "---------------------------------------")
+
+# Handle paths nicely
+include(GNUInstallDirs)
+
+set(CORE_NAME "${PROJECT_NAME}-core")
+set(CLIENT_NAME "${PROJECT_NAME}-client")
+set(TESTS_NAME "${PROJECT_NAME}-tests")
+set(BENCHMARK_NAME "${PROJECT_NAME}-benchmark")
+add_subdirectory(core)
+add_subdirectory(client)
+add_subdirectory(tests)
+add_subdirectory(benchmark)
+
+if(WITH_BINARY)
+    file(MAKE_DIRECTORY "${I2PD_DATA_DIR}/webui")
+    file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/webui" DESTINATION "${I2PD_DATA_DIR}")
+endif()

ChangeLog

@@ -1,249 +0,0 @@
-# for this file format description,
-# see https://github.com/olivierlacan/keep-a-changelog
-
-## [2.18.0] - 2018-01-30
-### Added
-- Show tunnel nicknames for I2CP destination in WebUI
-- Re-create HTTP and SOCKS proxy by tunnel reload
-- Graceful shutdown as soon as no more transit tunnels
-### Changed
-- Regenerate shared local destination by tunnel reload
-- Use transient local destination by default if not specified
-- Return correct code if pid file can't be created
-- Timing and number of attempts for adressbook requests
-- Certificates list
-### Fixed
-- Malformed addressbook subsctiption request
-- Build with boost 1.66
-- Few race conditions for SAM
-- Check LeaseSet's signature before update
-
-## [2.17.0] - 2017-12-04
-### Added
-- Reseed through HTTP and SOCKS proxy
-- Show status of client services through web console
-- Change log level through web connsole
-- transient keys for tunnels
-- i2p.streaming.initialAckDelay parameter
-- CRYPTO_TYPE for SAM destination
-- signature and crypto type for newkeys BOB command
-### Changed
-- Correct publication of ECIES destinations
-- Disable RSA signatures completely
-### Fixed
-- CVE-2017-17066
-- Possible buffer overflow for RSA-4096
-- Shutdown from web console for Windows
-- Web console page layout
-## [2.16.0] - 2017-11-13
-### Added
-- https and "Connect" method for HTTP proxy
-- outproxy for HTTP proxy
-- initial support of ECIES crypto
-- NTCP soft and hard descriptors limits
-- Support full timestamps in logs
-### Changed
-- Faster implmentation of GOST R 34.11 hash
-- Reject routers with RSA signtures
-- Reload config and shudown from Windows GUI
-- Update tunnels address(destination) without restart
-### Fixed
-- BOB crashes if destination is not set
-- Correct SAM tunnel name
-- QT GUI issues
-
-## [2.15.0] - 2017-08-17
-### Added
-- QT GUI
-- Ability to add and remove I2P tunnels without restart
-- Ability to disable SOCKS outproxy option
-### Changed
-- Strip-out Accept-* hedaers in HTTP proxy
-- Don't run peer test if nat=false
-- Separate output of NTCP and SSU sessions in Transports tab
-### Fixed
-- Handle lines with comments in hosts.txt file for address book
-- Run router with empty netdb for testnet
-- Skip expired introducers by iexp
-
-## [2.14.0] - 2017-06-01
-### Added
-- Transit traffic bandwidth limitation
-- NTCP connections through HTTP and SOCKS proxies
-- Ability to disable address helper for HTTP proxy
-### Changed
-- Reseed servers list
-- Minimal required version is 4.0 for Android
-### Fixed
-- Ignore comments in addressbook feed
-
-## [2.13.0] - 2017-04-06
-### Added
-- Persist local destination's tags
-- GOST signature types 9 and 10
-- Exploratory tunnels configuration
-### Changed
-- Reseed servers list
-- Inactive NTCP sockets get closed faster
-- Some EdDSA speed up
-### Fixed
-- Multiple acceptors for SAM
-- Follow on data after STREAM CREATE for SAM
-- Memory leaks
-
-## [2.12.0] - 2017-02-14
-### Added
-- Additional HTTP and SOCKS proxy tunnels
-- Reseed from ZIP archive
-- Some stats in a main window for Windows version
-### Changed
-- Reseed servers list
-- MTU of 1488 for ipv6
-- Android and Mac OS X versions use OpenSSL 1.1
-- New logo for Android
-### Fixed
-- Multiple memory leaks
-- Incomptibility of some EdDSA private keys with Java
-- Clock skew for Windows XP
-- Occasional crashes with I2PSnark
-
-## [2.11.0] - 2016-12-18
-### Added
-- Websockets support
-- Reseed through a floodfill
-- Tunnel configuration for HTTP and SOCKS proxy
-- Zero-hops tunnels for destinations
-- Multiple acceptors for SAM
-### Changed
-- Reseed servers list
-- DHT uses AVX if applicable
-- New logo
-- LeaseSet lookups
-### Fixed
-- HTTP Proxy connection reset for Windows
-- Crash upon SAM session termination
-- Can't connect to a destination for a longer time after restart
-- Mass packet loss for UDP tunnels
-
-## [2.10.2] - 2016-12-04
-### Fixed
-- Fixes UPnP discovery bug, producing excessive CPU usage
-- Fixes sudden SSU thread stop for Windows.
-
-## [2.10.1] - 2016-11-07
-### Fixed
-- Fixed some performance issues for Windows and Android
-
-## [2.10.0] - 2016-10-17
-### Added
-- Datagram i2p tunnels
-- Unique local addresses for server tunnels
-- Configurable list of reseed servers  and initial addressbook
-- Configurable netid
-- Initial iOS support
-
-### Changed
-- Reduced file descriptiors usage
-- Strict reseed checks enabled by default
-
-## Fixed
-- Multiple fixes in I2CP and BOB implementations
-
-## [2.9.0] - 2016-08-12
-### Changed
-- Proxy refactoring & speedup
-- Transmission-I2P support
-- Graceful shutdown for Windows
-- Android without QT
-- Reduced number of timers in SSU
-- ipv6 peer test support
-- Reseed from SU3 file
-
-## [2.8.0] - 2016-06-20
-### Added
-- Basic Android support
-- I2CP implementation
-- 'doxygen' target
-
-### Changed
-- I2PControl refactoring & fixes (proper jsonrpc responses on errors)
-- boost::regex no more needed
-
-### Fixed
-- initscripts: added openrc one, in sysv-ish make I2PD_PORT optional
-- properly close NTCP sessions (memleak)
-
-## [2.7.0] - 2016-05-18
-### Added
-- Precomputed El-Gamal/DH tables
-- Configurable limit of transit tunnels
-
-### Changed
-- Speed-up of asymmetric crypto for non-x64 platforms
-- Refactoring of web-console
-
-## [2.6.0] - 2016-03-31
-### Added
-- Graceful shutdown on SIGINT
-- Numeric bandwidth limits (was: by router class)
-- Jumpservices in web-console
-- Logging to syslog
-- Tray icon for windows application
-
-### Changed
-- Logs refactoring
-- Improved statistics in web-console
-
-### Deprecated:
-- Renamed main/tunnels config files (will use old, if found, but emits warning)
-
-## [2.5.1] - 2016-03-10
-### Fixed
-- Doesn't create ~/.i2pd dir if missing
-
-## [2.5.0] - 2016-03-04
-### Added
-- IRC server tunnels
-- SOCKS outproxy support
-- Support for gzipped addressbook updates
-- Support for router families
-
-### Changed
-- Shared RTT/RTO between streams
-- Filesystem work refactoring
-
-## [2.4.0] - 2016-02-03
-### Added
-- X-I2P-* headers for server http-tunnels
-- I2CP options for I2P tunnels
-- Show I2P tunnels in webconsole
-
-### Changed
-- Refactoring of cmdline/config parsing
-
-## [2.3.0] - 2016-01-12
-### Added
-- Support for new router bandwidth class codes (P and X)
-- I2PControl supports external webui
-- Added --pidfile and --notransit parameters
-- Ability to specify signature type for i2p tunnel
-
-### Changed
-- Fixed multiple floodfill-related bugs
-- New webconsole layout
-
-## [2.2.0] - 2015-12-22
-### Added
-- Ability to connect to router without ip via introducer
-
-### Changed
-- Persist temporary encryption keys for local destinations
-- Performance improvements for EdDSA
-- New addressbook structure
-
-## [2.1.0] - 2015-11-12
-### Added
-- Implementation of EdDSA
-
-### Changed
-- EdDSA is default signature type for new RouterInfos

Dockerfile

@@ -1,54 +0,0 @@
-FROM alpine:latest
-
-MAINTAINER Mikal Villa <mikal@sigterm.no>
-
-ENV GIT_BRANCH="master"
-ENV I2PD_PREFIX="/opt/i2pd-${GIT_BRANCH}"
-ENV PATH=${I2PD_PREFIX}/bin:$PATH
-
-ENV GOSU_VERSION=1.7
-ENV GOSU_SHASUM="34049cfc713e8b74b90d6de49690fa601dc040021980812b2f1f691534be8a50  /usr/local/bin/gosu"
-
-RUN mkdir /user && adduser -S -h /user i2pd && chown -R i2pd:nobody /user
-
-
-#
-# Each RUN is a layer, adding the dependencies and building i2pd in one layer takes around 8-900Mb, so to keep the
-# image under 20mb we need to remove all the build dependencies in the same "RUN" / layer.
-#
-
-# 1. install deps, clone and build.
-# 2. strip binaries.
-# 3. Purge all dependencies and other unrelated packages, including build directory.
-RUN apk --no-cache --virtual build-dependendencies add make gcc g++ libtool boost-dev build-base openssl-dev openssl git \
-    && mkdir -p /tmp/build \
-    && cd /tmp/build && git clone -b ${GIT_BRANCH} https://github.com/PurpleI2P/i2pd.git \
-    && cd i2pd \
-    && make -j4 \
-    && mkdir -p ${I2PD_PREFIX}/bin \
-    && mv i2pd ${I2PD_PREFIX}/bin/ \
-    && cd ${I2PD_PREFIX}/bin \
-    && strip i2pd \
-    && rm -fr /tmp/build && apk --purge del build-dependendencies build-base fortify-headers boost-dev zlib-dev openssl-dev \
-    boost-python3 python3 gdbm boost-unit_test_framework boost-python linux-headers boost-prg_exec_monitor \
-    boost-serialization boost-signals boost-wave boost-wserialization boost-math boost-graph boost-regex git pcre \
-    libtool g++ gcc pkgconfig
-
-# 2. Adding required libraries to run i2pd to ensure it will run.
-RUN apk --no-cache add boost-filesystem boost-system boost-program_options boost-date_time boost-thread boost-iostreams openssl musl-utils libstdc++
-
-# Gosu is a replacement for su/sudo in docker and not a backdoor :) See https://github.com/tianon/gosu
-RUN wget -O /usr/local/bin/gosu https://github.com/tianon/gosu/releases/download/${GOSU_VERSION}/gosu-amd64 \
-    && echo "${GOSU_SHASUM}" | sha256sum -c && chmod +x /usr/local/bin/gosu
-
-COPY entrypoint.sh /entrypoint.sh
-
-RUN chmod a+x /entrypoint.sh
-RUN echo "export PATH=${PATH}" >> /etc/profile
-
-VOLUME [ "/var/lib/i2pd" ]
-
-EXPOSE 7070 4444 4447 7656 2827 7654 7650
-
-ENTRYPOINT [ "/entrypoint.sh" ]
-

Makefile

@@ -1,127 +0,0 @@
-SYS := $(shell $(CXX) -dumpmachine)
-SHLIB := libi2pd.so
-ARLIB := libi2pd.a
-SHLIB_CLIENT := libi2pdclient.so
-ARLIB_CLIENT := libi2pdclient.a
-I2PD := i2pd
-GREP := grep
-DEPS := obj/make.dep
-
-LIB_SRC_DIR := libi2pd
-LIB_CLIENT_SRC_DIR := libi2pd_client
-DAEMON_SRC_DIR := daemon
-
-include filelist.mk
-
-USE_AESNI	:= yes
-USE_AVX		:= yes
-USE_STATIC	:= no
-USE_MESHNET	:= no
-USE_UPNP	:= no
-
-ifeq ($(WEBSOCKETS),1)
-	NEEDED_CXXFLAGS += -DWITH_EVENTS
-endif
-
-ifneq (, $(findstring darwin, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	ifeq ($(HOMEBREW),1)
-		include Makefile.homebrew
-	else
-		include Makefile.osx
-	endif
-else ifneq (, $(findstring freebsd, $(SYS))$(findstring openbsd, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	include Makefile.bsd
-else ifneq (, $(findstring linux, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	include Makefile.linux
-else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
-	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32Service.cpp Win32/Win32App.cpp
-	include Makefile.mingw
-else # not supported
-$(error Not supported platform)
-endif
-
-ifeq ($(USE_MESHNET),yes)
-	NEEDED_CXXFLAGS += -DMESHNET
-endif
-
-NEEDED_CXXFLAGS += -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR)
-
-all: mk_obj_dir $(ARLIB) $(ARLIB_CLIENT) $(I2PD)
-
-mk_obj_dir:
-	@mkdir -p obj
-	@mkdir -p obj/Win32
-	@mkdir -p obj/$(LIB_SRC_DIR)
-	@mkdir -p obj/$(LIB_CLIENT_SRC_DIR)
-	@mkdir -p obj/$(DAEMON_SRC_DIR)
-
-api: mk_obj_dir $(SHLIB) $(ARLIB)
-api_client: mk_obj_dir $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
-
-## NOTE: The NEEDED_CXXFLAGS are here so that CXXFLAGS can be specified at build time
-## **without** overwriting the CXXFLAGS which we need in order to build.
-## For example, when adding 'hardening flags' to the build
-## (e.g. -fstack-protector-strong -Wformat -Werror=format-security), we do not want to remove
-## -std=c++11. If you want to remove this variable please do so in a way that allows setting
-## custom FLAGS to work at build-time.
-
-deps: mk_obj_dir
-	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) -MM *.cpp > $(DEPS)
-	@sed -i -e '/\.o:/ s/^/obj\//' $(DEPS)
-
-obj/%.o: %.cpp
-	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) $(INCFLAGS) $(CPU_FLAGS) -c -o $@ $<
-
-# '-' is 'ignore if missing' on first run
--include $(DEPS)
-
-DAEMON_OBJS += $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
-$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT)
-	$(CXX) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-$(SHLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
-endif
-
-$(SHLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
-	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
-
-$(ARLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
-	$(AR) -r $@ $^
-
-$(ARLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
-	$(AR) -r $@ $^
-
-clean:
-	$(RM) -r obj
-	$(RM) -r docs/generated
-	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
-
-strip: $(I2PD) $(SHLIB_CLIENT) $(SHLIB)
-	strip $^
-
-LATEST_TAG=$(shell git describe --tags --abbrev=0 openssl)
-BRANCH=$(shell git rev-parse --abbrev-ref HEAD)
-dist:
-	git archive --format=tar.gz -9 --worktree-attributes \
-	    --prefix=i2pd_$(LATEST_TAG)/ $(LATEST_TAG) -o i2pd_$(LATEST_TAG).tar.gz
-
-last-dist:
-	git archive --format=tar.gz -9 --worktree-attributes \
-	    --prefix=i2pd_$(LATEST_TAG)/ $(BRANCH) -o ../i2pd_$(LATEST_TAG).orig.tar.gz
-
-doxygen:
-	doxygen -s docs/Doxyfile
-
-.PHONY: all
-.PHONY: clean
-.PHONY: deps
-.PHONY: doxygen
-.PHONY: dist
-.PHONY: api
-.PHONY: api_client
-.PHONY: mk_obj_dir

Makefile.bsd

@@ -1,12 +0,0 @@
-CXX = clang++
-CXXFLAGS ?= -g -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-misleading-indentation
-## NOTE: NEEDED_CXXFLAGS is here so that custom CXXFLAGS can be specified at build time
-## **without** overwriting the CXXFLAGS which we need in order to build.
-## For example, when adding 'hardening flags' to the build
-## (e.g. -fstack-protector-strong -Wformat -Werror=format-security), we do not want to remove
-## -std=c++11. If you want to remove this variable please do so in a way that allows setting
-## custom FLAGS to work at build-time.
-NEEDED_CXXFLAGS = -std=c++11 -D_GLIBCXX_USE_NANOSLEEP=1
-INCFLAGS = -I/usr/include/ -I/usr/local/include/
-LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-LDLIBS = -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread

Makefile.homebrew

@@ -1,45 +0,0 @@
-# root directory holding homebrew
-BREWROOT = /usr/local
-BOOSTROOT = ${BREWROOT}/opt/boost
-SSLROOT = ${BREWROOT}/opt/libressl
-UPNPROOT = ${BREWROOT}/opt/miniupnpc
-CXXFLAGS = -g -Wall -std=c++11 -DMAC_OSX -Wno-overloaded-virtual
-INCFLAGS = -I${SSLROOT}/include -I${BOOSTROOT}/include
-
-ifndef TRAVIS
-	CXX = clang++
-endif
-
-ifeq ($(USE_STATIC),yes)
-	LDLIBS = -lz ${SSLROOT}/lib/libcrypto.a ${SSLROOT}/lib/libssl.a ${BOOSTROOT}/lib/libboost_system.a ${BOOSTROOT}/lib/libboost_date_time.a ${BOOSTROOT}/lib/libboost_filesystem.a ${BOOSTROOT}/lib/libboost_program_options.a -lpthread
-else
-	LDFLAGS = -L${SSLROOT}/lib -L${BOOSTROOT}/lib
-	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
-endif
-
-ifeq ($(USE_UPNP),yes)
-	LDFLAGS += -ldl
-	CXXFLAGS += -DUSE_UPNP
-	INCFLAGS += -I${UPNPROOT}/include
-	ifeq ($(USE_STATIC),yes)
-		LDLIBS += ${UPNPROOT}/lib/libminiupnpc.a
-	else
-		LDFLAGS += -L${UPNPROOT}/lib
-		LDLIBS += -lminiupnpc
-	endif
-endif
-
-# OSX Notes
-# http://www.hutsby.net/2011/08/macs-with-aes-ni.html
-# Seems like all recent Mac's have AES-NI, after firmware upgrade 2.2
-# Found no good way to detect it from command line. TODO: Might be some osx sysinfo magic
-# note from psi: 2009 macbook does not have aesni
-#ifeq ($(USE_AESNI),yes)
-#	CXXFLAGS += -maes -DAESNI
-#endif
-
-# Disabled, since it will be the default make rule. I think its better
-# to define the default rule in Makefile and not Makefile.<ostype> - torkel
-#install: all
-#	test -d ${PREFIX} || mkdir -p ${PREFIX}/
-#	cp -r i2p ${PREFIX}/

Makefile.linux

@@ -1,72 +0,0 @@
-# set defaults instead redefine
-CXXFLAGS ?= -g -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-misleading-indentation
-INCFLAGS ?=
-
-## NOTE: The NEEDED_CXXFLAGS are here so that custom CXXFLAGS can be specified at build time
-## **without** overwriting the CXXFLAGS which we need in order to build.
-## For example, when adding 'hardening flags' to the build
-## (e.g. -fstack-protector-strong -Wformat -Werror=format-security), we do not want to remove
-## -std=c++11. If you want to remove this variable please do so in a way that allows setting
-## custom FLAGS to work at build-time.
-
-# detect proper flag for c++11 support by compilers
-CXXVER := $(shell $(CXX) -dumpversion)
-ifeq ($(shell expr match $(CXX) 'clang'),5)
-	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "4\.[0-9][0-9]"),4) # gcc >= 4.10
-	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "4\.[7-9]"),3) # >= 4.7
-	NEEDED_CXXFLAGS += -std=c++11 -D_GLIBCXX_USE_NANOSLEEP=1
-else ifeq ($(shell expr match ${CXXVER} "4\.6"),3) # = 4.6
-	NEEDED_CXXFLAGS += -std=c++0x
-else ifeq ($(shell expr match ${CXXVER} "[5-7]\.[0-9]"),3) # gcc >= 5.0
-	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "7"),1) # gcc 7 ubuntu
-	NEEDED_CXXFLAGS += -std=c++11
-else # not supported
-$(error Compiler too old)
-endif
-
-NEEDED_CXXFLAGS += -fPIC
-
-ifeq ($(USE_STATIC),yes)
-# NOTE: on glibc you will get this warning:
-#   Using 'getaddrinfo' in statically linked applications requires at runtime
-#   the shared libraries from the glibc version used for linking
-	LIBDIR := /usr/lib
-	LDLIBS  = $(LIBDIR)/libboost_system.a
-	LDLIBS += $(LIBDIR)/libboost_date_time.a
-	LDLIBS += $(LIBDIR)/libboost_filesystem.a
-	LDLIBS += $(LIBDIR)/libboost_program_options.a
-	LDLIBS += $(LIBDIR)/libssl.a
-	LDLIBS += $(LIBDIR)/libcrypto.a
-	LDLIBS += $(LIBDIR)/libz.a
-	LDLIBS += -lpthread -static-libstdc++ -static-libgcc -lrt -ldl
-	USE_AESNI := no
-else
-	LDLIBS = -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
-endif
-
-# UPNP Support (miniupnpc 1.5 and higher)
-ifeq ($(USE_UPNP),yes)
-	CXXFLAGS += -DUSE_UPNP
-ifeq ($(USE_STATIC),yes)
-	LDLIBS += $(LIBDIR)/libminiupnpc.a
-else
-	LDLIBS += -lminiupnpc
-endif
-endif
-
-ifeq ($(USE_AESNI),yes)
-#check if AES-NI is supported by CPU
-ifneq ($(shell $(GREP) -c aes /proc/cpuinfo),0)
-	CPU_FLAGS += -maes -DAESNI
-endif
-endif
-
-ifeq ($(USE_AVX),yes)
-#check if AVX supported by CPU
-ifneq ($(shell $(GREP) -c avx /proc/cpuinfo),0)
-	CPU_FLAGS += -mavx
-endif
-endif

Makefile.mingw

@@ -1,54 +0,0 @@
-USE_WIN32_APP=yes
-CXX = g++
-WINDRES = windres
-CXXFLAGS = -Os -D_MT -DWIN32 -D_WINDOWS -DWIN32_LEAN_AND_MEAN
-NEEDED_CXXFLAGS = -std=c++11
-BOOST_SUFFIX = -mt
-INCFLAGS = -Idaemon -I.
-LDFLAGS = -s -Wl,-rpath,/usr/local/lib -Wl,-Bstatic -static-libgcc -static-libstdc++
-
-# UPNP Support
-ifeq ($(USE_UPNP),yes)
-	CXXFLAGS += -DUSE_UPNP -DMINIUPNP_STATICLIB
-	LDLIBS = -lminiupnpc
-endif
-
-LDLIBS += \
-	-lboost_system$(BOOST_SUFFIX) \
-	-lboost_date_time$(BOOST_SUFFIX) \
-	-lboost_filesystem$(BOOST_SUFFIX) \
-	-lboost_program_options$(BOOST_SUFFIX) \
-	-lssl \
-	-lcrypto \
-	-lz \
-	-lwsock32 \
-	-lws2_32 \
-	-lgdi32 \
-	-liphlpapi \
-	-lstdc++ \
-	-lpthread
-
-ifeq ($(USE_WIN32_APP), yes)
-	CXXFLAGS += -DWIN32_APP
-	LDFLAGS += -mwindows
-	DAEMON_RC += Win32/Resource.rc
-	DAEMON_OBJS += $(patsubst %.rc,obj/%.o,$(DAEMON_RC))
-endif
-
-# don't change following line to ifeq ($(USE_AESNI),yes) !!!
-ifeq ($(USE_AESNI),1)
-	CPU_FLAGS += -maes -DAESNI
-else
-	CPU_FLAGS += -msse
-endif
-
-ifeq ($(USE_AVX),1)
-	CPU_FLAGS += -mavx
-endif
-
-ifeq ($(USE_ASLR),yes)
-	LDFLAGS += -Wl,--nxcompat -Wl,--high-entropy-va -Wl,--dynamicbase,--export-all-symbols
-endif
-
-obj/%.o : %.rc
-	$(WINDRES) -i $< -o $@

Makefile.osx

@@ -1,37 +0,0 @@
-CXX = clang++
-CXXFLAGS = -Os -Wall -std=c++11 -DMAC_OSX
-#CXXFLAGS = -g -O2 -Wall -std=c++11
-INCFLAGS = -I/usr/local/include
-LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-
-ifeq ($(USE_STATIC),yes)
-	LDLIBS = -lz /usr/local/lib/libcrypto.a /usr/local/lib/libssl.a /usr/local/lib/libboost_system.a /usr/local/lib/libboost_date_time.a /usr/local/lib/libboost_filesystem.a /usr/local/lib/libboost_program_options.a -lpthread
-else
-	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
-endif
-
-ifeq ($(USE_UPNP),yes)
-	LDFLAGS += -ldl
-	CXXFLAGS += -DUSE_UPNP
-	ifeq ($(USE_STATIC),yes)
-		LDLIBS += /usr/local/lib/libminiupnpc.a
-	else
-		LDLIBS += -lminiupnpc
-	endif
-endif
-
-ifeq ($(USE_AESNI),1)
-	CXXFLAGS += -maes -DAESNI
-else
-	CXXFLAGS += -msse
-endif
-
-ifeq ($(USE_AVX),1)
-	CXXFLAGS += -mavx
-endif
-
-# Disabled, since it will be the default make rule. I think its better
-# to define the default rule in Makefile and not Makefile.<ostype> - torkel
-#install: all
-#	test -d ${PREFIX} || mkdir -p ${PREFIX}/
-#	cp -r i2p ${PREFIX}/

README.md

@@ -1,84 +1,21 @@
 i2pd
 ====
 
-[Русская версия](https://github.com/PurpleI2P/i2pd_docs_ru/blob/master/README.md)
+I2P router written in C++.
 
-i2pd (I2P Daemon) is a full-featured C++ implementation of I2P client.  
+Documentation for config files, command line options, build instructions and more can be found under the doc directory.
 
-I2P (Invisible Internet Protocol) is a universal anonymous network layer.  
-All communications over I2P are anonymous and end-to-end encrypted, participants
-don't reveal their real IP addresses.  
+Downloads
+------------
 
-I2P client is a software used for building and using anonymous I2P
-networks. Such networks are commonly used for anonymous peer-to-peer
-applications (filesharing, cryptocurrencies) and anonymous client-server
-applications (websites, instant messengers, chat-servers).  
-
-I2P allows people from all around the world to communicate and share information
-without restrictions.  
-
-Features
---------
-
-* Distributed anonymous networking framework  
-* End-to-end encrypted communications  
-* Small footprint, simple dependencies, fast performance  
-* Rich set of APIs for developers of secure applications  
-
-Resources
----------
-
-* [Website](http://i2pd.website)
-* [Documentation](https://i2pd.readthedocs.io/en/latest/)
-* [Wiki](https://github.com/PurpleI2P/i2pd/wiki)
-* [Tickets/Issues](https://github.com/PurpleI2P/i2pd/issues)
-* [Specifications](https://geti2p.net/spec)
-* [Twitter](https://twitter.com/hashtag/i2pd)
-
-Installing
-----------
-
-The easiest way to install i2pd is by using
-[precompiled binaries](https://github.com/PurpleI2P/i2pd/releases/latest).
-See [documentation](https://i2pd.readthedocs.io/en/latest/) for how to build
-i2pd from source on your OS.  
+Official binary releases could be found at:
+http://download.i2p.io/purplei2p/i2pd/releases/
 
 
-Build instructions:
+Build Statuses
+---------------
 
-* [unix](https://i2pd.readthedocs.io/en/latest/devs/building/unix/)
-* [windows](https://i2pd.readthedocs.io/en/latest/devs/building/windows/)
-* [iOS](https://i2pd.readthedocs.io/en/latest/devs/building/ios/)
-* [android](https://i2pd.readthedocs.io/en/latest/devs/building/android/)
-
-
-**Supported systems:**
-
-* GNU/Linux x86/x64		- [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
-* Windows				- [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)
-* Mac OS X				- [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
-* FreeBSD
-* Android
-* iOS
-
-Using i2pd
-----------
-
-See [documentation](https://i2pd.readthedocs.io/en/latest/user-guide/run/) and
-[example config file](https://github.com/PurpleI2P/i2pd/blob/openssl/contrib/i2pd.conf).
-
-Donations
----------
-
-BTC: 3MDoGJW9TLMTCDGrR9bLgWXfm6sjmgy86f  
-LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59  
-ETH: 0x9e5bac70d20d1079ceaa111127f4fb3bccce379d  
-DASH: Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF  
-ZEC: t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ  
-GST: GbD2JSQHBHCKLa9WTHmigJRpyFgmBj4woG  
-
-License
--------
-
-This project is licensed under the BSD 3-clause license, which can be found in the file
-LICENSE in the root of the project source code.  
+- Linux x64      - Maintenance
+- Linux ARM      - Maintenance
+- Mac OS X       - Maintenance
+- Microsoft VC13 - To be added

TODO

@@ -0,0 +1,16 @@
+Refactoring:
+    - SSUSession:637, SSUSession:635 get rid of casting to SSUHeader
+    - Identity.cpp:156 check for self asignment
+    - Rely on a library for TLS and SSL.
+    - Move parsing code out of networking code, to allow better testing. 
+    - Move streaming code to a separate directory.
+    - Separate front-end code (SAM, BOB, ...) from the back-end.
+
+Additions:
+    - Write tests.
+    - Add documentation.
+    - Create a specialized IRC tunnel (instead of just a generic ClientTunnel instance).
+    - Ban peers with unexpected / bad behaviour.
+    - EdDSA support.
+    - Return correct error codes in HTTPProxy.
+    - Modify web interface layout and use AJAX to update information.

Win32/DaemonWin32.cpp

@@ -1,111 +0,0 @@
-#include <thread>
-#include <clocale>
-#include "Config.h"
-#include "Daemon.h"
-#include "util.h"
-#include "Log.h"
-
-#ifdef _WIN32
-#include "Win32/Win32Service.h"
-#ifdef WIN32_APP
-#include "Win32/Win32App.h"
-#endif
-
-namespace i2p
-{
-namespace util
-{
-	bool DaemonWin32::init(int argc, char* argv[])
-	{
-		setlocale(LC_CTYPE, "");
-		SetConsoleCP(1251);
-		SetConsoleOutputCP(1251);
-		setlocale(LC_ALL, "Russian");
-
-		if (!Daemon_Singleton::init(argc, argv))
-			return false;
-
-		std::string serviceControl; i2p::config::GetOption("svcctl", serviceControl);
-		if (serviceControl == "install")
-		{
-			LogPrint(eLogInfo, "WinSVC: installing ", SERVICE_NAME, " as service");
-			InstallService(
-				SERVICE_NAME,               // Name of service
-				SERVICE_DISPLAY_NAME,       // Name to display
-				SERVICE_START_TYPE,         // Service start type
-				SERVICE_DEPENDENCIES,       // Dependencies
-				SERVICE_ACCOUNT,            // Service running account
-				SERVICE_PASSWORD            // Password of the account
-				);
-			return false;
-		}
-		else if (serviceControl == "remove")
-		{
-			LogPrint(eLogInfo, "WinSVC: uninstalling ", SERVICE_NAME, " service");
-			UninstallService(SERVICE_NAME);
-			return false;
-		}
-
-		if (isDaemon)
-		{
-			LogPrint(eLogDebug, "Daemon: running as service");
-			I2PService service(SERVICE_NAME);
-			if (!I2PService::Run(service))
-			{
-				LogPrint(eLogError, "Daemon: Service failed to run w/err 0x%08lx\n", GetLastError());
-				return false;
-			}
-			return false;
-		}
-		else
-			LogPrint(eLogDebug, "Daemon: running as user");
-		return true;
-	}
-
-	bool DaemonWin32::start()
-	{
-		setlocale(LC_CTYPE, "");
-		SetConsoleCP(1251);
-		SetConsoleOutputCP(1251);
-		setlocale(LC_ALL, "Russian");
-#ifdef WIN32_APP
-		if (!i2p::win32::StartWin32App ()) return false;
-
-		// override log
-		i2p::config::SetOption("log", std::string ("file"));
-#endif
-		bool ret = Daemon_Singleton::start();
-		if (ret && i2p::log::Logger().GetLogType() == eLogFile)
-		{
-			// TODO: find out where this garbage to console comes from
-			SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);
-			SetStdHandle(STD_ERROR_HANDLE, INVALID_HANDLE_VALUE);
-		}
-		bool insomnia; i2p::config::GetOption("insomnia", insomnia);
-		if (insomnia)
-			SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
-		return ret;
-	}
-
-	bool DaemonWin32::stop()
-	{
-#ifdef WIN32_APP
-		i2p::win32::StopWin32App ();
-#endif
-		return Daemon_Singleton::stop();
-	}
-
-	void DaemonWin32::run ()
-	{
-#ifdef WIN32_APP
-		i2p::win32::RunWin32App ();
-#else
-		while (running)
-		{
-			std::this_thread::sleep_for (std::chrono::seconds(1));
-		}
-#endif
-	}
-}
-}
-#endif //_WIN32

Win32/Resource.rc

@@ -1,36 +0,0 @@
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-#include "winres.h"
-#undef APSTUDIO_READONLY_SYMBOLS
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-#pragma code_page(1252)
-
-#ifdef APSTUDIO_INVOKED
-1 TEXTINCLUDE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE
-BEGIN
-    "#include ""winres.h""\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE
-BEGIN
-    "\r\n"
-    "\0"
-END
-#endif		// APSTUDIO_INVOKED
-
-MAINICON ICON "mask.ico"
-#endif		// English (United States) resources
-
-#ifndef APSTUDIO_INVOKED
-#include "Resource.rc2"
-#endif		// not APSTUDIO_INVOKED
-

Win32/Resource.rc2

@@ -1,38 +0,0 @@
-#ifdef APSTUDIO_INVOKED
-#error this file is not editable by Microsoft Visual C++
-#endif //APSTUDIO_INVOKED
-
-#include "../libi2pd/version.h"
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION I2PD_VERSION_MAJOR,I2PD_VERSION_MINOR,I2PD_VERSION_MICRO,I2PD_VERSION_PATCH
- PRODUCTVERSION I2P_VERSION_MAJOR,I2P_VERSION_MINOR,I2P_VERSION_MICRO,I2P_VERSION_PATCH
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x40004L
- FILETYPE 0x1L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "CompanyName", "Purple I2P"
-            VALUE "FileDescription", "C++ I2P daemon"
-            VALUE "FileVersion", I2PD_VERSION
-            VALUE "InternalName", CODENAME
-            VALUE "LegalCopyright", "Copyright (C) 2013-2017, The PurpleI2P Project"
-            VALUE "OriginalFilename", "i2pd"
-            VALUE "ProductName", "Purple I2P"
-            VALUE "ProductVersion", I2P_VERSION
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END

Win32/Win32App.cpp

@@ -1,394 +0,0 @@
-#include <string.h>
-#include <windows.h>
-#include <shellapi.h>
-#include "ClientContext.h"
-#include "Config.h"
-#include "NetDb.hpp"
-#include "RouterContext.h"
-#include "Transports.h"
-#include "Tunnel.h"
-#include "version.h"
-#include "resource.h"
-#include "Daemon.h"
-#include "Win32App.h"
-#include <stdio.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#define snprintf _snprintf
-#endif
-
-#define ID_ABOUT 2000
-#define ID_EXIT 2001
-#define ID_CONSOLE 2002
-#define ID_APP 2003
-#define ID_GRACEFUL_SHUTDOWN 2004
-#define ID_STOP_GRACEFUL_SHUTDOWN 2005
-#define ID_RELOAD 2006
-
-#define ID_TRAY_ICON 2050
-#define WM_TRAYICON (WM_USER + 1)
-
-#define IDT_GRACEFUL_SHUTDOWN_TIMER 2100
-#define FRAME_UPDATE_TIMER 2101
-
-namespace i2p
-{
-namespace win32
-{
-	static void ShowPopupMenu (HWND hWnd, POINT *curpos, int wDefaultItem)
-	{
-		HMENU hPopup = CreatePopupMenu();
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_CONSOLE, "Open &console");
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_APP, "Show app");
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_ABOUT, "&About...");
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_RELOAD, "&Reload configs");
-		if (!i2p::util::DaemonWin32::Instance ().isGraceful)
-			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_GRACEFUL_SHUTDOWN, "&Graceful shutdown");
-		else
-			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_STOP_GRACEFUL_SHUTDOWN, "&Stop graceful shutdown");
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_EXIT, "E&xit");
-		SetMenuDefaultItem (hPopup, ID_CONSOLE, FALSE);
-		SendMessage (hWnd, WM_INITMENUPOPUP, (WPARAM)hPopup, 0);
-
-		POINT p;
-		if (!curpos)
-		{
-			GetCursorPos (&p);
-			curpos = &p;
-		}
-
-		WORD cmd = TrackPopupMenu (hPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY, curpos->x, curpos->y, 0, hWnd, NULL);
-		SendMessage (hWnd, WM_COMMAND, cmd, 0);
-
-		DestroyMenu(hPopup);
-	}
-
-	static void AddTrayIcon (HWND hWnd)
-	{
-		NOTIFYICONDATA nid;
-		memset(&nid, 0, sizeof(nid));
-		nid.cbSize = sizeof(nid);
-		nid.hWnd = hWnd;
-		nid.uID = ID_TRAY_ICON;
-		nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
-		nid.uCallbackMessage = WM_TRAYICON;
-		nid.hIcon = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE (MAINICON));
-		strcpy (nid.szTip, "i2pd");
-		strcpy (nid.szInfo, "i2pd is starting");
-		Shell_NotifyIcon(NIM_ADD, &nid );
-	}
-
-	static void RemoveTrayIcon (HWND hWnd)
-	{
-		NOTIFYICONDATA nid;
-		nid.hWnd = hWnd;
-		nid.uID = ID_TRAY_ICON;
-		Shell_NotifyIcon (NIM_DELETE, &nid);
-	}
-
-	static void ShowUptime (std::stringstream& s, int seconds)
-	{
-		int num;
-
-		if ((num = seconds / 86400) > 0) {
-			s << num << " days, ";
-			seconds -= num * 86400;
-		}
-		if ((num = seconds / 3600) > 0) {
-			s << num << " hours, ";
-			seconds -= num * 3600;
-		}
-		if ((num = seconds / 60) > 0) {
-			s << num << " min, ";
-			seconds -= num * 60;
-		}
-		s << seconds << " seconds\n";
-	}
-
-	template <typename size> static void ShowTransfered (std::stringstream& s, size transfer)
-	{
-		auto bytes = transfer & 0x03ff;
-		transfer >>= 10;
-		auto kbytes = transfer & 0x03ff;
-		transfer >>= 10;
-		auto mbytes = transfer & 0x03ff;
-		transfer >>= 10;
-		auto gbytes = transfer & 0x03ff;
-
-		if (gbytes)
-			s << gbytes << " GB, ";
-		if (mbytes)
-			s << mbytes << " MB, ";
-		if (kbytes)
-			s << kbytes << " KB, ";
-		s << bytes << " Bytes\n";
-	}
-
-	static void PrintMainWindowText (std::stringstream& s)
-	{
-		s << "\n";
-		s << "Status: ";
-		switch (i2p::context.GetStatus())
-		{
-			case eRouterStatusOK: s << "OK"; break;
-			case eRouterStatusTesting: s << "Testing"; break;
-			case eRouterStatusFirewalled: s << "Firewalled"; break;
-			case eRouterStatusError:
-			{
-				switch (i2p::context.GetError())
-				{
-					case eRouterErrorClockSkew: s << "Clock skew"; break;
-					default: s << "Error";
-				}
-				break;
-			}
-			default: s << "Unknown";
-		}
-		s << "; ";
-		s << "Success Rate: " << i2p::tunnel::tunnels.GetTunnelCreationSuccessRate() << "%\n";
-		s << "Uptime: "; ShowUptime(s, i2p::context.GetUptime ());
-		s << "\n";
-		s << "Inbound: " << i2p::transport::transports.GetInBandwidth() / 1024 << " KiB/s; ";
-		s << "Outbound: " << i2p::transport::transports.GetOutBandwidth() / 1024 << " KiB/s\n";
-		s << "Received: "; ShowTransfered (s, i2p::transport::transports.GetTotalReceivedBytes());
-		s << "Sent: "; ShowTransfered (s, i2p::transport::transports.GetTotalSentBytes());
-		s << "\n";
-		s << "Routers: " << i2p::data::netdb.GetNumRouters () << "; ";
-		s << "Floodfills: " << i2p::data::netdb.GetNumFloodfills () << "; ";
-		s << "LeaseSets: " << i2p::data::netdb.GetNumLeaseSets () << "\n";
-		s << "Tunnels: ";
-		s << "In: " << i2p::tunnel::tunnels.CountInboundTunnels() << "; ";
-		s << "Out: " << i2p::tunnel::tunnels.CountOutboundTunnels() << "; ";
-		s << "Transit: " << i2p::tunnel::tunnels.CountTransitTunnels() << "\n";
-		s << "\n";
-	}
-
-	static LRESULT CALLBACK WndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-	{
-		switch (uMsg)
-		{
-			case WM_CREATE:
-			{
-				AddTrayIcon (hWnd);
-				break;
-			}
-			case WM_CLOSE:
-			{
-				RemoveTrayIcon (hWnd);
-				KillTimer (hWnd, FRAME_UPDATE_TIMER);
-				KillTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER);
-				PostQuitMessage (0);
-				break;
-			}
-			case WM_COMMAND:
-			{
-				switch (LOWORD(wParam))
-				{
-					case ID_ABOUT:
-					{
-						std::stringstream text;
-						text << "Version: " << I2PD_VERSION << " " << CODENAME;
-						MessageBox( hWnd, TEXT(text.str ().c_str ()), TEXT("i2pd"), MB_ICONINFORMATION | MB_OK );
-						return 0;
-					}
-					case ID_EXIT:
-					{
-						PostMessage (hWnd, WM_CLOSE, 0, 0);
-						return 0;
-					}
-					case ID_GRACEFUL_SHUTDOWN:
-					{
-						i2p::context.SetAcceptsTunnels (false);
-						SetTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER, 10*60*1000, nullptr); // 10 minutes
-						i2p::util::DaemonWin32::Instance ().isGraceful = true;
-						return 0;
-					}
-					case ID_STOP_GRACEFUL_SHUTDOWN:
-					{
-						i2p::context.SetAcceptsTunnels (true);
-						KillTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER);
-						i2p::util::DaemonWin32::Instance ().isGraceful = false;
-						return 0;
-					}
-					case ID_RELOAD:
-					{
-						i2p::client::context.ReloadConfig();
-						std::stringstream text;
-						text << "I2Pd reloading configs...";
-						MessageBox( hWnd, TEXT(text.str ().c_str ()), TEXT("i2pd"), MB_ICONINFORMATION | MB_OK );
-						return 0;
-					}
-					case ID_CONSOLE:
-					{
-						char buf[30];
-						std::string httpAddr; i2p::config::GetOption("http.address", httpAddr);
-						uint16_t	httpPort; i2p::config::GetOption("http.port", httpPort);
-						snprintf(buf, 30, "http://%s:%d", httpAddr.c_str(), httpPort);
-						ShellExecute(NULL, "open", buf, NULL, NULL, SW_SHOWNORMAL);
-						return 0;
-					}
-					case ID_APP:
-					{
-						ShowWindow(hWnd, SW_SHOW);
-						SetTimer(hWnd, FRAME_UPDATE_TIMER, 3000, NULL);
-						return 0;
-					}
-				}
-				break;
-			}
-			case WM_SYSCOMMAND:
-			{
-				switch (wParam)
-				{
-					case SC_MINIMIZE:
-					{
-						ShowWindow(hWnd, SW_HIDE);
-						KillTimer (hWnd, FRAME_UPDATE_TIMER);
-						return 0;
-					}
-					case SC_CLOSE:
-					{
-						std::string close; i2p::config::GetOption("close", close);
-						if (0 == close.compare("ask"))
-						switch(::MessageBox(hWnd, "Would you like to minimize instead of exiting?"
-						" You can add 'close' configuration option. Valid values are: ask, minimize, exit.",
-						"Minimize instead of exiting?", MB_ICONQUESTION | MB_YESNOCANCEL | MB_DEFBUTTON1))
-						{
-							case IDYES: close = "minimize"; break;
-							case IDNO: close = "exit"; break;
-							default: return 0;
-						}
-						if (0 == close.compare("minimize"))
-						{
-							ShowWindow(hWnd, SW_HIDE);
-							KillTimer (hWnd, FRAME_UPDATE_TIMER);
-							return 0;
-						}
-						if (0 != close.compare("exit"))
-						{
-							::MessageBox(hWnd, close.c_str(), "Unknown close action in config", MB_OK | MB_ICONWARNING);
-							return 0;
-						}
-					}
-				}
-			}
-			case WM_TRAYICON:
-			{
-				switch (lParam)
-				{
-					case WM_LBUTTONUP:
-					case WM_RBUTTONUP:
-					{
-						SetForegroundWindow (hWnd);
-						ShowPopupMenu(hWnd, NULL, -1);
-						PostMessage (hWnd, WM_APP + 1, 0, 0);
-						break;
-					}
-				}
-				break;
-			}
-			case WM_TIMER:
-			{
-				if (wParam == IDT_GRACEFUL_SHUTDOWN_TIMER)
-				{
-					PostMessage (hWnd, WM_CLOSE, 0, 0); // exit
-					return 0;
-				}
-				if (wParam == FRAME_UPDATE_TIMER)
-				{
-					InvalidateRect(hWnd, NULL, TRUE);
-				}
-				break;
-			}
-			case WM_PAINT:
-			{
-				HDC hDC;
-				PAINTSTRUCT ps;
-				RECT rp;
-				HFONT hFont;
-				std::stringstream s; PrintMainWindowText (s);
-				hDC = BeginPaint (hWnd, &ps);
-				GetClientRect(hWnd, &rp);
-				SetTextColor(hDC, 0x00D43B69);
-				hFont = CreateFont(18,0,0,0,0,0,0,0,DEFAULT_CHARSET,0,0,0,0,TEXT("Times New Roman"));
-				SelectObject(hDC,hFont);
-				DrawText(hDC, TEXT(s.str().c_str()), s.str().length(), &rp, DT_CENTER|DT_VCENTER);
-				DeleteObject(hFont);
-				EndPaint(hWnd, &ps);
-				break;
-			}
-		}
-		return DefWindowProc( hWnd, uMsg, wParam, lParam);
-	}
-
-	bool StartWin32App ()
-	{
-		if (FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd")))
-		{
-			MessageBox(NULL, TEXT("I2Pd is running already"), TEXT("Warning"), MB_OK);
-			return false;
-		}
-		// register main window
-		auto hInst = GetModuleHandle(NULL);
-		WNDCLASSEX wclx;
-		memset (&wclx, 0, sizeof(wclx));
-		wclx.cbSize = sizeof(wclx);
-		wclx.style = 0;
-		wclx.lpfnWndProc = WndProc;
-		//wclx.cbClsExtra = 0;
-		//wclx.cbWndExtra = 0;
-		wclx.hInstance = hInst;
-		wclx.hIcon = LoadIcon (hInst, MAKEINTRESOURCE(MAINICON));
-		wclx.hCursor = LoadCursor (NULL, IDC_ARROW);
-		//wclx.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
-		wclx.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
-		wclx.lpszMenuName = NULL;
-		wclx.lpszClassName = I2PD_WIN32_CLASSNAME;
-		RegisterClassEx (&wclx);
-		// create new window
-		if (!CreateWindow(I2PD_WIN32_CLASSNAME, TEXT("i2pd"), WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, 100, 100, 350, 210, NULL, NULL, hInst, NULL))
-		{
-			MessageBox(NULL, "Failed to create main window", TEXT("Warning!"), MB_ICONERROR | MB_OK | MB_TOPMOST);
-			return false;
-		}
-		return true;
-	}
-
-	int RunWin32App ()
-	{
-		MSG msg;
-		while (GetMessage (&msg, NULL, 0, 0 ))
-		{
-			TranslateMessage (&msg);
-			DispatchMessage (&msg);
-		}
-		return msg.wParam;
-	}
-
-	void StopWin32App ()
-	{
-		HWND hWnd = FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd"));
-		if (hWnd)
-			PostMessage (hWnd, WM_COMMAND, MAKEWPARAM(ID_EXIT, 0), 0);
-		UnregisterClass (I2PD_WIN32_CLASSNAME, GetModuleHandle(NULL));
-	}
-
-	bool GracefulShutdown ()
-	{
-		HWND hWnd = FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd"));
-		if (hWnd)
-			PostMessage (hWnd, WM_COMMAND, MAKEWPARAM(ID_GRACEFUL_SHUTDOWN, 0), 0);
-		return hWnd;
-	}
-
-	bool StopGracefulShutdown ()
-	{
-		HWND hWnd = FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd"));
-		if (hWnd)
-			PostMessage (hWnd, WM_COMMAND, MAKEWPARAM(ID_STOP_GRACEFUL_SHUTDOWN, 0), 0);
-		return hWnd;
-	}
-
-}
-}

Win32/Win32App.h

@@ -1,17 +0,0 @@
-#ifndef WIN32APP_H__
-#define WIN32APP_H__
-
-#define I2PD_WIN32_CLASSNAME "i2pd main window"
-
-namespace i2p
-{
-namespace win32
-{
-	bool StartWin32App ();
-	void StopWin32App ();
-	int RunWin32App ();
-	bool GracefulShutdown ();
-	bool StopGracefulShutdown ();
-}
-}
-#endif // WIN32APP_H__

Win32/installer.iss

@@ -1,41 +0,0 @@
-#define I2Pd_AppName "i2pd"
-#define I2Pd_ver "2.18.0"
-#define I2Pd_Publisher "PurpleI2P"
-
-[Setup]
-AppName={#I2Pd_AppName}
-AppVersion={#I2Pd_ver}
-AppPublisher={#I2Pd_Publisher}
-DefaultDirName={pf}\I2Pd
-DefaultGroupName=I2Pd
-UninstallDisplayIcon={app}\I2Pd.exe
-OutputDir=.
-LicenseFile=../LICENSE
-OutputBaseFilename=setup_{#I2Pd_AppName}_v{#I2Pd_ver}
-SetupIconFile=mask.ico
-InternalCompressLevel=ultra64
-Compression=lzma/ultra64
-SolidCompression=true
-ArchitecturesInstallIn64BitMode=x64
-AppVerName={#I2Pd_AppName}
-ExtraDiskSpaceRequired=15
-AppID={{621A23E0-3CF4-4BD6-97BC-4835EA5206A2}
-AppPublisherURL=http://i2pd.website/
-AppSupportURL=https://github.com/PurpleI2P/i2pd/issues
-AppUpdatesURL=https://github.com/PurpleI2P/i2pd/releases
-
-[Files]
-Source: ..\i2pd_x86.exe; DestDir: {app}; DestName: i2pd.exe; Flags: ignoreversion; Check: not IsWin64
-Source: ..\i2pd_x64.exe; DestDir: {app}; DestName: i2pd.exe; Flags: ignoreversion; Check: IsWin64
-Source: ..\README.md; DestDir: {app}; DestName: Readme.txt; Flags: onlyifdoesntexist
-Source: ..\contrib\i2pd.conf; DestDir: {userappdata}\i2pd; Flags: onlyifdoesntexist
-Source: ..\contrib\subscriptions.txt; DestDir: {userappdata}\i2pd; Flags: onlyifdoesntexist
-Source: ..\contrib\tunnels.conf; DestDir: {userappdata}\i2pd; Flags: onlyifdoesntexist
-Source: ..\contrib\certificates\*; DestDir: {userappdata}\i2pd\certificates; Flags: onlyifdoesntexist recursesubdirs createallsubdirs
-
-[Icons]
-Name: {group}\I2Pd; Filename: {app}\i2pd.exe
-Name: {group}\Readme; Filename: {app}\Readme.txt
-
-[UninstallDelete]
-Type: filesandordirs; Name: {app}

Win32/resource.h

@@ -1,11 +0,0 @@
-//{{NO_DEPENDENCIES}}
-#define MAINICON						101
-
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE		102
-#define _APS_NEXT_COMMAND_VALUE			40001
-#define _APS_NEXT_CONTROL_VALUE			1001
-#define _APS_NEXT_SYMED_VALUE			101
-#endif
-#endif

Win32/winres.h

@@ -1,6 +0,0 @@
-#ifndef WINRES_H__
-#define WINRES_H__
-
-#include <winresrc.h>
-
-#endif

android/.gitignore

@@ -1,8 +0,0 @@
-gen
-tests
-.idea
-ant.properties
-local.properties
-build.sh
-bin
-log*

android/AndroidManifest.xml

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="org.purplei2p.i2pd"
-      android:versionCode="1"
-      android:versionName="2.18.0"
-	  android:installLocation="auto">
-    <uses-sdk android:minSdkVersion="14" android:targetSdkVersion="25"/>
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
-    <uses-permission android:name="android.permission.INTERNET"/>
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
-	<application android:label="@string/app_name" android:allowBackup="true" android:icon="@drawable/icon">
-	    <receiver android:name=".NetworkStateChangeReceiver">
-	        <intent-filter>
-	            <action android:name="android.net.conn.CONNECTIVITY_CHANGE"/>
-	        </intent-filter>
-	    </receiver>
-	    <activity android:name=".I2PD"
-                  android:label="@string/app_name">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-        <service android:enabled="true" android:name=".ForegroundService"/>
-    </application>
-</manifest>

android/build.gradle

@@ -1,47 +0,0 @@
-buildscript {
-        repositories {
-                mavenCentral()
-                jcenter()
-        }
-        dependencies {
-                classpath 'com.android.tools.build:gradle:2.1.2'
-        }
-}
-
-apply plugin: 'com.android.application'
-
-android {
-        compileSdkVersion 25
-        buildToolsVersion "25.0.2"
-        defaultConfig {
-                applicationId "org.purplei2p.i2pd"
-                targetSdkVersion 25
-                minSdkVersion 14
-                versionCode 1
-                versionName "2.17.1"
-        }
-    sourceSets {
-        main {
-            manifest.srcFile 'AndroidManifest.xml'
-            java.srcDirs = ['src']
-                        res.srcDirs = ['res']
-                        jniLibs.srcDirs = ['libs']
-        }
-        }
-    signingConfigs {
-        orignal {
-            storeFile file("i2pdapk.jks")
-            storePassword "android"
-            keyAlias "i2pdapk"
-            keyPassword "android"
-        }
-    }
-    buildTypes {
-                release {
-                        minifyEnabled false
-                        signingConfig signingConfigs.orignal
-                        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-project.txt'
-                }
-    }
-}
-

android/build.xml

@@ -1,96 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="i2pd" default="help">
-
-    <!-- The local.properties file is created and updated by the 'android' tool.
-         It contains the path to the SDK. It should *NOT* be checked into
-         Version Control Systems. -->
-    <property file="local.properties" />
-
-    <!-- The ant.properties file can be created by you. It is only edited by the
-         'android' tool to add properties to it.
-         This is the place to change some Ant specific build properties.
-         Here are some properties you may want to change/update:
-
-         source.dir
-             The name of the source directory. Default is 'src'.
-         out.dir
-             The name of the output directory. Default is 'bin'.
-
-         For other overridable properties, look at the beginning of the rules
-         files in the SDK, at tools/ant/build.xml
-
-         Properties related to the SDK location or the project target should
-         be updated using the 'android' tool with the 'update' action.
-
-         This file is an integral part of the build system for your
-         application and should be checked into Version Control Systems.
-
-         -->
-    <property file="ant.properties" />
-
-    <!-- if sdk.dir was not set from one of the property file, then
-         get it from the ANDROID_HOME env var.
-         This must be done before we load project.properties since
-         the proguard config can use sdk.dir -->
-    <property environment="env" />
-    <condition property="sdk.dir" value="${env.ANDROID_HOME}">
-        <isset property="env.ANDROID_HOME" />
-    </condition>
-
-    <!-- The project.properties file is created and updated by the 'android'
-         tool, as well as ADT.
-
-         This contains project specific properties such as project target, and library
-         dependencies. Lower level build properties are stored in ant.properties
-         (or in .classpath for Eclipse projects).
-
-         This file is an integral part of the build system for your
-         application and should be checked into Version Control Systems. -->
-    <loadproperties srcFile="project.properties" />
-
-    <!-- quick check on sdk.dir -->
-    <fail
-            message="sdk.dir is missing. Insert sdk.dir=... into './local.properties'. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable."
-            unless="sdk.dir"
-    />
-
-    <fail
-            message="ndk.dir is missing. Insert ndk.dir=... into './local.properties'."
-            unless="ndk.dir"
-    />
-
-    <!--
-        Import per project custom build rules if present at the root of the project.
-        This is the place to put custom intermediary targets such as:
-            -pre-build
-            -pre-compile
-            -post-compile (This is typically used for code obfuscation.
-                           Compiled code location: ${out.classes.absolute.dir}
-                           If this is not done in place, override ${out.dex.input.absolute.dir})
-            -post-package
-            -post-build
-            -pre-clean
-    -->
-    <import file="custom_rules.xml" optional="true" />
-
-    <!-- Import the actual build file.
-
-         To customize existing targets, there are two options:
-         - Customize only one target:
-             - copy/paste the target into this file, *before* the
-               <import> task.
-             - customize it to your needs.
-         - Customize the whole content of build.xml
-             - copy/paste the content of the rules files (minus the top node)
-               into this file, replacing the <import> task.
-             - customize to your needs.
-
-         ***********************
-         ****** IMPORTANT ******
-         ***********************
-         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
-         in order to avoid having your file be overridden by tools such as "android update project"
-    -->
-    <!-- version-tag: 1 -->
-    <import file="${sdk.dir}/tools/ant/build.xml" />
-</project>

android/jni/Android.mk

@@ -1,73 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := i2pd
-LOCAL_CPP_FEATURES := rtti exceptions
-LOCAL_C_INCLUDES += $(IFADDRS_PATH) $(LIB_SRC_PATH) $(LIB_CLIENT_SRC_PATH) $(DAEMON_SRC_PATH)
-LOCAL_STATIC_LIBRARIES := \
-	boost_system \
-	boost_date_time \
-	boost_filesystem \
-	boost_program_options \
-	crypto ssl \
-	miniupnpc
-LOCAL_LDLIBS := -lz
-
-LOCAL_SRC_FILES := DaemonAndroid.cpp i2pd_android.cpp $(IFADDRS_PATH)/ifaddrs.c \
-	$(wildcard $(LIB_SRC_PATH)/*.cpp)\
-	$(wildcard $(LIB_CLIENT_SRC_PATH)/*.cpp)\
-	$(DAEMON_SRC_PATH)/Daemon.cpp \
-	$(DAEMON_SRC_PATH)/UPnP.cpp \
-	$(DAEMON_SRC_PATH)/HTTPServer.cpp \
-	$(DAEMON_SRC_PATH)/I2PControl.cpp
-
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := boost_system
-LOCAL_SRC_FILES := $(BOOST_PATH)/boost_1_62_0/$(TARGET_ARCH_ABI)/lib/libboost_system.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost_1_62_0/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := boost_date_time
-LOCAL_SRC_FILES := $(BOOST_PATH)/boost_1_62_0/$(TARGET_ARCH_ABI)/lib/libboost_date_time.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost_1_62_0/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := boost_filesystem
-LOCAL_SRC_FILES := $(BOOST_PATH)/boost_1_62_0/$(TARGET_ARCH_ABI)/lib/libboost_filesystem.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost_1_62_0/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := boost_program_options
-LOCAL_SRC_FILES := $(BOOST_PATH)/boost_1_62_0/$(TARGET_ARCH_ABI)/lib/libboost_program_options.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost_1_62_0/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := crypto
-LOCAL_SRC_FILES := $(OPENSSL_PATH)/openssl-1.1.0e/$(TARGET_ARCH_ABI)/lib/libcrypto.a
-LOCAL_EXPORT_C_INCLUDES := $(OPENSSL_PATH)/openssl-1.1.0e/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := ssl
-LOCAL_SRC_FILES := $(OPENSSL_PATH)/openssl-1.1.0e/$(TARGET_ARCH_ABI)/lib/libssl.a
-LOCAL_EXPORT_C_INCLUDES := $(OPENSSL_PATH)/openssl-1.1.0e/include
-LOCAL_STATIC_LIBRARIES := crypto
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := miniupnpc
-LOCAL_SRC_FILES := $(MINIUPNP_PATH)/miniupnp-2.0/$(TARGET_ARCH_ABI)/lib/libminiupnpc.a
-LOCAL_EXPORT_C_INCLUDES := $(MINIUPNP_PATH)/miniupnp-2.0/include
-include $(PREBUILT_STATIC_LIBRARY)

android/jni/Application.mk

@@ -1,40 +0,0 @@
-#APP_ABI := all
-#APP_ABI := armeabi-v7a x86
-#APP_ABI := x86
-#APP_ABI := x86_64
-APP_ABI := armeabi-v7a
-#can be android-3 but will fail for x86 since arch-x86 is not present at ndkroot/platforms/android-3/ . libz is taken from there.
-APP_PLATFORM := android-14
-
-# http://stackoverflow.com/a/21386866/529442 http://stackoverflow.com/a/15616255/529442 to enable c++11 support in Eclipse
-NDK_TOOLCHAIN_VERSION := 4.9
-# APP_STL := stlport_shared  --> does not seem to contain C++11 features
-APP_STL := gnustl_shared
-
-# Enable c++11 extensions in source code
-APP_CPPFLAGS += -std=c++11
-
-APP_CPPFLAGS += -DANDROID -D__ANDROID__ -DUSE_UPNP
-ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
-APP_CPPFLAGS += -DANDROID_ARM7A
-endif
-
-APP_OPTIM  := debug
-
-# git clone https://github.com/PurpleI2P/Boost-for-Android-Prebuilt.git
-# git clone https://github.com/PurpleI2P/OpenSSL-for-Android-Prebuilt.git
-# git clone https://github.com/PurpleI2P/MiniUPnP-for-Android-Prebuilt.git
-# git clone https://github.com/PurpleI2P/android-ifaddrs.git
-# change to your own
-I2PD_LIBS_PATH = /path/to/libraries
-BOOST_PATH = $(I2PD_LIBS_PATH)/Boost-for-Android-Prebuilt
-OPENSSL_PATH = $(I2PD_LIBS_PATH)/OpenSSL-for-Android-Prebuilt
-MINIUPNP_PATH = $(I2PD_LIBS_PATH)/MiniUPnP-for-Android-Prebuilt
-IFADDRS_PATH = $(I2PD_LIBS_PATH)/android-ifaddrs
-
-# don't change me
-I2PD_SRC_PATH = $(PWD)/..
-
-LIB_SRC_PATH = $(I2PD_SRC_PATH)/libi2pd
-LIB_CLIENT_SRC_PATH = $(I2PD_SRC_PATH)/libi2pd_client
-DAEMON_SRC_PATH = $(I2PD_SRC_PATH)/daemon

android/jni/DaemonAndroid.cpp

@@ -1,193 +0,0 @@
-#include "DaemonAndroid.h"
-#include "Daemon.h"
-#include <iostream>
-#include <boost/exception/diagnostic_information.hpp>
-#include <boost/exception_ptr.hpp>
-#include <exception>
-//#include "mainwindow.h"
-
-namespace i2p
-{
-namespace android
-{
-/*	Worker::Worker (DaemonAndroidImpl& daemon):
-		m_Daemon (daemon)
-	{
-	}
-
-	void Worker::startDaemon()
-	{
-		Log.d(TAG"Performing daemon start...");
-		m_Daemon.start();
-		Log.d(TAG"Daemon started.");
-		emit resultReady();
-	}
-	void Worker::restartDaemon()
-	{
-		Log.d(TAG"Performing daemon restart...");
-		m_Daemon.restart();
-		Log.d(TAG"Daemon restarted.");
-		emit resultReady();
-	}
-	void Worker::stopDaemon() {
-		Log.d(TAG"Performing daemon stop...");
-		m_Daemon.stop();
-		Log.d(TAG"Daemon stopped.");
-		emit resultReady();
-	}
-
-    Controller::Controller(DaemonAndroidImpl& daemon):
-		m_Daemon (daemon)
-	{
-		Worker *worker = new Worker (m_Daemon);
-		worker->moveToThread(&workerThread);
-		connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
-		connect(this, &Controller::startDaemon, worker, &Worker::startDaemon);
-		connect(this, &Controller::stopDaemon, worker, &Worker::stopDaemon);
-		connect(this, &Controller::restartDaemon, worker, &Worker::restartDaemon);
-		connect(worker, &Worker::resultReady, this, &Controller::handleResults);
-		workerThread.start();
-	}
-	Controller::~Controller()
-	{
-		Log.d(TAG"Closing and waiting for daemon worker thread...");
-		workerThread.quit();
-		workerThread.wait();
-		Log.d(TAG"Waiting for daemon worker thread finished.");
-        if(m_Daemon.isRunning())
-        {
-		    Log.d(TAG"Stopping the daemon...");
-            m_Daemon.stop();
-		    Log.d(TAG"Stopped the daemon.");
-		}
-	}
-*/
-	DaemonAndroidImpl::DaemonAndroidImpl ()
-		//:
-        /*mutex(nullptr), */
-        //m_IsRunning(false),
-        //m_RunningChangedCallback(nullptr)
-	{
-	}
-
-	DaemonAndroidImpl::~DaemonAndroidImpl ()
-	{
-		//delete mutex;
-	}
-
-	bool DaemonAndroidImpl::init(int argc, char* argv[])
-	{
-		//mutex=new QMutex(QMutex::Recursive);
-		//setRunningCallback(0);
-        //m_IsRunning=false;
-		return Daemon.init(argc,argv);
-	}
-
-	void DaemonAndroidImpl::start()
-	{
-		//QMutexLocker locker(mutex);
-		//setRunning(true);
-		Daemon.start();
-	}
-
-	void DaemonAndroidImpl::stop()
-	{
-		//QMutexLocker locker(mutex);
-		Daemon.stop();
-		//setRunning(false);
-	}
-
-	void DaemonAndroidImpl::restart()
-	{
-		//QMutexLocker locker(mutex);
-		stop();
-		start();
-	}
-	/*
-	void DaemonAndroidImpl::setRunningCallback(runningChangedCallback cb)
-	{
-		m_RunningChangedCallback = cb;
-	}
-
-	bool DaemonAndroidImpl::isRunning()
-	{
-        return m_IsRunning;
-	}
-
-	void DaemonAndroidImpl::setRunning(bool newValue)
-	{
-        bool oldValue = m_IsRunning;
-		if(oldValue!=newValue)
-		{
-            m_IsRunning = newValue;
-		    if(m_RunningChangedCallback)
-				m_RunningChangedCallback();
-		}
-	}
-*/
-	static DaemonAndroidImpl daemon;
-	static char* argv[1]={strdup("tmp")};
-	/**
-	 * returns error details if failed
-	 * returns "ok" if daemon initialized and started okay
-	 */
-	std::string start(/*int argc, char* argv[]*/)
-	{
-		try
-		{
-			//int result;
-
-			{
-				//Log.d(TAG"Initialising the daemon...");
-				bool daemonInitSuccess = daemon.init(1,argv);
-				if(!daemonInitSuccess)
-				{
-					//QMessageBox::critical(0, "Error", "Daemon init failed");
-					return "Daemon init failed";
-				}
-				//Log.d(TAG"Initialised, creating the main window...");
-				//MainWindow w;
-				//Log.d(TAG"Before main window.show()...");
-				//w.show ();
-
-				{
-					//i2p::qt::Controller daemonQtController(daemon);
-					//Log.d(TAG"Starting the daemon...");
-					//emit daemonQtController.startDaemon();
-					//daemon.start ();
-					//Log.d(TAG"Starting GUI event loop...");
-					//result = app.exec();
-					//daemon.stop ();
-					daemon.start();
-				}
-			}
-
-			//QMessageBox::information(&w, "Debug", "demon stopped");
-			//Log.d(TAG"Exiting the application");
-			//return result;
-		}
-		catch (boost::exception& ex)
-		{
-			std::stringstream ss;
-		    ss << boost::diagnostic_information(ex);
-		    return ss.str();
-		}
-		catch (std::exception& ex)
-		{
-			std::stringstream ss;
-		    ss << ex.what();
-		    return ss.str();
-		}
-		catch(...)
-		{
-			return "unknown exception";
-		}
-		return "ok";
-	}
-
-	void stop()
-	{
-		daemon.stop();
-	}
-}
-}

android/jni/DaemonAndroid.h

@@ -1,87 +0,0 @@
-#ifndef DAEMON_ANDROID_H
-#define DAEMON_ANDROID_H
-
-#include <string>
-
-namespace i2p
-{
-namespace android
-{
-    class DaemonAndroidImpl
-    {
-    public:
-
-		DaemonAndroidImpl ();
-		~DaemonAndroidImpl ();
-
-        //typedef void (*runningChangedCallback)();
-
-        /**
-         * @return success
-         */
-        bool init(int argc, char* argv[]);
-        void start();
-        void stop();
-        void restart();
-        //void setRunningCallback(runningChangedCallback cb);
-        //bool isRunning();
-    private:
-        //void setRunning(bool running);
-	private:
-		//QMutex* mutex;
-        //bool m_IsRunning;
-		//runningChangedCallback m_RunningChangedCallback;
-    };
-
-	/**
-	 * returns "ok" if daemon init failed
-	 * returns errinfo if daemon initialized and started okay
-	 */
-    std::string start();
-
-    // stops the daemon
-    void stop();
-
-    /*
-	class Worker : public QObject
-    {
-        Q_OBJECT
-	public:
-
-		Worker (DaemonAndroidImpl& daemon);
-
-	private:
-
-		DaemonAndroidImpl& m_Daemon;
-
-    public slots:
-        void startDaemon();
-        void restartDaemon();
-        void stopDaemon();
-
-    signals:
-        void resultReady();
-    };
-
-    class Controller : public QObject
-    {
-        Q_OBJECT
-        QThread workerThread;
-    public:
-        Controller(DaemonAndroidImpl& daemon);
-        ~Controller();
-	private:
-		DaemonAndroidImpl& m_Daemon;
-
-    public slots:
-        void handleResults(){}
-    signals:
-        void startDaemon();
-        void stopDaemon();
-        void restartDaemon();
-    };
-    */
-}
-}
-
-#endif // DAEMON_ANDROID_H

android/jni/i2pd_android.cpp

@@ -1,66 +0,0 @@
-
-//#include <string.h>
-#include <jni.h>
-#include "org_purplei2p_i2pd_I2PD_JNI.h"
-#include "DaemonAndroid.h"
-#include "RouterContext.h"
-#include "Transports.h"
-
-JNIEXPORT jstring JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_getABICompiledWith
-  (JNIEnv * env, jclass clazz) {
-#if defined(__arm__)
-  #if defined(__ARM_ARCH_7A__)
-    #if defined(__ARM_NEON__)
-      #if defined(__ARM_PCS_VFP)
-        #define ABI "armeabi-v7a/NEON (hard-float)"
-      #else
-        #define ABI "armeabi-v7a/NEON"
-      #endif
-    #else
-      #if defined(__ARM_PCS_VFP)
-        #define ABI "armeabi-v7a (hard-float)"
-      #else
-        #define ABI "armeabi-v7a"
-      #endif
-    #endif
-  #else
-   #define ABI "armeabi"
-  #endif
-#elif defined(__i386__)
-   #define ABI "x86"
-#elif defined(__x86_64__)
-   #define ABI "x86_64"
-#elif defined(__mips64)  /* mips64el-* toolchain defines __mips__ too */
-   #define ABI "mips64"
-#elif defined(__mips__)
-   #define ABI "mips"
-#elif defined(__aarch64__)
-   #define ABI "arm64-v8a"
-#else
-   #define ABI "unknown"
-#endif
-
-    return env->NewStringUTF(ABI);
-}
-
-JNIEXPORT jstring JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_startDaemon
-  (JNIEnv * env, jclass clazz) {
-	return env->NewStringUTF(i2p::android::start().c_str());
-}
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_stopDaemon
-  (JNIEnv * env, jclass clazz) {
-	i2p::android::stop();
-}
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_stopAcceptingTunnels
-  (JNIEnv * env, jclass clazz) {
-	i2p::context.SetAcceptsTunnels (false);
-}
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_onNetworkStateChanged
-  (JNIEnv * env, jclass clazz, jboolean isConnected)
-{
-	bool isConnectedBool = (bool) isConnected;
-	i2p::transport::transports.SetOnline (isConnectedBool);
-}

android/jni/org_purplei2p_i2pd_I2PD_JNI.h

@@ -1,33 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-/* Header for class org_purplei2p_i2pd_I2PD_JNI */
-
-#ifndef _Included_org_purplei2p_i2pd_I2PD_JNI
-#define _Included_org_purplei2p_i2pd_I2PD_JNI
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class:     org_purplei2p_i2pd_I2PD_JNI
- * Method:    stringFromJNI
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_getABICompiledWith
-  (JNIEnv *, jclass);
-
-JNIEXPORT jstring JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_startDaemon
-  (JNIEnv *, jclass);
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_stopDaemon
-  (JNIEnv *, jclass);
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_stopAcceptingTunnels
-  (JNIEnv *, jclass);
-
-JNIEXPORT void JNICALL Java_org_purplei2p_i2pd_I2PD_1JNI_onNetworkStateChanged
-  (JNIEnv * env, jclass clazz, jboolean isConnected);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

android/proguard-project.txt

@@ -1,20 +0,0 @@
-# To enable ProGuard in your project, edit project.properties
-# to define the proguard.config property as described in that file.
-#
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in ${sdk.dir}/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the ProGuard
-# include property in project.properties.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}

android/project.properties

@@ -1,14 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must be checked in Version Control Systems.
-#
-# To customize properties used by the Ant build system edit
-# "ant.properties", and override values to adapt the script to your
-# project structure.
-#
-# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
-#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
-
-# Project target.
-target=android-25

android/res/menu/options_main.xml

@@ -1,16 +0,0 @@
-<menu
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    tools:context=".I2PD">
-    <item
-        android:id="@+id/action_graceful_quit"
-        android:title="@string/action_graceful_quit"
-        android:orderInCategory="98"
-        />
-    <item
-        android:id="@+id/action_quit"
-        android:title="@string/action_quit"
-        android:orderInCategory="99"
-        />
-</menu>

android/res/values/strings.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name">i2pd</string>
-    <string name="i2pd_started">i2pd started</string>
-    <string name="i2pd_service_started">i2pd service started</string>
-    <string name="i2pd_service_stopped">i2pd service stopped</string>
-    <string name="action_quit">Quit</string>
-    <string name="action_graceful_quit">Graceful Quit</string>
-    <string name="graceful_quit_is_already_in_progress">Graceful quit is already in progress</string>
-    <string name="graceful_quit_is_in_progress">Graceful quit is in progress</string>
-</resources>

android/src/org/purplei2p/i2pd/DaemonSingleton.java

@@ -1,126 +0,0 @@
-package org.purplei2p.i2pd;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import android.util.Log;
-
-public class DaemonSingleton {
-	private static final String TAG="i2pd";
-	private static final DaemonSingleton instance = new DaemonSingleton();
-	public static interface StateUpdateListener { void daemonStateUpdate(); }
-	private final Set<StateUpdateListener> stateUpdateListeners = new HashSet<StateUpdateListener>();
-
-	public static DaemonSingleton getInstance() {
-		return instance;
-	}
-
-	public synchronized void addStateChangeListener(StateUpdateListener listener) { stateUpdateListeners.add(listener); }
-	public synchronized void removeStateChangeListener(StateUpdateListener listener) { stateUpdateListeners.remove(listener); }
-
-	public synchronized void stopAcceptingTunnels() {
-		if(isStartedOkay()){
-			state=State.gracefulShutdownInProgress;
-			fireStateUpdate();
-			I2PD_JNI.stopAcceptingTunnels();
-		}
-	}
-
-	public void onNetworkStateChange(boolean isConnected) {
-		I2PD_JNI.onNetworkStateChanged(isConnected);
-	}
-
-	private boolean startedOkay;
-
-	public static enum State {uninitialized,starting,jniLibraryLoaded,startedOkay,startFailed,gracefulShutdownInProgress};
-
-	private State state = State.uninitialized;
-
-	public State getState() { return state; }
-
-	public synchronized void start() {
-		if(state != State.uninitialized)return;
-		state = State.starting;
-		fireStateUpdate();
-		new Thread(new Runnable(){
-
-			@Override
-			public void run() {
-				try {
-					I2PD_JNI.loadLibraries();
-					synchronized (DaemonSingleton.this) {
-						state = State.jniLibraryLoaded;
-						fireStateUpdate();
-					}
-				} catch (Throwable tr) {
-					lastThrowable=tr;
-					synchronized (DaemonSingleton.this) {
-						state = State.startFailed;
-						fireStateUpdate();
-					}
-					return;
-				}
-				try {
-					synchronized (DaemonSingleton.this) {
-						daemonStartResult = I2PD_JNI.startDaemon();
-						if("ok".equals(daemonStartResult)){
-							state=State.startedOkay;
-							setStartedOkay(true);
-						}else state=State.startFailed;
-						fireStateUpdate();
-					}
-				} catch (Throwable tr) {
-					lastThrowable=tr;
-					synchronized (DaemonSingleton.this) {
-						state = State.startFailed;
-						fireStateUpdate();
-					}
-					return;
-				}
-			}
-
-		}, "i2pdDaemonStart").start();
-	}
-	private Throwable lastThrowable;
-	private String daemonStartResult="N/A";
-
-	private synchronized void fireStateUpdate() {
-		Log.i(TAG, "daemon state change: "+state);
-		for(StateUpdateListener listener : stateUpdateListeners) {
-			try {
-				listener.daemonStateUpdate();
-			} catch (Throwable tr) {
-				Log.e(TAG, "exception in listener ignored", tr);
-			}
-		}
-	}
-
-	public Throwable getLastThrowable() {
-		return lastThrowable;
-	}
-
-	public String getDaemonStartResult() {
-		return daemonStartResult;
-	}
-
-	private final Object startedOkayLock = new Object();
-
-	public boolean isStartedOkay() {
-		synchronized (startedOkayLock) {
-			return startedOkay;
-		}
-	}
-
-	private void setStartedOkay(boolean startedOkay) {
-		synchronized (startedOkayLock) {
-			this.startedOkay = startedOkay;
-		}
-	}
-
-	public synchronized void stopDaemon() {
-		if(isStartedOkay()){
-			try {I2PD_JNI.stopDaemon();}catch(Throwable tr){Log.e(TAG, "", tr);}
-			setStartedOkay(false);
-		}
-	}
-}

android/src/org/purplei2p/i2pd/ForegroundService.java

@@ -1,97 +0,0 @@
-package org.purplei2p.i2pd;
-
-import android.app.Notification;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.app.Service;
-import android.content.Intent;
-import android.os.Binder;
-import android.os.IBinder;
-import android.util.Log;
-import android.widget.Toast;
-
-public class ForegroundService extends Service {
-    private NotificationManager notificationManager;
-
-    // Unique Identification Number for the Notification.
-    // We use it on Notification start, and to cancel it.
-    private int NOTIFICATION = R.string.i2pd_started;
-
-    /**
-     * Class for clients to access.  Because we know this service always
-     * runs in the same process as its clients, we don't need to deal with
-     * IPC.
-     */
-    public class LocalBinder extends Binder {
-        ForegroundService getService() {
-            return ForegroundService.this;
-        }
-    }
-
-    @Override
-    public void onCreate() {
-        notificationManager = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
-
-        // Display a notification about us starting.  We put an icon in the status bar.
-        showNotification();
-        daemon.start();
-        // Tell the user we started.
-        Toast.makeText(this, R.string.i2pd_service_started, Toast.LENGTH_SHORT).show();
-    }
-
-    @Override
-    public int onStartCommand(Intent intent, int flags, int startId) {
-        Log.i("ForegroundService", "Received start id " + startId + ": " + intent);
-        daemon.start();
-        return START_STICKY;
-    }
-
-    @Override
-    public void onDestroy() {
-        // Cancel the persistent notification.
-        notificationManager.cancel(NOTIFICATION);
-
-        stopForeground(true);
-
-        // Tell the user we stopped.
-        Toast.makeText(this, R.string.i2pd_service_stopped, Toast.LENGTH_SHORT).show();
-    }
-
-    @Override
-    public IBinder onBind(Intent intent) {
-        return mBinder;
-    }
-
-    // This is the object that receives interactions from clients.  See
-    // RemoteService for a more complete example.
-    private final IBinder mBinder = new LocalBinder();
-
-    /**
-     * Show a notification while this service is running.
-     */
-    private void showNotification() {
-        // In this sample, we'll use the same text for the ticker and the expanded notification
-        CharSequence text = getText(R.string.i2pd_started);
-
-        // The PendingIntent to launch our activity if the user selects this notification
-        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
-                new Intent(this, I2PD.class), 0);
-
-        // Set the info for the views that show in the notification panel.
-        Notification notification = new Notification.Builder(this)
-                .setSmallIcon(R.drawable.itoopie_notification_icon)  // the status icon
-                .setTicker(text)  // the status text
-                .setWhen(System.currentTimeMillis())  // the time stamp
-                .setContentTitle(getText(R.string.app_name))  // the label of the entry
-                .setContentText(text)  // the contents of the entry
-                .setContentIntent(contentIntent)  // The intent to send when the entry is clicked
-                .build();
-
-        // Send the notification.
-        //mNM.notify(NOTIFICATION, notification);
-        startForeground(NOTIFICATION, notification);
-    }
-
-	private final DaemonSingleton daemon = DaemonSingleton.getInstance();
-}
-

android/src/org/purplei2p/i2pd/I2PD.java

@@ -1,245 +0,0 @@
-package org.purplei2p.i2pd;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.util.Timer;
-import java.util.TimerTask;
-
-import android.annotation.SuppressLint;
-import android.app.Activity;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
-import android.os.Build;
-import android.os.Bundle;
-import android.os.IBinder;
-import android.util.Log;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.widget.TextView;
-import android.widget.Toast;
-
-public class I2PD extends Activity {
-	private static final String TAG = "i2pd";
-
-	private TextView textView;
-
-	private final DaemonSingleton daemon = DaemonSingleton.getInstance();
-
-	private DaemonSingleton.StateUpdateListener daemonStateUpdatedListener =
-			new DaemonSingleton.StateUpdateListener() {
-
-		@Override
-		public void daemonStateUpdate() {
-			runOnUiThread(new Runnable(){
-
-				@Override
-				public void run() {
-					try {
-						if(textView==null)return;
-						Throwable tr = daemon.getLastThrowable();
-						if(tr!=null) {
-							textView.setText(throwableToString(tr));
-							return;
-						}
-						DaemonSingleton.State state = daemon.getState();
-						textView.setText(String.valueOf(state)+
-								(DaemonSingleton.State.startFailed.equals(state)?": "+daemon.getDaemonStartResult():""));
-					} catch (Throwable tr) {
-						Log.e(TAG,"error ignored",tr);
-					}
-				}
-			});
-		}
-	};
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        textView = new TextView(this);
-        setContentView(textView);
-        DaemonSingleton.getInstance().addStateChangeListener(daemonStateUpdatedListener);
-        daemonStateUpdatedListener.daemonStateUpdate();
-
-        //set the app be foreground
-        doBindService();
-    }
-
-    @Override
-	protected void onDestroy() {
-		super.onDestroy();
-		localDestroy();
-	}
-
-	private void localDestroy() {
-		textView = null;
-		DaemonSingleton.getInstance().removeStateChangeListener(daemonStateUpdatedListener);
-		Timer gracefulQuitTimer = getGracefulQuitTimer();
-		if(gracefulQuitTimer!=null) {
-			gracefulQuitTimer.cancel();
-			setGracefulQuitTimer(null);
-		}
-		try{
-            doUnbindService();
-		}catch(Throwable tr){
-			Log.e(TAG, "", tr);
-		}
-	}
-
-	private CharSequence throwableToString(Throwable tr) {
-    	StringWriter sw = new StringWriter(8192);
-    	PrintWriter pw = new PrintWriter(sw);
-    	tr.printStackTrace(pw);
-    	pw.close();
-    	return sw.toString();
-	}
-
-//	private LocalService mBoundService;
-
-    private ServiceConnection mConnection = new ServiceConnection() {
-        public void onServiceConnected(ComponentName className, IBinder service) {
-            // This is called when the connection with the service has been
-            // established, giving us the service object we can use to
-            // interact with the service.  Because we have bound to a explicit
-            // service that we know is running in our own process, we can
-            // cast its IBinder to a concrete class and directly access it.
-//	        mBoundService = ((LocalService.LocalBinder)service).getService();
-
-            // Tell the user about this for our demo.
-//	        Toast.makeText(Binding.this, R.string.local_service_connected,
-//	                Toast.LENGTH_SHORT).show();
-        }
-
-        public void onServiceDisconnected(ComponentName className) {
-            // This is called when the connection with the service has been
-            // unexpectedly disconnected -- that is, its process crashed.
-            // Because it is running in our same process, we should never
-            // see this happen.
-//	        mBoundService = null;
-//	        Toast.makeText(Binding.this, R.string.local_service_disconnected,
-//	                Toast.LENGTH_SHORT).show();
-        }
-    };
-
-
-    private boolean mIsBound;
-
-    private void doBindService() {
-        // Establish a connection with the service.  We use an explicit
-        // class name because we want a specific service implementation that
-        // we know will be running in our own process (and thus won't be
-        // supporting component replacement by other applications).
-        bindService(new Intent(this,
-                ForegroundService.class), mConnection, Context.BIND_AUTO_CREATE);
-        mIsBound = true;
-    }
-
-    private void doUnbindService() {
-        if (mIsBound) {
-            // Detach our existing connection.
-            unbindService(mConnection);
-            mIsBound = false;
-        }
-    }
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		// Inflate the menu; this adds items to the action bar if it is present.
-		getMenuInflater().inflate(R.menu.options_main, menu);
-		return true;
-	}
-
-	@Override
-	public boolean onOptionsItemSelected(MenuItem item) {
-		// Handle action bar item clicks here. The action bar will
-		// automatically handle clicks on the Home/Up button, so long
-		// as you specify a parent activity in AndroidManifest.xml.
-		int id = item.getItemId();
-
-		switch(id){
-        case R.id.action_quit:
-            quit();
-            return true;
-        case R.id.action_graceful_quit:
-            gracefulQuit();
-            return true;
-        }
-
-		return super.onOptionsItemSelected(item);
-	}
-
-    @SuppressLint("NewApi")
-	private void quit() {
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                finishAndRemoveTask();
-            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-                finishAffinity();
-            } else {
-                //moveTaskToBack(true);
-                finish();
-            }
-        }catch (Throwable tr) {
-            Log.e(TAG, "", tr);
-        }
-        try{
-            daemon.stopDaemon();
-	    }catch (Throwable tr) {
-	        Log.e(TAG, "", tr);
-	    }
-        System.exit(0);
-    }
-
-    private Timer gracefulQuitTimer;
-    private final Object gracefulQuitTimerLock = new Object();
-    private void gracefulQuit() {
-    	if(getGracefulQuitTimer()!=null){
-	        Toast.makeText(this, R.string.graceful_quit_is_already_in_progress,
-	        		Toast.LENGTH_SHORT).show();
-    		return;
-    	}
-        Toast.makeText(this, R.string.graceful_quit_is_in_progress,
-        		Toast.LENGTH_SHORT).show();
-        new Thread(new Runnable(){
-
-			@Override
-			public void run() {
-				try{
-					Log.d(TAG, "grac stopping");
-			        if(daemon.isStartedOkay()) {
-			        	daemon.stopAcceptingTunnels();
-			            Timer gracefulQuitTimer = new Timer(true);
-						setGracefulQuitTimer(gracefulQuitTimer);
-						gracefulQuitTimer.schedule(new TimerTask(){
-
-			    			@Override
-			    			public void run() {
-			    				quit();
-			    			}
-
-			            }, 10*60*1000/*milliseconds*/);
-			        }else{
-			        	quit();
-			        }
-				} catch(Throwable tr) {
-					Log.e(TAG,"",tr);
-				}
-			}
-
-        },"gracQuitInit").start();
-    }
-
-	private Timer getGracefulQuitTimer() {
-		synchronized (gracefulQuitTimerLock) {
-			return gracefulQuitTimer;
-		}
-	}
-
-	private void setGracefulQuitTimer(Timer gracefulQuitTimer) {
-    	synchronized (gracefulQuitTimerLock) {
-    		this.gracefulQuitTimer = gracefulQuitTimer;
-    	}
-	}
-}

android/src/org/purplei2p/i2pd/I2PD_JNI.java

@@ -1,21 +0,0 @@
-package org.purplei2p.i2pd;
-
-public class I2PD_JNI {
-    public static native String getABICompiledWith();
-	/**
-	 * returns error info if failed
-	 * returns "ok" if daemon initialized and started okay
-	 */
-    public static native String startDaemon();
-    //should only be called after startDaemon() success
-    public static native void stopDaemon();
-
-    public static native void stopAcceptingTunnels();
-
-	public static native void onNetworkStateChanged(boolean isConnected);
-
-	public static void loadLibraries() {
-    	System.loadLibrary("gnustl_shared");
-        System.loadLibrary("i2pd");
-    }
-}

android/src/org/purplei2p/i2pd/NetworkStateChangeReceiver.java

@@ -1,30 +0,0 @@
-package org.purplei2p.i2pd;
-
-import android.util.Log;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.net.ConnectivityManager;
-import android.net.NetworkInfo;
-
-public class NetworkStateChangeReceiver extends BroadcastReceiver {
-
-    private static final String TAG = "i2pd";
-
-	//api level 1
-    @Override
-    public void onReceive(final Context context, final Intent intent) {
-        Log.d(TAG,"Network state change");
-		try {
-			ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
-			NetworkInfo activeNetworkInfo = cm.getActiveNetworkInfo();
-			boolean isConnected = activeNetworkInfo!=null && activeNetworkInfo.isConnected();
-			// https://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html?hl=ru
-			// boolean isWiFi = activeNetworkInfo!=null && (activeNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI);
-
-			I2PD_JNI.onNetworkStateChanged(isConnected);
-		} catch (Throwable tr) {
-			Log.d(TAG,"",tr);
-		}
-    }
-}

appveyor.yml

@@ -1,49 +0,0 @@
-version: 2.18.{build}
-pull_requests:
-  do_not_increment_build_number: true
-branches:
-  only:
-  - openssl
-skip_tags: true
-os: Visual Studio 2015
-shallow_clone: true
-clone_depth: 1
-
-environment:
-  MSYS2_PATH_TYPE: inherit
-  CHERE_INVOKING: enabled_from_arguments
-  matrix:
-  - MSYSTEM: MINGW64
-  - MSYSTEM: MINGW32
-
-install:
-- c:\msys64\usr\bin\bash -lc "pacman --noconfirm -Rns gcc-fortran gcc"
-- c:\msys64\usr\bin\bash -lc "pacman --noconfirm -Syuu"
-
-- c:\msys64\usr\bin\bash -lc "pacman --noconfirm -Syuu"
-
-- if "%MSYSTEM%" == "MINGW64" (
-    c:\msys64\usr\bin\bash -lc "pacman --noconfirm -S mingw-w64-x86_64-boost mingw-w64-x86_64-miniupnpc"
-  ) else (
-    c:\msys64\usr\bin\bash -lc "pacman --noconfirm -S mingw-w64-i686-boost mingw-w64-i686-miniupnpc"
-  )
-
-- if "%MSYSTEM%" == "MINGW64" (
-    set "bitness=64"
-  ) else (
-    set "bitness=32"
-  )
-
-build_script:
-- cmd: >-
-    cd \projects\i2pd
-
-    echo MSYSTEM = %MSYSTEM%, bitness = %bitness%
-
-- c:\msys64\usr\bin\bash -lc "make USE_UPNP=yes -j2"
-- 7z a -tzip -mx9 -mmt i2pd-mingw-win%bitness%.zip i2pd.exe
-
-test: off
-
-artifacts:
-- path: i2pd-mingw-win*.zip

benchmark/CMakeLists.txt

@@ -0,0 +1,14 @@
+set(BENCHMARK_SRC
+  "main.cpp"
+)
+
+if(WITH_BENCHMARK)
+    add_executable(${BENCHMARK_NAME} ${BENCHMARK_SRC})
+    target_link_libraries(
+        ${BENCHMARK_NAME} ${CORE_NAME} ${DL_LIB} ${Boost_LIBRARIES} ${CRYPTO++_LIBRARIES}
+        ${CMAKE_THREAD_LIBS_INIT}
+    )
+    install(TARGETS
+        ${BENCHMARK_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    )
+endif()

benchmark/main.cpp

@@ -0,0 +1,83 @@
+#include "crypto/Signature.h"
+#include <cryptopp/osrng.h>
+#include <iostream>
+#include <chrono>
+#include <functional>
+
+typedef std::function<void(CryptoPP::RandomNumberGenerator&, uint8_t*, uint8_t*)> KeyGenerator;
+
+template<class Verifier, class Signer>
+void benchmark(std::size_t count, std::size_t public_key_size, std::size_t private_key_size,
+    std::size_t signature_size, KeyGenerator generator)
+{
+    typedef std::chrono::time_point<std::chrono::high_resolution_clock> TimePoint;
+    CryptoPP::AutoSeededRandomPool rng;
+
+    uint8_t private_key[private_key_size] = {};
+    uint8_t public_key[public_key_size] = {};
+
+    generator(rng, private_key, public_key);
+
+    Verifier verifier(public_key); 
+    Signer signer(private_key); 
+
+    uint8_t message[512] = {};
+    uint8_t output[signature_size] = {};
+
+    std::chrono::nanoseconds sign_duration(0);
+    std::chrono::nanoseconds verify_duration(0);
+
+    for(std::size_t i = 0; i < count; ++i) {
+        rng.GenerateBlock(message, 512); 
+        TimePoint begin1 = std::chrono::high_resolution_clock::now();
+        signer.Sign(rng, message, 512, output);
+        TimePoint end1 = std::chrono::high_resolution_clock::now();
+
+        sign_duration += std::chrono::duration_cast<std::chrono::nanoseconds>(end1 - begin1);
+
+        TimePoint begin2 = std::chrono::high_resolution_clock::now();
+        verifier.Verify(message, 512, output);
+        TimePoint end2 = std::chrono::high_resolution_clock::now();
+
+        verify_duration += std::chrono::duration_cast<std::chrono::nanoseconds>(end2 - begin2);
+    }
+    std::cout << "Conducted " << count << " experiments." << std::endl;
+    std::cout << "Total sign time: " << std::chrono::duration_cast<std::chrono::milliseconds>(sign_duration).count() << std::endl;
+    std::cout << "Total verify time: " << std::chrono::duration_cast<std::chrono::milliseconds>(verify_duration).count() << std::endl;
+}
+
+
+int main()
+{
+    using namespace i2p::crypto;
+    std::cout << "--------DSA---------" << std::endl;
+    benchmark<DSAVerifier, DSASigner>(
+        1000, DSA_PUBLIC_KEY_LENGTH,
+        DSA_PRIVATE_KEY_LENGTH, DSA_SIGNATURE_LENGTH,
+        &CreateDSARandomKeys
+    );
+    std::cout << "-----ECDSAP256------" << std::endl;
+    benchmark<ECDSAP256Verifier, ECDSAP256Signer>(
+        1000, ECDSAP256_KEY_LENGTH,
+        ECDSAP256_KEY_LENGTH, 64,
+        &CreateECDSAP256RandomKeys
+    );
+    std::cout << "-----ECDSAP384------" << std::endl;
+    benchmark<ECDSAP384Verifier, ECDSAP384Signer>(
+        1000, ECDSAP384_KEY_LENGTH,
+        ECDSAP384_KEY_LENGTH, 64,
+        &CreateECDSAP384RandomKeys
+    );
+    std::cout << "-----ECDSAP521------" << std::endl;
+    benchmark<ECDSAP521Verifier, ECDSAP521Signer>(
+        1000, ECDSAP521_KEY_LENGTH,
+        ECDSAP521_KEY_LENGTH, 64,
+        &CreateECDSAP521RandomKeys
+    );
+    std::cout << "-----EDDSA25519-----" << std::endl;
+    benchmark<EDDSA25519Verifier, EDDSA25519Signer>(
+        1000, EDDSA25519_PUBLIC_KEY_LENGTH,
+        EDDSA25519_PRIVATE_KEY_LENGTH, 64,
+        &CreateEDDSARandomKeys
+    );
+}

build/.gitignore

@@ -1,14 +0,0 @@
-# Various generated files
-/CMakeFiles/
-/i2pd
-/libi2pd.a
-/libi2pdclient.a
-/cmake_install.cmake
-/CMakeCache.txt
-/CPackConfig.cmake
-/CPackSourceConfig.cmake
-/install_manifest.txt
-/arch.c
-# windows build script
-i2pd*.zip
-build*.log

build/CMakeLists.txt

@@ -1,571 +0,0 @@
-cmake_minimum_required ( VERSION 2.8.12 )
-# this addresses CMP0059 with CMake > 3.3 for PCH flags
-cmake_policy( VERSION 2.8.12 )
-project ( "i2pd" )
-
-# for debugging
-#set(CMAKE_VERBOSE_MAKEFILE on)
-
-# configurale options
-option(WITH_AESNI     "Use AES-NI instructions set" OFF)
-option(WITH_AVX       "Use AVX instructions" OFF)
-option(WITH_HARDENING "Use hardening compiler flags" OFF)
-option(WITH_LIBRARY   "Build library" ON)
-option(WITH_BINARY    "Build binary" ON)
-option(WITH_STATIC    "Static build" OFF)
-option(WITH_UPNP "Include support for UPnP client" OFF)
-option(WITH_PCH "Use precompiled header" OFF)
-option(WITH_GUI "Include GUI (currently MS Windows only)" ON)
-option(WITH_MESHNET "Build for cjdns test network" OFF)
-option(WITH_ADDRSANITIZER "Build with address sanitizer unix only" OFF)
-option(WITH_THREADSANITIZER "Build with thread sanitizer unix only" OFF)
-option(WITH_I2LUA "Build for i2lua" OFF)
-option(WITH_WEBSOCKETS "Build with websocket ui" OFF)
-
-# paths
-set ( CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules" )
-set ( CMAKE_SOURCE_DIR ".." )
-
-# architecture
-include(TargetArch)
-target_architecture(ARCHITECTURE)
-
-set(LIBI2PD_SRC_DIR ../libi2pd)
-set(LIBI2PD_CLIENT_SRC_DIR ../libi2pd_client)
-
-include_directories(${LIBI2PD_SRC_DIR})
-include_directories(${LIBI2PD_CLIENT_SRC_DIR})
-
-set (LIBI2PD_SRC
-  "${LIBI2PD_SRC_DIR}/BloomFilter.cpp"
-  "${LIBI2PD_SRC_DIR}/Config.cpp"
-  "${LIBI2PD_SRC_DIR}/Crypto.cpp"
-  "${LIBI2PD_SRC_DIR}/CryptoKey.cpp"
-  "${LIBI2PD_SRC_DIR}/Garlic.cpp"
-  "${LIBI2PD_SRC_DIR}/Gzip.cpp"
-  "${LIBI2PD_SRC_DIR}/HTTP.cpp"
-  "${LIBI2PD_SRC_DIR}/I2NPProtocol.cpp"
-  "${LIBI2PD_SRC_DIR}/Identity.cpp"
-  "${LIBI2PD_SRC_DIR}/LeaseSet.cpp"
-  "${LIBI2PD_SRC_DIR}/FS.cpp"
-  "${LIBI2PD_SRC_DIR}/Log.cpp"
-  "${LIBI2PD_SRC_DIR}/NTCPSession.cpp"
-  "${LIBI2PD_SRC_DIR}/NetDbRequests.cpp"
-  "${LIBI2PD_SRC_DIR}/NetDb.cpp"
-  "${LIBI2PD_SRC_DIR}/Profiling.cpp"
-  "${LIBI2PD_SRC_DIR}/Reseed.cpp"
-  "${LIBI2PD_SRC_DIR}/RouterContext.cpp"
-  "${LIBI2PD_SRC_DIR}/RouterInfo.cpp"
-  "${LIBI2PD_SRC_DIR}/SSU.cpp"
-  "${LIBI2PD_SRC_DIR}/SSUData.cpp"
-  "${LIBI2PD_SRC_DIR}/SSUSession.cpp"
-  "${LIBI2PD_SRC_DIR}/Streaming.cpp"
-  "${LIBI2PD_SRC_DIR}/Destination.cpp"
-  "${LIBI2PD_SRC_DIR}/TransitTunnel.cpp"
-  "${LIBI2PD_SRC_DIR}/Tunnel.cpp"
-  "${LIBI2PD_SRC_DIR}/TunnelGateway.cpp"
-  "${LIBI2PD_SRC_DIR}/Transports.cpp"
-  "${LIBI2PD_SRC_DIR}/TunnelEndpoint.cpp"
-  "${LIBI2PD_SRC_DIR}/TunnelPool.cpp"
-  "${LIBI2PD_SRC_DIR}/Base.cpp"
-  "${LIBI2PD_SRC_DIR}/util.cpp"
-  "${LIBI2PD_SRC_DIR}/Datagram.cpp"
-  "${LIBI2PD_SRC_DIR}/Family.cpp"
-  "${LIBI2PD_SRC_DIR}/Signature.cpp"
-  "${LIBI2PD_SRC_DIR}/Timestamp.cpp"
-  "${LIBI2PD_SRC_DIR}/api.cpp"
-  "${LIBI2PD_SRC_DIR}/Event.cpp"
-  "${LIBI2PD_SRC_DIR}/Gost.cpp"
-)
-
-if (WITH_WEBSOCKETS)
-  add_definitions(-DWITH_EVENTS)
-  find_package(websocketpp REQUIRED)
-endif ()
-
-if (WIN32 OR MSYS)
-  list (APPEND LIBI2PD_SRC "${CMAKE_SOURCE_DIR}/I2PEndian.cpp")
-endif ()
-
-if (WITH_I2LUA)
-  add_definitions(-DI2LUA)
-endif()
-
-add_library(libi2pd ${LIBI2PD_SRC})
-set_target_properties(libi2pd PROPERTIES PREFIX "")
-install(TARGETS libi2pd
-  EXPORT libi2pd
-  ARCHIVE DESTINATION lib
-  COMPONENT Libraries)
-# TODO Make libi2pd available to 3rd party projects via CMake as imported target
-# FIXME This pulls stdafx
-# install(EXPORT libi2pd DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-set (CLIENT_SRC
-  "${LIBI2PD_CLIENT_SRC_DIR}/AddressBook.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/BOB.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/ClientContext.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/MatchedDestination.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/I2PTunnel.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/I2PService.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/SAM.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/SOCKS.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/HTTPProxy.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/I2CP.cpp"
-  "${LIBI2PD_CLIENT_SRC_DIR}/WebSocks.cpp"
-)
-
-if(WITH_WEBSOCKETS)
-  list (APPEND CLIENT_SRC "${LIBI2PD_CLIENT_SRC_DIR}/Websocket.cpp")
-endif ()
-add_library(i2pdclient ${CLIENT_SRC})
-
-set(DAEMON_SRC_DIR ../daemon)
-
-set (DAEMON_SRC
-  "${DAEMON_SRC_DIR}/Daemon.cpp"
-  "${DAEMON_SRC_DIR}/HTTPServer.cpp"
-  "${DAEMON_SRC_DIR}/I2PControl.cpp"
-  "${DAEMON_SRC_DIR}/i2pd.cpp"
-  "${DAEMON_SRC_DIR}/UPnP.cpp"
-)
-
-if (WITH_MESHNET)
-  add_definitions(-DMESHNET)
-endif ()
-
-if (WITH_UPNP)
-  add_definitions(-DUSE_UPNP)
-  if (NOT MSVC AND NOT MSYS)
-    set(DL_LIB ${CMAKE_DL_LIBS})
-  endif ()
-endif ()
-
-# compiler flags customization (by vendor)
-if (MSVC)
-  add_definitions( -DWIN32_LEAN_AND_MEAN -DNOMINMAX )
-  # TODO Check & report to Boost dev, there should be no need for these two
-  add_definitions( -DBOOST_THREAD_NO_LIB -DBOOST_CHRONO_NO_LIB )
-  set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL" )
-  set( CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /INCREMENTAL:NO /LTCG" )
-  set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} /GL" )
-  set( CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /INCREMENTAL:NO /LTCG" )
-else()
-  if (MSYS OR MINGW)
-    add_definitions( -DWIN32_LEAN_AND_MEAN )
-  endif ()
-  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Winvalid-pch -Wno-unused-parameter" )
-  set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -pedantic" )
-  # TODO: The following is incompatible with static build and enabled hardening for OpenWRT.
-  # Multiple definitions of __stack_chk_fail (libssp & libc)
-  set( CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -flto -s -ffunction-sections -fdata-sections" )
-  set( CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "-Wl,--gc-sections" ) # -flto is added from above
-endif ()
-
-# check for c++11 support
-include(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11_SUPPORTED)
-CHECK_CXX_COMPILER_FLAG("-std=c++0x" CXX0X_SUPPORTED)
-if (CXX11_SUPPORTED)
-  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
-elseif (CXX0X_SUPPORTED) # gcc 4.6
-  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x" )
-elseif (NOT MSVC)
-  message(SEND_ERROR "C++11 standart not seems to be supported by compiler. Too old version?")
-endif ()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe")
-  if (WITH_HARDENING)
-    add_definitions( "-D_FORTIFY_SOURCE=2" )
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security -Werror=format-security" )
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector --param ssp-buffer-size=4" )
-  endif ()
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-  # more tweaks
-  if (NOT (MSVC OR MSYS OR APPLE))
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-const-variable -Wno-overloaded-virtual -Wno-c99-extensions" )
-  endif()
-endif ()
-
-if (WITH_HARDENING AND MSVC)
-  # Most security options like dynamic base, buffer & stack checks are ON by default
-  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /guard:cf" )
-endif ()
-
-# compiler flags customization (by system)
-if (UNIX)
-  list (APPEND DAEMON_SRC "${DAEMON_SRC_DIR}/UnixDaemon.cpp")
-  if (NOT (CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR APPLE))
-    # "'sleep_for' is not a member of 'std::this_thread'" in gcc 4.7/4.8
-    add_definitions( "-D_GLIBCXX_USE_NANOSLEEP=1" )
-  endif ()
-elseif (WIN32 OR MSYS)
-  list (APPEND DAEMON_SRC "${CMAKE_SOURCE_DIR}/Win32/DaemonWin32.cpp")
-  if (WITH_GUI)
-    list (APPEND DAEMON_SRC "${CMAKE_SOURCE_DIR}/Win32/Win32App.cpp")
-    set_source_files_properties("${CMAKE_SOURCE_DIR}/Win32/DaemonWin32.cpp"
-      PROPERTIES COMPILE_DEFINITIONS WIN32_APP)
-  endif ()
-  list (APPEND DAEMON_SRC "${CMAKE_SOURCE_DIR}/Win32/Win32Service.cpp")
-  list (APPEND DAEMON_SRC "${CMAKE_SOURCE_DIR}/Win32/Resource.rc")
-endif ()
-
-if (WITH_AESNI)
-  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes" )
-  add_definitions ( -DAESNI )
-endif()
-
-if (WITH_AVX)
-  set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx" )
-endif()
-
-if (WITH_ADDRSANITIZER)
-  if (NOT MSVC)
-    set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer" )
-    set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address" )
-  else ()
-    message( SEND_ERROR "MSVC does not support address sanitizer option")
-  endif()
-endif()
-
-if (WITH_THREADSANITIZER)
-  if (WITH_ADDRSANITIZER)
-    message( FATAL_ERROR "thread sanitizer option cannot be combined with address sanitizer")
-  elseif (NOT MSVC)
-    set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread" )
-    set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread" )
-  else ()
-    message( SEND_ERROR "MSVC does not support address sanitizer option")
-  endif()
-endif()
-
-
-# libraries
-# TODO: once CMake 3.1+ becomes mainstream, see e.g. http://stackoverflow.com/a/29871891/673826
-# use imported Threads::Threads instead
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-if (IOS)
-  set(CMAKE_THREAD_LIBS_INIT "-lpthread")
-  set(CMAKE_HAVE_THREADS_LIBRARY 1)
-  set(CMAKE_USE_WIN32_THREADS_INIT 0)
-  set(CMAKE_USE_PTHREADS_INIT 1)
-else()
-  find_package ( Threads REQUIRED )
-endif()
-if(THREADS_HAVE_PTHREAD_ARG) # compile time flag
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-endif()
-
-if (WITH_STATIC)
-  set(Boost_USE_STATIC_LIBS ON)
-  set(Boost_USE_STATIC_RUNTIME ON)
-  if (WIN32 AND NOT MSYS AND NOT MINGW)
-    # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace
-    foreach(flag_var
-            CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-            CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-      if(${flag_var} MATCHES "/MD")
-        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-      endif(${flag_var} MATCHES "/MD")
-    endforeach(flag_var)
-  else ()
-    set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
-  endif ()
-  set(BUILD_SHARED_LIBS OFF)
-  if (${CMAKE_CXX_COMPILER} MATCHES ".*-openwrt-.*")
-    set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread" )
-    # set( CMAKE_THREAD_LIBS_INIT "gcc_eh -Wl,--whole-archive -lpthread -Wl,--no-whole-archive" )
-    set( CMAKE_THREAD_LIBS_INIT "gcc_eh -Wl,-u,pthread_create,-u,pthread_once,-u,pthread_mutex_lock,-u,pthread_mutex_unlock,-u,pthread_join,-u,pthread_equal,-u,pthread_detach,-u,pthread_cond_wait,-u,pthread_cond_signal,-u,pthread_cond_destroy,-u,pthread_cond_broadcast,-u,pthread_cancel" )
-  endif ()
-else()
-  if (NOT WIN32 AND NOT MSYS)
-    # TODO: Consider separate compilation for LIBI2PD_SRC for library.
-    # No need in -fPIC overhead for binary if not interested in library
-    # HINT: revert c266cff CMakeLists.txt: compilation speed up
-    set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC" )
-  endif ()
-  add_definitions(-DBOOST_SYSTEM_DYN_LINK -DBOOST_FILESYSTEM_DYN_LINK -DBOOST_PROGRAM_OPTIONS_DYN_LINK -DBOOST_DATE_TIME_DYN_LINK -DBOOST_REGEX_DYN_LINK)
-endif ()
-
-if (WITH_PCH)
-  include_directories(BEFORE ${CMAKE_BINARY_DIR})
-  add_library(stdafx STATIC "${LIBI2PD_SRC_DIR}/stdafx.cpp")
-  if(MSVC)
-    target_compile_options(stdafx PRIVATE /Ycstdafx.h /Zm155)
-    add_custom_command(TARGET stdafx POST_BUILD
-      COMMAND xcopy /y stdafx.dir\\$<CONFIG>\\*.pdb libi2pd.dir\\$<CONFIG>\\
-      COMMAND xcopy /y stdafx.dir\\$<CONFIG>\\*.pdb i2pdclient.dir\\$<CONFIG>\\
-      COMMAND xcopy /y stdafx.dir\\$<CONFIG>\\*.pdb i2pd.dir\\$<CONFIG>\\
-      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-      )
-    target_compile_options(libi2pd PRIVATE /FIstdafx.h /Yustdafx.h /Zm155 "/Fp${CMAKE_BINARY_DIR}/stdafx.dir/$<CONFIG>/stdafx.pch")
-    target_compile_options(i2pdclient PRIVATE /FIstdafx.h /Yustdafx.h /Zm155 "/Fp${CMAKE_BINARY_DIR}/stdafx.dir/$<CONFIG>/stdafx.pch")
-  else()
-    string(TOUPPER ${CMAKE_BUILD_TYPE} BTU)
-    get_directory_property(DEFS DEFINITIONS)
-    string(REPLACE " " ";" FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${BTU}} ${DEFS}")
-    add_custom_command(TARGET stdafx PRE_BUILD
-      COMMAND ${CMAKE_CXX_COMPILER} ${FLAGS} -c ${CMAKE_CURRENT_SOURCE_DIR}/../libi2pd/stdafx.h -o ${CMAKE_BINARY_DIR}/stdafx.h.gch
-    )
-    target_compile_options(libi2pd PRIVATE -include libi2pd/stdafx.h)
-    target_compile_options(i2pdclient PRIVATE -include libi2pd/stdafx.h)
-  endif()
-  target_link_libraries(libi2pd stdafx)
-endif()
-
-target_link_libraries(i2pdclient libi2pd)
-
-find_package ( Boost COMPONENTS system filesystem program_options date_time REQUIRED )
-if(NOT DEFINED Boost_INCLUDE_DIRS)
-  message(SEND_ERROR "Boost is not found, or your boost version was bellow 1.46. Please download Boost!")
-endif()
-
-find_package ( OpenSSL REQUIRED )
-if(NOT DEFINED OPENSSL_INCLUDE_DIR)
-  message(SEND_ERROR "Could not find OpenSSL. Please download and install it first!")
-else()
-  if(NOT (OPENSSL_VERSION VERSION_LESS 1.1))
-    message(WARNING "Your OpenSSL version ${OPENSSL_VERSION} >=1.1 is experimental: build with v1.0 when possible.")
-  endif()
-endif()
-
-if (WITH_UPNP)
-  find_package ( MiniUPnPc REQUIRED )
-  include_directories( SYSTEM ${MINIUPNPC_INCLUDE_DIR} )
-endif()
-
-find_package ( ZLIB )
-if (NOT ZLIB_FOUND )
-  # We are probably on Windows
-  find_program( PATCH patch C:/Program Files/Git/usr/bin C:/msys64/usr/bin C:/msys32/usr/bin C:/Strawberry/c/bin )
-  include( ExternalProject )
-  if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
-    set( ZLIB_EXTRA -DAMD64=ON )
-  else()
-    set( ZLIB_EXTRA -DASM686=ON "-DCMAKE_ASM_MASM_FLAGS=/W0 /safeseh" )
-  endif()
-  ExternalProject_Add(zlib-project
-    URL http://zlib.net/zlib-1.2.8.tar.gz
-    URL_MD5 44d667c142d7cda120332623eab69f40
-    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/zlib
-    PATCH_COMMAND "${PATCH}" -p0 < ${CMAKE_CURRENT_SOURCE_DIR}/cmake-zlib-static.patch
-      && "${PATCH}" -p0 < ${CMAKE_CURRENT_SOURCE_DIR}/cmake-zlib-amd64.patch
-    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
-      -DWITH_STATIC=${WITH_STATIC} ${ZLIB_EXTRA}
-    )
-  if (WITH_PCH)
-    add_dependencies( stdafx zlib-project )
-  else ()
-    add_dependencies( libi2pd zlib-project )
-  endif ()
-  # ExternalProject_Get_Property(zlib-project install_dir)
-  set ( ZLIB_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/zlib/include" CACHE FILEPATH "zlib include dir" FORCE)
-  if (NOT WITH_STATIC)
-    set ( ZLIB_LIBRARY debug zlibd optimized zlib CACHE STRING "zlib libraries" FORCE)
-  endif ()
-  link_directories(${CMAKE_CURRENT_BINARY_DIR}/zlib/lib)
-else()
-  link_directories(${ZLIB_ROOT}/lib)
-endif ()
-if (WITH_STATIC AND (MSVC OR MSYS))
-  set ( ZLIB_LIBRARY debug zlibstaticd optimized zlibstatic CACHE STRING "zlib libraries" FORCE)
-endif ()
-
-# load includes
-include_directories( SYSTEM ${Boost_INCLUDE_DIRS} ${OPENSSL_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} )
-
-
-# warn if for meshnet
-if (WITH_MESHNET)
-  message(STATUS "Building for testnet")
-  message(WARNING "This build will NOT work on mainline i2p")
-endif()
-
-include(CheckAtomic)
-
-
-# show summary
-message(STATUS "---------------------------------------")
-message(STATUS "Build type         : ${CMAKE_BUILD_TYPE}")
-message(STATUS "Compiler vendor    : ${CMAKE_CXX_COMPILER_ID}")
-message(STATUS "Compiler version   : ${CMAKE_CXX_COMPILER_VERSION}")
-message(STATUS "Compiler path      : ${CMAKE_CXX_COMPILER}")
-message(STATUS "Architecture       : ${ARCHITECTURE}")
-message(STATUS "Install prefix:    : ${CMAKE_INSTALL_PREFIX}")
-message(STATUS "Options:")
-message(STATUS "  AESNI            : ${WITH_AESNI}")
-message(STATUS "  AVX              : ${WITH_AVX}")
-message(STATUS "  HARDENING        : ${WITH_HARDENING}")
-message(STATUS "  LIBRARY          : ${WITH_LIBRARY}")
-message(STATUS "  BINARY           : ${WITH_BINARY}")
-message(STATUS "  STATIC BUILD     : ${WITH_STATIC}")
-message(STATUS "  UPnP             : ${WITH_UPNP}")
-message(STATUS "  PCH              : ${WITH_PCH}")
-message(STATUS "  MESHNET          : ${WITH_MESHNET}")
-message(STATUS "  ADDRSANITIZER    : ${WITH_ADDRSANITIZER}")
-message(STATUS "  THREADSANITIZER  : ${WITH_THREADSANITIZER}")
-message(STATUS "  I2LUA            : ${WITH_I2LUA}")
-message(STATUS "  WEBSOCKETS       : ${WITH_WEBSOCKETS}")
-message(STATUS "---------------------------------------")
-
-#Handle paths nicely
-include(GNUInstallDirs)
-
-if (WITH_BINARY)
-  add_executable ( "${PROJECT_NAME}" ${DAEMON_SRC} )
-  if (WIN32 AND WITH_GUI)
-    set_target_properties("${PROJECT_NAME}" PROPERTIES WIN32_EXECUTABLE TRUE )
-  endif()
-  if(NOT MSVC)
-    if (WITH_STATIC)
-      set_target_properties("${PROJECT_NAME}" PROPERTIES LINK_FLAGS "-static" )
-    endif ()
-  endif()
-
-  if (WITH_PCH)
-    if (MSVC)
-      target_compile_options("${PROJECT_NAME}" PRIVATE /FIstdafx.h /Yustdafx.h /Zm155 "/Fp${CMAKE_BINARY_DIR}/stdafx.dir/$<CONFIG>/stdafx.pch")
-    else()
-      target_compile_options("${PROJECT_NAME}" PRIVATE -include libi2pd/stdafx.h)
-    endif()
-  endif()
-
-  if (WITH_HARDENING AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT MSYS AND NOT MINGW)
-    set_target_properties("${PROJECT_NAME}" PROPERTIES LINK_FLAGS "-z relro -z now" )
-  endif ()
-
-  if (WITH_UPNP)
-	  target_link_libraries("${PROJECT_NAME}" "${MINIUPNPC_LIBRARY}")
-  endif ()
-
-  # FindBoost pulls pthread for thread which is broken for static linking at least on Ubuntu 15.04
-  list(GET Boost_LIBRARIES -1 LAST_Boost_LIBRARIES)
-  if(${LAST_Boost_LIBRARIES} MATCHES ".*pthread.*")
-    list(REMOVE_AT Boost_LIBRARIES -1)
-  endif()
-
-  if (MSYS OR MINGW)
-    set (MINGW_EXTRA -lws2_32 -lmswsock -liphlpapi )
-  endif ()
-  if (WITH_STATIC)
-    set(DL_LIB ${CMAKE_DL_LIBS})
-  endif()
-  target_link_libraries( "${PROJECT_NAME}" libi2pd i2pdclient ${DL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${ZLIB_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${MINGW_EXTRA} ${DL_LIB} ${CMAKE_REQUIRED_LIBRARIES})
-
-  install(TARGETS "${PROJECT_NAME}" RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime)
-  set (APPS "\${CMAKE_INSTALL_PREFIX}/bin/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}")
-  set (DIRS "${Boost_LIBRARY_DIR};${OPENSSL_INCLUDE_DIR}/../bin;${ZLIB_INCLUDE_DIR}/../bin;/mingw32/bin")
-  if (MSVC)
-    install(FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION ${CMAKE_INSTALL_BINDIR} CONFIGURATIONS DEBUG RELWITHDEBINFO COMPONENT Symbols)
-    # TODO Somehow this picks lots of unrelevant stuff with MSYS. OS X testing needed.
-    INSTALL(CODE "
-      include(BundleUtilities)
-      fixup_bundle(\"${APPS}\"   \"\"   \"${DIRS}\")
-      " COMPONENT Runtime)
-  endif ()
-endif ()
-
-install(FILES ../LICENSE
-  DESTINATION .
-  COMPONENT Runtime
-  )
-# Take a copy on Appveyor
-install(FILES "C:/projects/openssl-$ENV{OPENSSL}/LICENSE"
-  DESTINATION .
-  COMPONENT Runtime
-  RENAME LICENSE_OPENSSL
-  OPTIONAL                      # for local builds only!
-  )
-
-file(GLOB_RECURSE I2PD_SOURCES "../libi2pd/*.cpp" "../libi2pd_client/*.cpp" "../daemon/*.cpp" "../build" "../Win32" "../Makefile*")
-install(FILES ${I2PD_SOURCES} DESTINATION src/ COMPONENT Source)
-# install(DIRECTORY ../ DESTINATION src/
-#   # OPTIONAL
-#   COMPONENT Source FILES_MATCHING
-#   PATTERN .git EXCLUDE
-#   PATTERN "*.cpp"
-#   )
-
-file(GLOB I2PD_HEADERS "../libi2pd/*.h" "../libi2pd_client/*.h" "../daemon/*.h")
-install(FILES ${I2PD_HEADERS} DESTINATION src/ COMPONENT Headers)
-# install(DIRECTORY ../ DESTINATION src/
-#   # OPTIONAL
-#   COMPONENT Headers FILES_MATCHING
-#   PATTERN .git EXCLUDE
-#   PATTERN "*.h"
-#   )
-
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Purple I2P, a C++ I2P daemon")
-set(CPACK_PACKAGE_VENDOR "Purple I2P")
-set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/../README.md")
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/../LICENSE")
-file(READ ../libi2pd/version.h version_h)
-string(REGEX REPLACE ".*I2PD_VERSION_MAJOR ([0-9]+).*" "\\1" CPACK_PACKAGE_VERSION_MAJOR "${version_h}")
-string(REGEX REPLACE ".*I2PD_VERSION_MINOR ([0-9]+).*" "\\1" CPACK_PACKAGE_VERSION_MINOR "${version_h}")
-string(REGEX REPLACE ".*I2PD_VERSION_MICRO ([0-9]+).*" "\\1" CPACK_PACKAGE_VERSION_MICRO "${version_h}")
-string(REGEX REPLACE ".*I2PD_VERSION_PATCH ([0-9]+).*" "\\1" CPACK_PACKAGE_VERSION_PATCH "${version_h}")
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "Purple I2P")# ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
-include(CPackComponent)
-cpack_add_component(Runtime
-  DESCRIPTION "Main files"
-  REQUIRED INSTALL_TYPES minimal)
-cpack_add_component(Symbols
-  DISPLAY_NAME "Debug symbols"
-  DESCRIPTION "Debug symbols for use with WinDbg or Visual Studio"
-  INSTALL_TYPES recommended full
-  )
-cpack_add_component(Libraries
-  DESCRIPTION "Binary libraries for development"
-  INSTALL_TYPES full dev3rd
-  )
-cpack_add_component(Source
-  DISPLAY_NAME "Source code"
-  DESCRIPTION "I2pd source code"
-  INSTALL_TYPES full
-  )
-cpack_add_component(Headers
-  DISPLAY_NAME "Header files"
-  DESCRIPTION "I2pd header files for development"
-  INSTALL_TYPES full dev3rd
-  )
-install(FILES ${MINIUPNPC_INCLUDE_DIR}/miniupnpc/miniupnpc.dll
-  DESTINATION bin
-  COMPONENT MiniUPnPc
-  OPTIONAL
-  )
-install(FILES ${MINIUPNPC_INCLUDE_DIR}/miniupnpc/LICENSE
-  DESTINATION .
-  COMPONENT MiniUPnPc
-  RENAME LICENSE_MINIUPNPC
-  OPTIONAL
-  )
-cpack_add_component(MiniUPnPc
-  INSTALL_TYPES full recommended
-  # DOWNLOADED
-  # ARCHIVE_FILE miniupnpc-win32.zip
-  )
-cpack_add_install_type(recommended DISPLAY_NAME Recommended)
-cpack_add_install_type(dev3rd DISPLAY_NAME "Third party development")
-cpack_add_install_type(full DISPLAY_NAME Full)
-cpack_add_install_type(minimal DISPLAY_NAME Minimal)
-if((WIN32 OR MSYS) AND NOT UNIX)
-  # There is a bug in NSI that does not handle full unix paths properly. Make
-  # sure there is at least one set of four (4) backlasshes.
-  set(CPACK_NSIS_DEFINES "RequestExecutionLevel user")
-  set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/../Win32\\\\mask.bmp")
-  set(CPACK_NSIS_INSTALLED_ICON_NAME "bin/i2pd.exe")
-  SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
-  set(CPACK_NSIS_HELP_LINK "https:\\\\\\\\github.com\\\\PurpleI2P\\\\i2pd\\\\issues")
-  set(CPACK_NSIS_URL_INFO_ABOUT "https:\\\\\\\\github.com\\\\PurpleI2P\\\\i2pd")
-  set(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Install i2pd as windows service.lnk' '$INSTDIR\\\\bin\\\\i2pd.exe' '--service=install'
-CreateShortCut '$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Remove i2pd windows service.lnk' '$INSTDIR\\\\bin\\\\i2pd.exe' '--service=remove'")
-  set(CPACK_NSIS_DELETE_ICONS_EXTRA "Delete '$SMPROGRAMS\\\\$START_MENU\\\\Install i2pd as windows service.lnk'
-Delete '$SMPROGRAMS\\\\$START_MENU\\\\Remove i2pd windows service.lnk'")
-else()
-  set(CPACK_STRIP_FILES "bin/i2pd")
-  set(CPACK_SOURCE_STRIP_FILES "")
-endif()
-set(CPACK_PACKAGE_EXECUTABLES "i2pd" "C++ I2P daemon")
-set(CPACK_SOURCE_GENERATOR "TGZ")
-include(CPack)

build/build_mingw.cmd

@@ -1,72 +0,0 @@
-@echo off
-setlocal enableextensions enabledelayedexpansion
-title Building i2pd
-
-REM Copyright (c) 2013-2017, The PurpleI2P Project
-REM This file is part of Purple i2pd project and licensed under BSD3
-REM See full license text in LICENSE file at top of project tree
-
-REM To use that script, you must have installed in your MSYS installation these packages:
-REM Base: git make zip
-REM x86_64: mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-gcc
-REM i686: mingw-w64-i686-boost mingw-w64-i686-openssl mingw-w64-i686-gcc
-
-REM setting up variables for MSYS
-REM Note: if you installed MSYS64 to different path, edit WD variable (only C:\msys64 needed to edit)!
-set "WD=C:\msys64\usr\bin\"
-set MSYS2_PATH_TYPE=inherit
-set CHERE_INVOKING=enabled_from_arguments
-set MSYSTEM=MSYS
-
-set "xSH=%WD%bash -lc"
-
-REM detecting number of processors and subtract 1.
-set /a threads=%NUMBER_OF_PROCESSORS%-1
-
-REM we must work in root of repo
-cd ..
-
-REM deleting old log files
-del /S build_*.log >> nul
-
-echo Receiving latest commit and cleaning up...
-%xSH% "git pull && make clean" > build/build_git.log 2>&1
-echo.
-
-REM set to variable current commit hash
-FOR /F "usebackq" %%a IN (`%xSH% 'git describe --tags'`) DO (
- set tag=%%a
-)
-
-%xSH% "echo To use configs and certificates, move all files and certificates folder from contrib directory here. > README.txt" >> nul
-
-REM starting building
-set MSYSTEM=MINGW32
-set bitness=32
-call :BUILDING
-echo.
-
-set MSYSTEM=MINGW64
-set bitness=64
-call :BUILDING
-echo.
-
-del README.txt >> nul
-
-echo Build complete...
-pause
-exit /b 0
-
-:BUILDING
-%xSH% "make clean" >> nul
-echo Building i2pd %tag% for win%bitness%:
-echo Build AVX+AESNI...
-%xSH% "make USE_UPNP=yes USE_AVX=1 USE_AESNI=1 -j%threads% && zip -r9 build/i2pd_%tag%_win%bitness%_mingw_avx_aesni.zip i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates && make clean" > build/build_win%bitness%_avx_aesni.log 2>&1
-echo Build AVX...
-%xSH% "make USE_UPNP=yes USE_AVX=1 -j%threads% && zip -r9 build/i2pd_%tag%_win%bitness%_mingw_avx.zip i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates && make clean" > build/build_win%bitness%_avx.log 2>&1
-echo Build AESNI...
-%xSH% "make USE_UPNP=yes USE_AESNI=1 -j%threads% && zip -r9 build/i2pd_%tag%_win%bitness%_mingw_aesni.zip i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates && make clean" > build/build_win%bitness%_aesni.log 2>&1
-echo Build without extensions...
-%xSH% "make USE_UPNP=yes -j%threads% && zip -r9 build/i2pd_%tag%_win%bitness%_mingw.zip i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates && make clean" > build/build_win%bitness%.log 2>&1
-
-:EOF

build/cmake-zlib-amd64.patch

@@ -1,10 +0,0 @@
---- CMakeLists.txt.orig	2015-12-07 14:19:36.447689600 -0600
-+++ CMakeLists.txt	2015-12-07 14:18:23.004419900 -0600
-@@ -165,6 +165,7 @@
- 		ENABLE_LANGUAGE(ASM_MASM)
-         set(ZLIB_ASMS
- 			contrib/masmx64/gvmat64.asm
-+			contrib/masmx64/inffas8664.c
- 			contrib/masmx64/inffasx64.asm
- 		)
-     endif()

build/cmake-zlib-static.patch

@@ -1,28 +0,0 @@
---- CMakeLists.txt.orig	2013-04-28 17:57:10.000000000 -0500
-+++ CMakeLists.txt	2015-12-03 12:53:52.371087900 -0600
-@@ -7,6 +7,7 @@
- 
- option(ASM686 "Enable building i686 assembly implementation")
- option(AMD64 "Enable building amd64 assembly implementation")
-+option(WITH_STATIC    "Static runtime on Windows" OFF)
- 
- set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
- set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
-@@ -66,6 +67,17 @@
-     include_directories(${CMAKE_CURRENT_SOURCE_DIR})
- endif()
- 
-+if(WITH_STATIC AND (MSVC OR MSYS))
-+    # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace
-+    foreach(flag_var
-+            CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-+            CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
-+      if(${flag_var} MATCHES "/MD")
-+        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-+      endif(${flag_var} MATCHES "/MD")
-+    endforeach(flag_var)
-+endif()
-+
- if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
-     # If we're doing an out of source build and the user has a zconf.h
-     # in their source tree...

build/cmake_modules/CheckAtomic.cmake

@@ -1,106 +0,0 @@
-# atomic builtins are required for threading support.
-
-INCLUDE(CheckCXXSourceCompiles)
-
-# Sometimes linking against libatomic is required for atomic ops, if
-# the platform doesn't support lock-free atomics.
-
-function(check_working_cxx_atomics varname)
-  set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-  set(CMAKE_REQUIRED_FLAGS "-std=c++11")
-  CHECK_CXX_SOURCE_COMPILES("
-#include <atomic>
-std::atomic<int> x;
-int main() {
-  return x;
-}
-" ${varname})
-  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
-endfunction(check_working_cxx_atomics)
-
-function(check_working_cxx_atomics64 varname)
-  set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-  set(CMAKE_REQUIRED_FLAGS "-std=c++11 ${CMAKE_REQUIRED_FLAGS}")
-  CHECK_CXX_SOURCE_COMPILES("
-#include <atomic>
-#include <cstdint>
-std::atomic<uint64_t> x (0);
-int main() {
-  uint64_t i = x.load(std::memory_order_relaxed);
-  return 0;
-}
-" ${varname})
-  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
-endfunction(check_working_cxx_atomics64)
-
-
-# This isn't necessary on MSVC, so avoid command-line switch annoyance
-# by only running on GCC-like hosts.
-if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
-  # First check if atomics work without the library.
-  check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
-  # If not, check if the library exists, and atomics work with it.
-  if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
-    check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
-    if( HAVE_LIBATOMIC )
-      list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
-      check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
-      if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
-        message(FATAL_ERROR "Host compiler must support std::atomic!")
-      endif()
-    else()
-      message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
-    endif()
-  endif()
-endif()
-
-# Check for 64 bit atomic operations.
-if(MSVC)
-  set(HAVE_CXX_ATOMICS64_WITHOUT_LIB True)
-else()
-  check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
-endif()
-
-# If not, check if the library exists, and atomics work with it.
-if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
-  check_library_exists(atomic __atomic_load_8 "" HAVE_CXX_LIBATOMICS64)
-  if(HAVE_CXX_LIBATOMICS64)
-    list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
-    check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
-    if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
-      message(FATAL_ERROR "Host compiler must support std::atomic!")
-    endif()
-  else()
-    message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
-  endif()
-endif()
-
-## TODO: This define is only used for the legacy atomic operations in
-## llvm's Atomic.h, which should be replaced.  Other code simply
-## assumes C++11 <atomic> works.
-CHECK_CXX_SOURCE_COMPILES("
-#ifdef _MSC_VER
-#include <Intrin.h> /* Workaround for PR19898. */
-#include <windows.h>
-#endif
-int main() {
-#ifdef _MSC_VER
-        volatile LONG val = 1;
-        MemoryBarrier();
-        InterlockedCompareExchange(&val, 0, 1);
-        InterlockedIncrement(&val);
-        InterlockedDecrement(&val);
-#else
-        volatile unsigned long val = 1;
-        __sync_synchronize();
-        __sync_val_compare_and_swap(&val, 1, 0);
-        __sync_add_and_fetch(&val, 1);
-        __sync_sub_and_fetch(&val, 1);
-#endif
-        return 0;
-      }
-" LLVM_HAS_ATOMICS)
-
-if( NOT LLVM_HAS_ATOMICS )
-  message(STATUS "Warning: LLVM will be built thread-unsafe because atomic builtins are missing")
-endif()

build/cmake_modules/FindCryptoPP.cmake

@@ -0,0 +1,61 @@
+# - Find Crypto++
+
+if(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)
+   set(CRYPTO++_FOUND TRUE)
+
+else(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)
+  find_path(CRYPTO++_INCLUDE_DIR cryptopp/cryptlib.h
+      /usr/include
+      /usr/local/include
+      $ENV{SystemDrive}/Crypto++/include
+      $ENV{CRYPTOPP}
+      $ENV{CRYPTOPP}/..
+      $ENV{CRYPTOPP}/include
+      ${PROJECT_SOURCE_DIR}/../..
+      )
+
+  find_library(CRYPTO++_LIBRARIES NAMES cryptopp
+      PATHS
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      $ENV{SystemDrive}/Crypto++/lib
+      $ENV{CRYPTOPP}/lib
+      )
+
+  if(MSVC AND NOT CRYPTO++_LIBRARIES) # Give a chance for MSVC multiconfig
+      if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+          set(PLATFORM x64)
+      else()
+          set(PLATFORM Win32)
+      endif()
+      find_library(CRYPTO++_LIBRARIES_RELEASE NAMES cryptlib cryptopp
+          HINTS
+          ${PROJECT_SOURCE_DIR}/../../cryptopp/${PLATFORM}/Output/Release
+          PATHS
+          $ENV{CRYPTOPP}/Win32/Output/Release
+      )
+      find_library(CRYPTO++_LIBRARIES_DEBUG NAMES cryptlib cryptopp
+          HINTS
+          ${PROJECT_SOURCE_DIR}/../../cryptopp/${PLATFORM}/Output/Debug
+          PATHS
+          $ENV{CRYPTOPP}/Win32/Output/Debug
+      )
+      set(CRYPTO++_LIBRARIES
+          debug ${CRYPTO++_LIBRARIES_DEBUG}
+          optimized ${CRYPTO++_LIBRARIES_RELEASE}
+          CACHE PATH "Path to Crypto++ library" FORCE
+      )
+  endif()
+
+  if(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)
+    set(CRYPTO++_FOUND TRUE)
+    message(STATUS "Found Crypto++: ${CRYPTO++_INCLUDE_DIR}, ${CRYPTO++_LIBRARIES}")
+  else(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)
+    set(CRYPTO++_FOUND FALSE)
+    message(STATUS "Crypto++ not found.")
+  endif(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)
+
+  mark_as_advanced(CRYPTO++_INCLUDE_DIR CRYPTO++_LIBRARIES)
+
+endif(CRYPTO++_INCLUDE_DIR AND CRYPTO++_LIBRARIES)

build/cmake_modules/FindMiniUPnPc.cmake

@@ -1,28 +1,25 @@
 # - Find MINIUPNPC
 
-if(MINIUPNPC_INCLUDE_DIR AND MINIUPNPC_LIBRARY)
+if(MINIUPNPC_INCLUDE_DIR)
    set(MINIUPNPC_FOUND TRUE)
 
 else()
-  find_path(MINIUPNPC_INCLUDE_DIR miniupnpc/miniupnpc.h
-      /usr/include
-      /usr/local/include
-      /opt/local/include
-      $ENV{SystemDrive}
-      ${PROJECT_SOURCE_DIR}/../..
+  find_path(MINIUPNPC_INCLUDE_DIR miniupnpc.h
+      /usr/include/miniupnpc
+      /usr/local/include/miniupnpc
+      /opt/local/include/miniupnpc
+      $ENV{SystemDrive}/miniupnpc
+      ${PROJECT_SOURCE_DIR}/../../miniupnpc
       )
-
-  find_library(MINIUPNPC_LIBRARY miniupnpc)
-
-  if(MINIUPNPC_INCLUDE_DIR AND MINIUPNPC_LIBRARY)
+  
+  if(MINIUPNPC_INCLUDE_DIR)
     set(MINIUPNPC_FOUND TRUE)
     message(STATUS "Found MiniUPnP headers: ${MINIUPNPC_INCLUDE_DIR}")
-    message(STATUS "Found MiniUPnP library: ${MINIUPNPC_LIBRARY}")
   else()
     set(MINIUPNPC_FOUND FALSE)
     message(STATUS "MiniUPnP not found.")
   endif()
 
-  mark_as_advanced(MINIUPNPC_INCLUDE_DIR MINIUPNPC_LIBRARY)
-
+  mark_as_advanced(MINIUPNPC_INCLUDE_DIR)
+  
 endif()

build/cmake_modules/TargetArch.cmake

@@ -1,134 +0,0 @@
-# Based on the Qt 5 processor detection code, so should be very accurate
-# https://qt.gitorious.org/qt/qtbase/blobs/master/src/corelib/global/qprocessordetection.h
-# Currently handles arm (v5, v6, v7), x86 (32/64), ia64, and ppc (32/64)
-
-# Regarding POWER/PowerPC, just as is noted in the Qt source,
-# "There are many more known variants/revisions that we do not handle/detect."
-
-set(archdetect_c_code "
-#if defined(__arm__) || defined(__TARGET_ARCH_ARM)
-    #if defined(__ARM_ARCH_7__) \\
-        || defined(__ARM_ARCH_7A__) \\
-        || defined(__ARM_ARCH_7R__) \\
-        || defined(__ARM_ARCH_7M__) \\
-        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 7)
-        #error cmake_ARCH armv7
-    #elif defined(__ARM_ARCH_6__) \\
-        || defined(__ARM_ARCH_6J__) \\
-        || defined(__ARM_ARCH_6T2__) \\
-        || defined(__ARM_ARCH_6Z__) \\
-        || defined(__ARM_ARCH_6K__) \\
-        || defined(__ARM_ARCH_6ZK__) \\
-        || defined(__ARM_ARCH_6M__) \\
-        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 6)
-        #error cmake_ARCH armv6
-    #elif defined(__ARM_ARCH_5TEJ__) \\
-        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 5)
-        #error cmake_ARCH armv5
-    #else
-        #error cmake_ARCH arm
-    #endif
-#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
-    #error cmake_ARCH i386
-#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
-    #error cmake_ARCH x86_64
-#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
-    #error cmake_ARCH ia64
-#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \\
-      || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \\
-      || defined(_M_MPPC) || defined(_M_PPC)
-    #if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
-        #error cmake_ARCH ppc64
-    #else
-        #error cmake_ARCH ppc
-    #endif
-#endif
-
-#error cmake_ARCH unknown
-")
-
-# Set ppc_support to TRUE before including this file or ppc and ppc64
-# will be treated as invalid architectures since they are no longer supported by Apple
-
-function(target_architecture output_var)
-    if(APPLE AND CMAKE_OSX_ARCHITECTURES)
-        # On OS X we use CMAKE_OSX_ARCHITECTURES *if* it was set
-        # First let's normalize the order of the values
-
-        # Note that it's not possible to compile PowerPC applications if you are using
-        # the OS X SDK version 10.6 or later - you'll need 10.4/10.5 for that, so we
-        # disable it by default
-        # See this page for more information:
-        # http://stackoverflow.com/questions/5333490/how-can-we-restore-ppc-ppc64-as-well-as-full-10-4-10-5-sdk-support-to-xcode-4
-
-        # Architecture defaults to i386 or ppc on OS X 10.5 and earlier, depending on the CPU type detected at runtime.
-        # On OS X 10.6+ the default is x86_64 if the CPU supports it, i386 otherwise.
-
-        foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
-            if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
-                set(osx_arch_ppc TRUE)
-            elseif("${osx_arch}" STREQUAL "i386")
-                set(osx_arch_i386 TRUE)
-            elseif("${osx_arch}" STREQUAL "x86_64")
-                set(osx_arch_x86_64 TRUE)
-            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
-                set(osx_arch_ppc64 TRUE)
-            else()
-                message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
-            endif()
-        endforeach()
-
-        # Now add all the architectures in our normalized order
-        if(osx_arch_ppc)
-            list(APPEND ARCH ppc)
-        endif()
-
-        if(osx_arch_i386)
-            list(APPEND ARCH i386)
-        endif()
-
-        if(osx_arch_x86_64)
-            list(APPEND ARCH x86_64)
-        endif()
-
-        if(osx_arch_ppc64)
-            list(APPEND ARCH ppc64)
-        endif()
-    else()
-        file(WRITE "${CMAKE_BINARY_DIR}/arch.c" "${archdetect_c_code}")
-
-        enable_language(C)
-
-        # Detect the architecture in a rather creative way...
-        # This compiles a small C program which is a series of ifdefs that selects a
-        # particular #error preprocessor directive whose message string contains the
-        # target architecture. The program will always fail to compile (both because
-        # file is not a valid C program, and obviously because of the presence of the
-        # #error preprocessor directives... but by exploiting the preprocessor in this
-        # way, we can detect the correct target architecture even when cross-compiling,
-        # since the program itself never needs to be run (only the compiler/preprocessor)
-        try_run(
-            run_result_unused
-            compile_result_unused
-            "${CMAKE_BINARY_DIR}"
-            "${CMAKE_BINARY_DIR}/arch.c"
-            COMPILE_OUTPUT_VARIABLE ARCH
-            CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        )
-
-        # Parse the architecture name from the compiler output
-        string(REGEX MATCH "cmake_ARCH ([a-zA-Z0-9_]+)" ARCH "${ARCH}")
-
-        # Get rid of the value marker leaving just the architecture name
-        string(REPLACE "cmake_ARCH " "" ARCH "${ARCH}")
-
-        # If we are compiling with an unknown architecture this variable should
-        # already be set to "unknown" but in the case that it's empty (i.e. due
-        # to a typo in the code), then set it to unknown
-        if (NOT ARCH)
-            set(ARCH unknown)
-        endif()
-    endif()
-
-    set(${output_var} "${ARCH}" PARENT_SCOPE)
-endfunction()

build/docker/README.md

@@ -1,34 +0,0 @@
-Howto build & run
-==================
-
-**Build**
-
-Assuming you're in the root directory of the anoncoin source code.
-
-$ `cd build/docker`
-$ `docker -t meeh/i2pd:latest .`
-
-**Run**
-
-To run either the local build, or if not found - fetched prebuild from hub.docker.io, run the following command.
-
-$ `docker run --name anonnode -v /path/to/i2pd/datadir/on/host:/var/lib/i2pd -p 7070:7070 -p 4444:4444 -p 4447:4447 -p 7656:7656 -p 2827:2827 -p 7654:7654 -p 7650:7650  -d meeh/i2pd`
-
-All the ports ( -p HOSTPORT:DOCKERPORT ) is optional. However the command above enable all features (Webconsole, HTTP Proxy, BOB, SAM, i2cp, etc)
-
-The volume ( -v HOSTDIR:DOCKERDIR ) is also optional, but if you don't use it, your config, routerid and private keys will die along with the container.
-
-**Options**
-
-Options are set via docker environment variables. This can be set at run with -e parameters.
-
-* **ENABLE_IPV6**   - Enable IPv6 support. Any value can be used - it triggers as long as it's not empty.
-* **LOGLEVEL**      - Set the loglevel.
-* **ENABLE_AUTH**   - Enable auth for the webconsole. Username and password needs to be set manually in i2pd.conf cause security reasons.
-
-**Logging**
-
-Logging happens to STDOUT as the best practise with docker containers, since infrastructure systems like kubernetes with ELK integration can automatically forward the log to say, kibana or greylog without manual setup. :)
-
-
-

build/docker/old-ubuntu-based/Dockerfile

@@ -1,11 +0,0 @@
-FROM ubuntu
-
-RUN apt-get update && apt-get install -y libboost-dev libboost-filesystem-dev \
-       libboost-program-options-dev libboost-date-time-dev \
-       libssl-dev git build-essential
-
-RUN git clone https://github.com/PurpleI2P/i2pd.git
-WORKDIR /i2pd
-RUN make
-
-CMD ./i2pd

build/fig.yml

@@ -1,2 +0,0 @@
-i2pd:
-    build: .

client/BOB.cpp

@@ -0,0 +1,645 @@
+#include <string.h>
+#include <boost/lexical_cast.hpp>
+#include "util/Log.h"
+#include "ClientContext.h"
+#include "BOB.h"
+
+namespace i2p
+{
+namespace client
+{
+    BOBI2PInboundTunnel::BOBI2PInboundTunnel (int port, std::shared_ptr<ClientDestination> localDestination): 
+        BOBI2PTunnel (localDestination), 
+        m_Acceptor (localDestination->GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port))
+    {
+    }
+
+    BOBI2PInboundTunnel::~BOBI2PInboundTunnel ()
+    {
+        Stop ();
+    }
+
+    void BOBI2PInboundTunnel::Start ()
+    {
+        m_Acceptor.listen ();
+        Accept ();
+    }
+
+    void BOBI2PInboundTunnel::Stop ()
+    {
+        m_Acceptor.close();
+        ClearHandlers ();
+    }
+
+    void BOBI2PInboundTunnel::Accept ()
+    {
+        auto receiver = std::make_shared<AddressReceiver> ();
+        receiver->socket = std::make_shared<boost::asio::ip::tcp::socket> (GetService ());
+        m_Acceptor.async_accept (*receiver->socket, std::bind (&BOBI2PInboundTunnel::HandleAccept, this,
+            std::placeholders::_1, receiver));
+    }   
+
+    void BOBI2PInboundTunnel::HandleAccept (const boost::system::error_code& ecode, std::shared_ptr<AddressReceiver> receiver)
+    {
+        if (!ecode)
+        {
+            Accept ();  
+            ReceiveAddress (receiver);
+        }
+    }
+
+    void BOBI2PInboundTunnel::ReceiveAddress (std::shared_ptr<AddressReceiver> receiver)
+    {
+        receiver->socket->async_read_some (boost::asio::buffer(
+                receiver->buffer + receiver->bufferOffset, 
+                BOB_COMMAND_BUFFER_SIZE - receiver->bufferOffset),                
+            std::bind(&BOBI2PInboundTunnel::HandleReceivedAddress, this, 
+                std::placeholders::_1, std::placeholders::_2, receiver));
+    }
+    
+    void BOBI2PInboundTunnel::HandleReceivedAddress (const boost::system::error_code& ecode, std::size_t bytes_transferred,
+        std::shared_ptr<AddressReceiver> receiver)
+    {
+        if (ecode)
+            LogPrint ("BOB inbound tunnel read error: ", ecode.message ());
+        else
+        {
+            receiver->bufferOffset += bytes_transferred;
+            receiver->buffer[receiver->bufferOffset] = 0;
+            char * eol = strchr (receiver->buffer, '\n');
+            if (eol)
+            {
+                *eol = 0;
+                
+                receiver->data = (uint8_t *)eol + 1;
+                receiver->dataLen = receiver->bufferOffset - (eol - receiver->buffer + 1);
+                i2p::data::IdentHash ident;
+                if (!context.GetAddressBook ().GetIdentHash (receiver->buffer, ident)) 
+                {
+                    LogPrint (eLogError, "BOB address ", receiver->buffer, " not found");
+                    return;
+                }
+                auto leaseSet = GetLocalDestination ()->FindLeaseSet (ident);
+                if (leaseSet)
+                    CreateConnection (receiver, leaseSet);
+                else
+                    GetLocalDestination ()->RequestDestination (ident, 
+                        std::bind (&BOBI2PInboundTunnel::HandleDestinationRequestComplete,
+                        this, std::placeholders::_1, receiver));
+            }
+            else
+            {
+                if (receiver->bufferOffset < BOB_COMMAND_BUFFER_SIZE)
+                    ReceiveAddress (receiver);
+                else
+                    LogPrint ("BOB missing inbound address ");
+            }           
+        }
+    }
+
+    void BOBI2PInboundTunnel::HandleDestinationRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, std::shared_ptr<AddressReceiver> receiver)
+    {
+        if (leaseSet)
+            CreateConnection (receiver, leaseSet);
+        else
+            LogPrint ("LeaseSet for BOB inbound destination not found");
+    }   
+
+    void BOBI2PInboundTunnel::CreateConnection (std::shared_ptr<AddressReceiver> receiver, std::shared_ptr<const i2p::data::LeaseSet> leaseSet)
+    {
+        LogPrint ("New BOB inbound connection");
+        auto connection = std::make_shared<I2PTunnelConnection>(this, receiver->socket, leaseSet);
+        AddHandler (connection);
+        connection->I2PConnect (receiver->data, receiver->dataLen);
+    }
+
+    BOBI2POutboundTunnel::BOBI2POutboundTunnel (const std::string& address, int port, 
+        std::shared_ptr<ClientDestination> localDestination, bool quiet): BOBI2PTunnel (localDestination),
+        m_Endpoint (boost::asio::ip::address::from_string (address), port), m_IsQuiet (quiet)
+    {
+    }
+    
+    void BOBI2POutboundTunnel::Start ()
+    {
+        Accept ();
+    }
+
+    void BOBI2POutboundTunnel::Stop ()
+    {
+        ClearHandlers ();
+    }   
+
+    void BOBI2POutboundTunnel::Accept ()
+    {
+        auto localDestination = GetLocalDestination (); 
+        if (localDestination)
+            localDestination->AcceptStreams (std::bind (&BOBI2POutboundTunnel::HandleAccept, this, std::placeholders::_1));
+        else
+            LogPrint ("Local destination not set for server tunnel");
+    }
+
+    void BOBI2POutboundTunnel::HandleAccept (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {   
+            auto conn = std::make_shared<I2PTunnelConnection> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), m_Endpoint, m_IsQuiet);
+            AddHandler (conn);
+            conn->Connect ();
+        }   
+    }
+
+    BOBDestination::BOBDestination (std::shared_ptr<ClientDestination> localDestination):
+        m_LocalDestination (localDestination), 
+        m_OutboundTunnel (nullptr), m_InboundTunnel (nullptr)
+    {
+    }
+        
+    BOBDestination::~BOBDestination ()
+    {
+        delete m_OutboundTunnel;
+        delete m_InboundTunnel;
+        i2p::client::context.DeleteLocalDestination (m_LocalDestination);
+    }   
+
+    void BOBDestination::Start ()
+    {
+        if (m_OutboundTunnel) m_OutboundTunnel->Start ();
+        if (m_InboundTunnel) m_InboundTunnel->Start ();
+    }
+        
+    void BOBDestination::Stop ()
+    {       
+        StopTunnels ();
+        m_LocalDestination->Stop ();
+    }   
+
+    void BOBDestination::StopTunnels ()
+    {
+        if (m_OutboundTunnel)
+        {   
+            m_OutboundTunnel->Stop ();
+            delete m_OutboundTunnel;
+            m_OutboundTunnel = nullptr;
+        }   
+        if (m_InboundTunnel)
+        {   
+            m_InboundTunnel->Stop ();
+            delete m_InboundTunnel;
+            m_InboundTunnel = nullptr;
+        }   
+    }   
+        
+    void BOBDestination::CreateInboundTunnel (int port)
+    {
+        if (!m_InboundTunnel)
+            m_InboundTunnel = new BOBI2PInboundTunnel (port, m_LocalDestination);
+    }
+        
+    void BOBDestination::CreateOutboundTunnel (const std::string& address, int port, bool quiet)
+    {
+        if (!m_OutboundTunnel)
+            m_OutboundTunnel = new BOBI2POutboundTunnel (address, port, m_LocalDestination, quiet);
+    }   
+        
+    BOBCommandSession::BOBCommandSession (BOBCommandChannel& owner): 
+        m_Owner (owner), m_Socket (m_Owner.GetService ()), m_ReceiveBufferOffset (0),
+        m_IsOpen (true), m_IsQuiet (false), m_InPort (0), m_OutPort (0),
+        m_CurrentDestination (nullptr)
+    {
+    }
+
+    BOBCommandSession::~BOBCommandSession ()
+    {
+    }
+
+    void BOBCommandSession::Terminate ()
+    {
+        m_Socket.close ();
+        m_IsOpen = false;   
+    }
+
+    void BOBCommandSession::Receive ()
+    {
+        m_Socket.async_read_some (boost::asio::buffer(m_ReceiveBuffer + m_ReceiveBufferOffset, BOB_COMMAND_BUFFER_SIZE - m_ReceiveBufferOffset),                
+            std::bind(&BOBCommandSession::HandleReceived, shared_from_this (), 
+            std::placeholders::_1, std::placeholders::_2));
+    }
+
+    void BOBCommandSession::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("BOB command channel read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }   
+        else
+        {   
+            size_t size = m_ReceiveBufferOffset + bytes_transferred; 
+            m_ReceiveBuffer[size] = 0;
+            char * eol = strchr (m_ReceiveBuffer, '\n');
+            if (eol)
+            {
+                *eol = 0;
+                char * operand =  strchr (m_ReceiveBuffer, ' ');
+                if (operand)  
+                {   
+                    *operand = 0;
+                    operand++;
+                }   
+                else 
+                    operand = eol;
+                // process command
+                auto& handlers = m_Owner.GetCommandHandlers ();
+                auto it = handlers.find (m_ReceiveBuffer);
+                if (it != handlers.end ())
+                    (this->*(it->second))(operand, eol - operand);
+                else    
+                {
+                    LogPrint (eLogError, "BOB unknown command ", m_ReceiveBuffer);
+                    SendReplyError ("unknown command");
+                }
+
+                m_ReceiveBufferOffset = size - (eol - m_ReceiveBuffer) - 1;
+                memmove (m_ReceiveBuffer, eol + 1, m_ReceiveBufferOffset);
+            }
+            else
+            {
+                if (size < BOB_COMMAND_BUFFER_SIZE)
+                    m_ReceiveBufferOffset = size;
+                else
+                {
+                    LogPrint (eLogError, "Malformed input of the BOB command channel");
+                    Terminate ();
+                }
+            }   
+        }
+    }
+
+    void BOBCommandSession::Send (size_t len)
+    {
+        boost::asio::async_write (m_Socket, boost::asio::buffer (m_SendBuffer, len), 
+            boost::asio::transfer_all (),
+            std::bind(&BOBCommandSession::HandleSent, shared_from_this (), 
+                std::placeholders::_1, std::placeholders::_2));
+    }
+
+    void BOBCommandSession::HandleSent (const boost::system::error_code& ecode, std::size_t)
+    {
+        if (ecode)
+        {
+            LogPrint ("BOB command channel send error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            if (m_IsOpen)
+                Receive ();
+            else
+                Terminate ();   
+        }
+    }
+
+    void BOBCommandSession::SendReplyOK (const char * msg)
+    {
+#ifdef _MSC_VER
+        size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_OK, msg);
+#else       
+        size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_OK, msg);
+#endif
+        Send (len);
+    }
+
+    void BOBCommandSession::SendReplyError (const char * msg)
+    {
+#ifdef _MSC_VER
+        size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_ERROR, msg);
+#else       
+        size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_REPLY_ERROR, msg);
+#endif
+        Send (len); 
+    }
+        
+    void BOBCommandSession::SendVersion ()
+    {
+        size_t len = strlen (BOB_VERSION);
+        memcpy (m_SendBuffer, BOB_VERSION, len);
+        Send (len);
+    }
+
+    void BOBCommandSession::SendData (const char * nickname)
+    {
+#ifdef _MSC_VER
+        size_t len = sprintf_s (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_DATA, nickname);
+#else       
+        size_t len = snprintf (m_SendBuffer, BOB_COMMAND_BUFFER_SIZE, BOB_DATA, nickname);
+#endif
+        Send (len);         
+    }
+        
+    void BOBCommandSession::ZapCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: zap");
+        Terminate ();
+    }
+
+    void BOBCommandSession::QuitCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: quit");
+        m_IsOpen = false;
+        SendReplyOK ("Bye!");
+    }
+
+    void BOBCommandSession::StartCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: start ", m_Nickname);
+        if (!m_CurrentDestination)
+        {   
+            m_CurrentDestination = new BOBDestination (i2p::client::context.CreateNewLocalDestination (m_Keys, true, &m_Options));
+            m_Owner.AddDestination (m_Nickname, m_CurrentDestination);
+        }   
+        if (m_InPort)
+            m_CurrentDestination->CreateInboundTunnel (m_InPort);
+        if (m_OutPort && !m_Address.empty ())
+            m_CurrentDestination->CreateOutboundTunnel (m_Address, m_OutPort, m_IsQuiet);
+        m_CurrentDestination->Start (); 
+        SendReplyOK ("tunnel starting");    
+    }   
+    
+    void BOBCommandSession::StopCommandHandler (const char*, size_t)
+    {
+        auto dest = m_Owner.FindDestination (m_Nickname);
+        if (dest)
+        {
+            dest->StopTunnels ();
+            SendReplyOK ("tunnel stopping");
+        }
+        else
+            SendReplyError ("tunnel not found");
+    }   
+    
+    void BOBCommandSession::SetNickCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: setnick ", operand);
+        m_Nickname = operand;
+        std::string msg ("Nickname set to ");
+        msg += operand;
+        SendReplyOK (msg.c_str ());
+    }   
+
+    void BOBCommandSession::GetNickCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: getnick ", operand);
+        m_CurrentDestination = m_Owner.FindDestination (operand); 
+        if (m_CurrentDestination)
+        {
+            m_Keys = m_CurrentDestination->GetKeys ();
+            m_Nickname = operand;
+            std::string msg ("Nickname set to ");
+            msg += operand;
+            SendReplyOK (msg.c_str ());
+        }
+        else
+            SendReplyError ("tunnel not found");    
+    }   
+
+    void BOBCommandSession::NewkeysCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: newkeys");
+        m_Keys = i2p::data::PrivateKeys::CreateRandomKeys ();
+        SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
+    }   
+
+    void BOBCommandSession::SetkeysCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: setkeys ", operand);
+        m_Keys.FromBase64 (operand);
+        SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
+    }
+        
+    void BOBCommandSession::GetkeysCommandHandler (const char *, size_t)
+    {       
+        LogPrint (eLogDebug, "BOB: getkeys");
+        SendReplyOK (m_Keys.ToBase64 ().c_str ());
+    }   
+
+    void BOBCommandSession::GetdestCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: getdest");
+        SendReplyOK (m_Keys.GetPublic ().ToBase64 ().c_str ());
+    }   
+        
+    void BOBCommandSession::OuthostCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: outhost ", operand);
+        m_Address = operand;
+        SendReplyOK ("outhost set");
+    }
+        
+    void BOBCommandSession::OutportCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: outport ", operand);
+        m_OutPort = boost::lexical_cast<int>(operand);
+        SendReplyOK ("outbound port set");
+    }   
+
+    void BOBCommandSession::InhostCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: inhost ", operand);
+        m_Address = operand;
+        SendReplyOK ("inhost set");
+    }
+        
+    void BOBCommandSession::InportCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: inport ", operand);
+        m_InPort = boost::lexical_cast<int>(operand);
+        SendReplyOK ("inbound port set");
+    }       
+
+    void BOBCommandSession::QuietCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: quiet");
+        m_IsQuiet = true;
+        SendReplyOK ("quiet");
+    }   
+    
+    void BOBCommandSession::LookupCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: lookup ", operand);
+        i2p::data::IdentHash ident;
+        if (!context.GetAddressBook ().GetIdentHash (operand, ident) || !m_CurrentDestination) 
+        {
+            SendReplyError ("Address Not found");
+            return;
+        }   
+        auto localDestination = m_CurrentDestination->GetLocalDestination ();
+        auto leaseSet = localDestination->FindLeaseSet (ident);
+        if (leaseSet)
+            SendReplyOK (leaseSet->GetIdentity ().ToBase64 ().c_str ());
+        else
+        {
+            auto s = shared_from_this ();
+            localDestination->RequestDestination (ident, 
+                [s](std::shared_ptr<i2p::data::LeaseSet> ls)
+                {
+                    if (ls)
+                        s->SendReplyOK (ls->GetIdentity ().ToBase64 ().c_str ());
+                    else    
+                        s->SendReplyError ("LeaseSet Not found");
+                }   
+            );
+        }
+    }
+
+    void BOBCommandSession::ClearCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: clear");
+        m_Owner.DeleteDestination (m_Nickname);
+        SendReplyOK ("cleared");
+    }   
+
+    void BOBCommandSession::ListCommandHandler (const char*, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: list");
+        auto& destinations = m_Owner.GetDestinations ();
+        for (auto it: destinations)
+            SendData (it.first.c_str ());
+        SendReplyOK ("Listing done");
+    }   
+
+    void BOBCommandSession::OptionCommandHandler (const char * operand, size_t)
+    {
+        LogPrint (eLogDebug, "BOB: option ", operand);
+        const char * value = strchr (operand, '=');
+        if (value)
+        {   
+            *(const_cast<char *>(value)) = 0;
+            m_Options[operand] = value + 1; 
+            *(const_cast<char *>(value)) = '=';
+            SendReplyOK ("option");
+        }   
+        else
+            SendReplyError ("malformed");
+    }   
+        
+    BOBCommandChannel::BOBCommandChannel(const std::string& address, int port)
+        : m_IsRunning (false), m_Thread (nullptr),
+          m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
+            boost::asio::ip::address::from_string(address), port)
+          )
+    {
+        // command -> handler
+        m_CommandHandlers[BOB_COMMAND_ZAP] = &BOBCommandSession::ZapCommandHandler; 
+        m_CommandHandlers[BOB_COMMAND_QUIT] = &BOBCommandSession::QuitCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_START] = &BOBCommandSession::StartCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_STOP] = &BOBCommandSession::StopCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_SETNICK] = &BOBCommandSession::SetNickCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_GETNICK] = &BOBCommandSession::GetNickCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_NEWKEYS] = &BOBCommandSession::NewkeysCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_GETKEYS] = &BOBCommandSession::GetkeysCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_SETKEYS] = &BOBCommandSession::SetkeysCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_GETDEST] = &BOBCommandSession::GetdestCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_OUTHOST] = &BOBCommandSession::OuthostCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_OUTPORT] = &BOBCommandSession::OutportCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_INHOST] = &BOBCommandSession::InhostCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_INPORT] = &BOBCommandSession::InportCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_QUIET] = &BOBCommandSession::QuietCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_LOOKUP] = &BOBCommandSession::LookupCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_CLEAR] = &BOBCommandSession::ClearCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_LIST] = &BOBCommandSession::ListCommandHandler;
+        m_CommandHandlers[BOB_COMMAND_OPTION] = &BOBCommandSession::OptionCommandHandler;
+    }
+
+    BOBCommandChannel::~BOBCommandChannel ()
+    {
+        Stop ();
+        for (auto it: m_Destinations)
+            delete it.second;
+    }
+
+    void BOBCommandChannel::Start ()
+    {
+        Accept ();
+        m_IsRunning = true;
+        m_Thread = new std::thread (std::bind (&BOBCommandChannel::Run, this));
+    }
+
+    void BOBCommandChannel::Stop ()
+    {
+        m_IsRunning = false;
+        for (auto it: m_Destinations)
+            it.second->Stop ();
+        m_Acceptor.cancel ();   
+        m_Service.stop ();
+        if (m_Thread)
+        {   
+            m_Thread->join (); 
+            delete m_Thread;
+            m_Thread = nullptr;
+        }   
+    }
+        
+    void BOBCommandChannel::Run () 
+    { 
+        while (m_IsRunning)
+        {
+            try
+            {   
+                m_Service.run ();
+            }
+            catch (std::exception& ex)
+            {
+                LogPrint (eLogError, "BOB: ", ex.what ());
+            }   
+        }   
+    }
+
+    void BOBCommandChannel::AddDestination (const std::string& name, BOBDestination * dest)
+    {
+        m_Destinations[name] = dest;
+    }   
+
+    void BOBCommandChannel::DeleteDestination (const std::string& name)
+    {
+        auto it = m_Destinations.find (name);
+        if (it != m_Destinations.end ())
+        {
+            it->second->Stop ();
+            delete it->second;
+            m_Destinations.erase (it);
+        }   
+    }   
+        
+    BOBDestination * BOBCommandChannel::FindDestination (const std::string& name)
+    {
+        auto it = m_Destinations.find (name);
+        if (it != m_Destinations.end ())
+            return it->second;
+        return nullptr; 
+    }
+        
+    void BOBCommandChannel::Accept ()
+    {
+        auto newSession = std::make_shared<BOBCommandSession> (*this);
+        m_Acceptor.async_accept (newSession->GetSocket (), std::bind (&BOBCommandChannel::HandleAccept, this,
+            std::placeholders::_1, newSession));
+    }
+
+    void BOBCommandChannel::HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<BOBCommandSession> session)
+    {
+        if (ecode != boost::asio::error::operation_aborted)
+            Accept ();
+
+        if (!ecode)
+        {
+            LogPrint (eLogInfo, "New BOB command connection from ", session->GetSocket ().remote_endpoint ());
+            session->SendVersion ();    
+        }
+        else
+            LogPrint (eLogError, "BOB accept error: ",  ecode.message ());
+    }
+}
+}
+

client/BOB.h

@@ -0,0 +1,237 @@
+#ifndef BOB_H__
+#define BOB_H__
+
+#include <inttypes.h>
+#include <thread>
+#include <memory>
+#include <map>
+#include <string>
+#include <boost/asio.hpp>
+#include "I2PTunnel.h"
+#include "I2PService.h"
+#include "Identity.h"
+#include "LeaseSet.h"
+
+namespace i2p
+{
+namespace client
+{
+    const size_t BOB_COMMAND_BUFFER_SIZE = 1024;
+    const char BOB_COMMAND_ZAP[] = "zap";
+    const char BOB_COMMAND_QUIT[] = "quit";
+    const char BOB_COMMAND_START[] = "start";
+    const char BOB_COMMAND_STOP[] = "stop"; 
+    const char BOB_COMMAND_SETNICK[] = "setnick";
+    const char BOB_COMMAND_GETNICK[] = "getnick";       
+    const char BOB_COMMAND_NEWKEYS[] = "newkeys";
+    const char BOB_COMMAND_GETKEYS[] = "getkeys";
+    const char BOB_COMMAND_SETKEYS[] = "setkeys";
+    const char BOB_COMMAND_GETDEST[] = "getdest";
+    const char BOB_COMMAND_OUTHOST[] = "outhost";   
+    const char BOB_COMMAND_OUTPORT[] = "outport";
+    const char BOB_COMMAND_INHOST[] = "inhost"; 
+    const char BOB_COMMAND_INPORT[] = "inport";
+    const char BOB_COMMAND_QUIET[] = "quiet";
+    const char BOB_COMMAND_LOOKUP[] = "lookup"; 
+    const char BOB_COMMAND_CLEAR[] = "clear";
+    const char BOB_COMMAND_LIST[] = "list";
+    const char BOB_COMMAND_OPTION[] = "option";
+    
+    const char BOB_VERSION[] = "BOB 00.00.10\nOK\n";    
+    const char BOB_REPLY_OK[] = "OK %s\n";
+    const char BOB_REPLY_ERROR[] = "ERROR %s\n";
+    const char BOB_DATA[] = "NICKNAME %s\n";
+
+    class BOBI2PTunnel: public I2PService
+    {
+        public:
+
+            BOBI2PTunnel (std::shared_ptr<ClientDestination> localDestination): 
+                I2PService (localDestination) {};
+
+            virtual void Start () {};
+            virtual void Stop () {};                
+    };  
+    
+    class BOBI2PInboundTunnel: public BOBI2PTunnel
+    {
+            struct AddressReceiver
+            {
+                std::shared_ptr<boost::asio::ip::tcp::socket> socket;
+                char buffer[BOB_COMMAND_BUFFER_SIZE + 1]; // for destination base64 address
+                uint8_t * data; // pointer to buffer
+                size_t dataLen, bufferOffset; 
+
+                AddressReceiver (): data (nullptr), dataLen (0), bufferOffset (0) {};
+            };  
+        
+        public:
+
+            BOBI2PInboundTunnel (int port, std::shared_ptr<ClientDestination> localDestination);
+            ~BOBI2PInboundTunnel ();
+
+            void Start ();
+            void Stop ();
+
+        private:
+
+            void Accept ();
+            void HandleAccept (const boost::system::error_code& ecode, std::shared_ptr<AddressReceiver> receiver);
+
+            void ReceiveAddress (std::shared_ptr<AddressReceiver> receiver);
+            void HandleReceivedAddress (const boost::system::error_code& ecode, std::size_t bytes_transferred,
+                std::shared_ptr<AddressReceiver> receiver);
+
+            void HandleDestinationRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, std::shared_ptr<AddressReceiver> receiver);
+
+            void CreateConnection (std::shared_ptr<AddressReceiver> receiver, std::shared_ptr<const i2p::data::LeaseSet> leaseSet);
+
+        private:
+
+            boost::asio::ip::tcp::acceptor m_Acceptor;  
+    };
+
+    class BOBI2POutboundTunnel: public BOBI2PTunnel
+    {
+        public:
+
+             BOBI2POutboundTunnel (const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, bool quiet);  
+
+            void Start ();
+            void Stop ();
+
+            void SetQuiet () { m_IsQuiet = true; };
+
+        private:
+
+            void Accept ();
+            void HandleAccept (std::shared_ptr<i2p::stream::Stream> stream);
+
+        private:
+
+            boost::asio::ip::tcp::endpoint m_Endpoint;  
+            bool m_IsQuiet; 
+    };
+
+
+    class BOBDestination
+    {
+        public:
+
+            BOBDestination (std::shared_ptr<ClientDestination> localDestination);
+            ~BOBDestination ();
+
+            void Start ();
+            void Stop ();
+            void StopTunnels ();
+            void CreateInboundTunnel (int port);
+            void CreateOutboundTunnel (const std::string& address, int port, bool quiet);
+            const i2p::data::PrivateKeys& GetKeys () const { return m_LocalDestination->GetPrivateKeys (); };
+            std::shared_ptr<ClientDestination> GetLocalDestination () const { return m_LocalDestination; };
+            
+        private:    
+
+            std::shared_ptr<ClientDestination> m_LocalDestination;
+            BOBI2POutboundTunnel * m_OutboundTunnel;
+            BOBI2PInboundTunnel * m_InboundTunnel;
+    };  
+    
+    class BOBCommandChannel;
+    class BOBCommandSession: public std::enable_shared_from_this<BOBCommandSession>
+    {
+        public:
+
+            BOBCommandSession (BOBCommandChannel& owner);
+            ~BOBCommandSession ();  
+            void Terminate ();
+
+            boost::asio::ip::tcp::socket& GetSocket () { return m_Socket; };
+            void SendVersion ();
+
+            // command handlers
+            void ZapCommandHandler (const char * operand, size_t len);
+            void QuitCommandHandler (const char * operand, size_t len);
+            void StartCommandHandler (const char * operand, size_t len);
+            void StopCommandHandler (const char * operand, size_t len);
+            void SetNickCommandHandler (const char * operand, size_t len);
+            void GetNickCommandHandler (const char * operand, size_t len);
+            void NewkeysCommandHandler (const char * operand, size_t len);
+            void SetkeysCommandHandler (const char * operand, size_t len);
+            void GetkeysCommandHandler (const char * operand, size_t len);
+            void GetdestCommandHandler (const char * operand, size_t len);
+            void OuthostCommandHandler (const char * operand, size_t len);
+            void OutportCommandHandler (const char * operand, size_t len);
+            void InhostCommandHandler (const char * operand, size_t len);
+            void InportCommandHandler (const char * operand, size_t len);           
+            void QuietCommandHandler (const char * operand, size_t len);    
+            void LookupCommandHandler (const char * operand, size_t len);
+            void ClearCommandHandler (const char * operand, size_t len);
+            void ListCommandHandler (const char * operand, size_t len);
+            void OptionCommandHandler (const char * operand, size_t len);
+            
+        private:
+
+            void Receive ();
+            void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+
+            void Send (size_t len);
+            void HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void SendReplyOK (const char * msg);
+            void SendReplyError (const char * msg);
+            void SendData (const char * nickname);
+
+        private:
+
+            BOBCommandChannel& m_Owner;
+            boost::asio::ip::tcp::socket m_Socket;
+            char m_ReceiveBuffer[BOB_COMMAND_BUFFER_SIZE + 1], m_SendBuffer[BOB_COMMAND_BUFFER_SIZE + 1];
+            size_t m_ReceiveBufferOffset;
+            bool m_IsOpen, m_IsQuiet;
+            std::string m_Nickname, m_Address;
+            int m_InPort, m_OutPort;
+            i2p::data::PrivateKeys m_Keys;
+            std::map<std::string, std::string> m_Options; 
+            BOBDestination * m_CurrentDestination;
+    };
+    typedef void (BOBCommandSession::*BOBCommandHandler)(const char * operand, size_t len);
+
+    class BOBCommandChannel
+    {
+        public:
+
+            BOBCommandChannel(const std::string& address, int port);
+            ~BOBCommandChannel ();
+
+            void Start ();
+            void Stop ();
+
+            boost::asio::io_service& GetService () { return m_Service; };
+            void AddDestination (const std::string& name, BOBDestination * dest);
+            void DeleteDestination (const std::string& name);
+            BOBDestination * FindDestination (const std::string& name);
+            
+        private:
+
+            void Run ();
+            void Accept ();
+            void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<BOBCommandSession> session);
+
+        private:
+
+            bool m_IsRunning;
+            std::thread * m_Thread; 
+            boost::asio::io_service m_Service;
+            boost::asio::ip::tcp::acceptor m_Acceptor;
+            std::map<std::string, BOBDestination *> m_Destinations;
+            std::map<std::string, BOBCommandHandler> m_CommandHandlers;
+
+        public:
+
+            const decltype(m_CommandHandlers)& GetCommandHandlers () const { return m_CommandHandlers; };
+            const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
+    };  
+}
+}
+
+#endif
+

client/CMakeLists.txt

@@ -0,0 +1,63 @@
+set(CLIENT_SRC
+  "BOB.cpp"	
+  "ClientContext.cpp"
+  "Daemon.cpp"
+  "HTTPProxy.cpp"
+  "HTTPServer.cpp"
+  "I2PService.cpp"
+  "i2pcontrol/I2PControl.cpp"	
+  "i2pcontrol/I2PControlServer.cpp"	
+  "I2PTunnel.cpp"
+  "SAM.cpp"
+  "SOCKS.cpp"
+  "i2p.cpp"
+)
+
+include_directories(".")
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    list(APPEND CLIENT_SRC "DaemonLinux.cpp")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+    list(APPEND CLIENT_SRC "DaemonLinux.cpp")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    list(APPEND CLIENT_SRC "DaemonLinux.cpp")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+    list(APPEND CLIENT_SRC "DaemonLinux.cpp")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    list(APPEND CLIENT_SRC "DaemonWin32.cpp")
+    list(APPEND CLIENT_SRC "Win32Service.cpp")
+endif()
+
+if(WITH_BINARY)
+    add_executable(${CLIENT_NAME} ${CLIENT_SRC})
+    if(NOT MSVC) # FIXME: incremental linker file name (.ilk) collision for dll & exe
+        set_target_properties(${CLIENT_NAME} PROPERTIES OUTPUT_NAME "${PROJECT_NAME}")
+        if(WITH_STATIC)
+            set_target_properties(${CLIENT_NAME} PROPERTIES LINK_FLAGS "-static" )
+        endif()
+    endif()
+
+    if(WITH_HARDENING AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        set_target_properties(${CLIENT_NAME} PROPERTIES LINK_FLAGS "-z relro -z now")
+    endif()
+
+    # FindBoost pulls pthread for thread which is broken for static linking
+    # (at least on Ubuntu 15.04)
+    list(GET Boost_LIBRARIES -1 LAST_Boost_LIBRARIES)
+    if(${LAST_Boost_LIBRARIES} MATCHES ".*pthread.*")
+        list(REMOVE_AT Boost_LIBRARIES -1)
+    endif()
+    target_link_libraries(
+        ${CLIENT_NAME} ${CORE_NAME}
+        ${DL_LIB} ${Boost_LIBRARIES} ${CRYPTO++_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    )
+
+    install(TARGETS
+        ${CLIENT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    )
+    if(MSVC)
+        install(FILES
+            $<TARGET_PDB_FILE:${CLIENT_NAME}> DESTINATION "bin" CONFIGURATIONS DEBUG
+        )
+    endif()
+endif()

client/ClientContext.cpp

@@ -0,0 +1,365 @@
+#include <fstream>
+#include <iostream>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/ini_parser.hpp>
+#include "util/util.h"
+#include "util/Log.h"
+#include "Identity.h"
+#include "ClientContext.h"
+
+namespace i2p
+{
+namespace client
+{
+    ClientContext context;  
+
+    ClientContext::ClientContext (): m_SharedLocalDestination (nullptr),
+        m_HttpProxy (nullptr), m_SocksProxy (nullptr), m_SamBridge (nullptr), 
+        m_BOBCommandChannel (nullptr), m_I2PControlService (nullptr)
+    {
+    }
+    
+    ClientContext::~ClientContext () 
+    {
+        delete m_HttpProxy;
+        delete m_SocksProxy;
+        delete m_SamBridge;
+        delete m_BOBCommandChannel;
+        delete m_I2PControlService;
+    }
+    
+    void ClientContext::Start ()
+    {
+        if (!m_SharedLocalDestination)
+        {   
+            m_SharedLocalDestination = CreateNewLocalDestination (); // non-public, DSA
+            m_Destinations[m_SharedLocalDestination->GetIdentity ().GetIdentHash ()] = m_SharedLocalDestination;
+            m_SharedLocalDestination->Start ();
+        }
+
+        std::shared_ptr<ClientDestination> localDestination;    
+        // proxies  
+        std::string proxyKeys = i2p::util::config::GetArg("-proxykeys", "");
+        if (proxyKeys.length () > 0)
+            localDestination = LoadLocalDestination (proxyKeys, false);
+        m_HttpProxy = new i2p::proxy::HTTPProxy(
+            i2p::util::config::GetArg("-httpproxyaddress", "127.0.0.1"),
+            i2p::util::config::GetArg("-httpproxyport", 4446),
+            localDestination
+        );
+        m_HttpProxy->Start();
+        LogPrint("HTTP Proxy started");
+        m_SocksProxy = new i2p::proxy::SOCKSProxy(
+            i2p::util::config::GetArg("-socksproxyaddress", "127.0.0.1"),
+            i2p::util::config::GetArg("-socksproxyport", 4447),
+            localDestination
+        );
+        m_SocksProxy->Start();
+        LogPrint("SOCKS Proxy Started");
+    
+        // I2P tunnels
+        std::string ircDestination = i2p::util::config::GetArg("-ircdest", "");
+        if (ircDestination.length () > 0) // ircdest is presented
+        {
+            localDestination = nullptr;
+            std::string ircKeys = i2p::util::config::GetArg("-irckeys", "");    
+            if (ircKeys.length () > 0)
+                localDestination = LoadLocalDestination (ircKeys, false);
+            auto ircPort = i2p::util::config::GetArg("-ircport", 6668);
+            auto ircTunnel = new I2PClientTunnel(
+                ircDestination, i2p::util::config::GetArg("-ircaddress", "127.0.0.1"),
+                ircPort, localDestination
+            );
+            ircTunnel->Start ();
+            // TODO: allow muliple tunnels on the same port (but on a different address)
+            m_ClientTunnels.insert(std::make_pair(
+                ircPort, std::unique_ptr<I2PClientTunnel>(ircTunnel)
+            ));
+            LogPrint("IRC tunnel started");
+        }   
+        std::string eepKeys = i2p::util::config::GetArg("-eepkeys", "");
+        if (eepKeys.length () > 0) // eepkeys file is presented
+        {
+            localDestination = LoadLocalDestination (eepKeys, true);
+            auto serverTunnel = new I2PServerTunnel (i2p::util::config::GetArg("-eepaddress", "127.0.0.1"),
+                i2p::util::config::GetArg("-eepport", 80), localDestination);
+            serverTunnel->Start ();
+            m_ServerTunnels.insert (std::make_pair(localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel)));
+            LogPrint("Server tunnel started");
+        }
+        ReadTunnels ();
+
+        // SAM
+        int samPort = i2p::util::config::GetArg("-samport", 0);
+        if (samPort)
+        {
+            m_SamBridge = new SAMBridge(
+                i2p::util::config::GetArg("-samaddress", "127.0.0.1"), samPort
+            );
+            m_SamBridge->Start ();
+            LogPrint("SAM bridge started");
+        } 
+
+        // BOB
+        int bobPort = i2p::util::config::GetArg("-bobport", 0);
+        if (bobPort)
+        {
+            m_BOBCommandChannel = new BOBCommandChannel(
+                i2p::util::config::GetArg("-bobaddress", "127.0.0.1"), bobPort
+            );
+            m_BOBCommandChannel->Start ();
+            LogPrint("BOB command channel started");
+        } 
+
+        // I2P Control
+        int i2pcontrolPort = i2p::util::config::GetArg("-i2pcontrolport", 0);
+        if(i2pcontrolPort) {
+            m_I2PControlService = new i2pcontrol::I2PControlService(
+                i2p::util::config::GetArg("-i2pcontroladdress", "127.0.0.1"),
+                i2pcontrolPort,
+                i2p::util::config::GetArg(
+                    "-i2pcontrolpassword", i2pcontrol::constants::DEFAULT_PASSWORD
+                )
+            );
+            m_I2PControlService->Start();
+            LogPrint("I2PControl started");
+        }
+        m_AddressBook.Start (m_SharedLocalDestination.get());
+    }
+        
+    void ClientContext::Stop ()
+    {
+        m_HttpProxy->Stop();
+        delete m_HttpProxy;
+        m_HttpProxy = nullptr;
+        LogPrint("HTTP Proxy stopped");
+        m_SocksProxy->Stop();
+        delete m_SocksProxy;
+        m_SocksProxy = nullptr;
+        LogPrint("SOCKS Proxy stopped");
+        for (auto& it: m_ClientTunnels)
+        {
+            it.second->Stop ();
+            LogPrint("I2P client tunnel on port ", it.first, " stopped");   
+        }
+        m_ClientTunnels.clear ();   
+        for (auto& it: m_ServerTunnels)
+        {
+            it.second->Stop ();
+            LogPrint("I2P server tunnel stopped");  
+        }
+        m_ServerTunnels.clear ();   
+        if (m_SamBridge)
+        {
+            m_SamBridge->Stop ();
+            delete m_SamBridge; 
+            m_SamBridge = nullptr;
+            LogPrint("SAM bridge stopped"); 
+        }       
+        if (m_BOBCommandChannel)
+        {
+            m_BOBCommandChannel->Stop ();
+            delete m_BOBCommandChannel; 
+            m_BOBCommandChannel = nullptr;
+            LogPrint("BOB command channel stopped");    
+        }           
+        if (m_I2PControlService)
+        {
+            m_I2PControlService->Stop ();
+            delete m_I2PControlService; 
+            m_I2PControlService = nullptr;
+            LogPrint("I2PControl stopped"); 
+        }   
+        m_AddressBook.Stop ();      
+        for (auto it: m_Destinations)
+            it.second->Stop ();
+        m_Destinations.clear ();
+        m_SharedLocalDestination = nullptr; 
+    }   
+    
+    std::shared_ptr<ClientDestination> ClientContext::LoadLocalDestination (const std::string& filename, bool isPublic)
+    {
+        i2p::data::PrivateKeys keys;
+        std::string fullPath = i2p::util::filesystem::GetFullPath (filename);
+        std::ifstream s(fullPath.c_str (), std::ifstream::binary);
+        if (s.is_open ())   
+        {   
+            s.seekg (0, std::ios::end);
+            size_t len = s.tellg();
+            s.seekg (0, std::ios::beg);
+            uint8_t * buf = new uint8_t[len];
+            s.read ((char *)buf, len);
+            keys.FromBuffer (buf, len);
+            delete[] buf;
+            LogPrint ("Local address ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " loaded");
+        }   
+        else
+        {
+            LogPrint ("Can't open file ", fullPath, " Creating new one");
+            keys = i2p::data::PrivateKeys::CreateRandomKeys (i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256); 
+            std::ofstream f (fullPath, std::ofstream::binary | std::ofstream::out);
+            size_t len = keys.GetFullLen ();
+            uint8_t * buf = new uint8_t[len];
+            len = keys.ToBuffer (buf, len);
+            f.write ((char *)buf, len);
+            delete[] buf;
+            
+            LogPrint ("New private keys file ", fullPath, " for ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " created");
+        }   
+
+        std::shared_ptr<ClientDestination> localDestination = nullptr;  
+        std::unique_lock<std::mutex> l(m_DestinationsMutex);    
+        auto it = m_Destinations.find (keys.GetPublic ().GetIdentHash ()); 
+        if (it != m_Destinations.end ())
+        {
+            LogPrint (eLogWarning, "Local destination ",  m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " alreday exists");
+            localDestination = it->second;
+        }
+        else
+        {
+            localDestination = std::make_shared<ClientDestination> (keys, isPublic);
+            m_Destinations[localDestination->GetIdentHash ()] = localDestination;
+            localDestination->Start ();
+        }
+        return localDestination;
+    }
+
+    std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (bool isPublic, i2p::data::SigningKeyType sigType,
+        const std::map<std::string, std::string> * params)
+    {
+        i2p::data::PrivateKeys keys = i2p::data::PrivateKeys::CreateRandomKeys (sigType);
+        auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
+        std::unique_lock<std::mutex> l(m_DestinationsMutex);
+        m_Destinations[localDestination->GetIdentHash ()] = localDestination;
+        localDestination->Start ();
+        return localDestination;
+    }
+
+    void ClientContext::DeleteLocalDestination (std::shared_ptr<ClientDestination> destination)
+    {
+        if (!destination) return;
+        auto it = m_Destinations.find (destination->GetIdentHash ());
+        if (it != m_Destinations.end ())
+        {
+            auto d = it->second;
+            {
+                std::unique_lock<std::mutex> l(m_DestinationsMutex);
+                m_Destinations.erase (it);
+            }   
+            d->Stop ();
+        }
+    }
+
+    std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic,
+        const std::map<std::string, std::string> * params)
+    {
+        auto it = m_Destinations.find (keys.GetPublic ().GetIdentHash ());
+        if (it != m_Destinations.end ())
+        {
+            LogPrint ("Local destination ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " exists");
+            if (!it->second->IsRunning ())
+            {   
+                it->second->Start ();
+                return it->second;
+            }   
+            return nullptr;
+        }   
+        auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
+        std::unique_lock<std::mutex> l(m_DestinationsMutex);
+        m_Destinations[keys.GetPublic ().GetIdentHash ()] = localDestination;
+        localDestination->Start ();
+        return localDestination;
+    }
+    
+    std::shared_ptr<ClientDestination> ClientContext::FindLocalDestination (const i2p::data::IdentHash& destination) const
+    {
+        auto it = m_Destinations.find (destination);
+        if (it != m_Destinations.end ())
+            return it->second;
+        return nullptr;
+    }   
+
+    void ClientContext::ReadTunnels ()
+    {
+        boost::property_tree::ptree pt;
+        std::string pathTunnelsConfigFile = i2p::util::filesystem::GetTunnelsConfigFile().string();
+        try {
+            boost::property_tree::read_ini(
+                pathTunnelsConfigFile,
+                pt
+            );
+        } catch(const std::exception& ex) {
+            LogPrint(eLogWarning, "Can't read ", pathTunnelsConfigFile, ": ", ex.what ());
+            return;
+        }
+            
+        int numClientTunnels = 0, numServerTunnels = 0;
+        for(auto& section: pt) {
+            std::string name = section.first;           
+            try {
+                std::string type = section.second.get<std::string> (I2P_TUNNELS_SECTION_TYPE);
+                if(type == I2P_TUNNELS_SECTION_TYPE_CLIENT) {
+                    // mandatory params
+                    std::string dest = section.second.get<std::string> (I2P_CLIENT_TUNNEL_DESTINATION);
+                    int port = section.second.get<int> (I2P_CLIENT_TUNNEL_PORT);
+                    // optional params
+                    std::string address = section.second.get(
+                        I2P_CLIENT_TUNNEL_ADDRESS, "127.0.0.1"
+                    );
+                    std::string keys = section.second.get(I2P_CLIENT_TUNNEL_KEYS, "");
+                    int destinationPort = section.second.get(I2P_CLIENT_TUNNEL_DESTINATION_PORT, 0);
+
+                    std::shared_ptr<ClientDestination> localDestination = nullptr;
+                    if(keys.length () > 0)
+                        localDestination = LoadLocalDestination (keys, false);
+
+                    auto clientTunnel = new I2PClientTunnel(
+                        dest, address, port, localDestination, destinationPort
+                    );
+                    // TODO: allow multiple tunnels on the same port (but on a different address)
+                    if(m_ClientTunnels.insert(std::make_pair(port, std::unique_ptr<I2PClientTunnel>(clientTunnel))).second)
+                        clientTunnel->Start ();
+                    else
+                        LogPrint (eLogError, "I2P client tunnel with port ", port, " already exists");
+                    numClientTunnels++;
+                } else if(type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP)
+                {   
+                    // mandatory params
+                    std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);
+                    int port = section.second.get<int> (I2P_SERVER_TUNNEL_PORT);
+                    std::string keys = section.second.get<std::string> (I2P_SERVER_TUNNEL_KEYS);
+                    // optional params
+                    int inPort = section.second.get (I2P_SERVER_TUNNEL_INPORT, 0);
+                    std::string accessList = section.second.get (I2P_SERVER_TUNNEL_ACCESS_LIST, "");                    
+
+                    auto localDestination = LoadLocalDestination (keys, true);
+                    I2PServerTunnel * serverTunnel = (type == I2P_TUNNELS_SECTION_TYPE_HTTP) ? new I2PServerTunnelHTTP (host, port, localDestination, inPort) : new I2PServerTunnel (host, port, localDestination, inPort);
+                    if (accessList.length () > 0) {
+                        std::set<i2p::data::IdentHash> idents;
+                        size_t pos = 0, comma;
+                        do {
+                            comma = accessList.find (',', pos);
+                            i2p::data::IdentHash ident;
+                            ident.FromBase32 (accessList.substr (pos, comma != std::string::npos ? comma - pos : std::string::npos));   
+                            idents.insert (ident);
+                            pos = comma + 1;
+                        } while (comma != std::string::npos);
+                        serverTunnel->SetAccessList (idents);
+                    }
+                    if (m_ServerTunnels.insert (std::make_pair (localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel))).second)
+                        serverTunnel->Start ();
+                    else
+                        LogPrint (eLogError, "I2P server tunnel for destination ",   m_AddressBook.ToAddress(localDestination->GetIdentHash ()), " already exists");    
+                    numServerTunnels++;
+                } else
+                    LogPrint (eLogWarning, "Unknown section type=", type, " of ", name, " in ", pathTunnelsConfigFile);
+                
+            } catch (const std::exception& ex) {
+                LogPrint (eLogError, "Can't read tunnel ", name, " params: ", ex.what ());
+            }
+        }   
+        LogPrint (eLogInfo, numClientTunnels, " I2P client tunnels created");
+        LogPrint (eLogInfo, numServerTunnels, " I2P server tunnels created");
+    }   
+}       
+}   

client/ClientContext.h

@@ -0,0 +1,86 @@
+#ifndef CLIENT_CONTEXT_H__
+#define CLIENT_CONTEXT_H__
+
+#include <map>
+#include <mutex>
+#include <memory>
+#include "Destination.h"
+#include "HTTPProxy.h"
+#include "SOCKS.h"
+#include "I2PTunnel.h"
+#include "SAM.h"
+#include "BOB.h"
+#include "AddressBook.h"
+#include "i2pcontrol/I2PControlServer.h"
+
+namespace i2p
+{
+namespace client
+{
+    const char I2P_TUNNELS_SECTION_TYPE[] = "type";
+    const char I2P_TUNNELS_SECTION_TYPE_CLIENT[] = "client";
+    const char I2P_TUNNELS_SECTION_TYPE_SERVER[] = "server";
+    const char I2P_TUNNELS_SECTION_TYPE_HTTP[] = "http";
+    const char I2P_CLIENT_TUNNEL_PORT[] = "port";
+    const char I2P_CLIENT_TUNNEL_ADDRESS[] = "address";
+    const char I2P_CLIENT_TUNNEL_DESTINATION[] = "destination";
+    const char I2P_CLIENT_TUNNEL_KEYS[] = "keys";
+    const char I2P_CLIENT_TUNNEL_DESTINATION_PORT[] = "destinationport";    
+    const char I2P_SERVER_TUNNEL_HOST[] = "host";   
+    const char I2P_SERVER_TUNNEL_PORT[] = "port";
+    const char I2P_SERVER_TUNNEL_KEYS[] = "keys";
+    const char I2P_SERVER_TUNNEL_INPORT[] = "inport";
+    const char I2P_SERVER_TUNNEL_ACCESS_LIST[] = "accesslist";      
+
+    class ClientContext
+    {
+        public:
+
+            ClientContext ();
+            ~ClientContext ();
+
+            void Start ();
+            void Stop ();
+
+            std::shared_ptr<ClientDestination> GetSharedLocalDestination () const { return m_SharedLocalDestination; };
+            std::shared_ptr<ClientDestination> CreateNewLocalDestination (bool isPublic = false, i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1,
+                const std::map<std::string, std::string> * params = nullptr); // transient
+            std::shared_ptr<ClientDestination> CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic = true, 
+                const std::map<std::string, std::string> * params = nullptr);
+            void DeleteLocalDestination (std::shared_ptr<ClientDestination> destination);
+            std::shared_ptr<ClientDestination> FindLocalDestination (const i2p::data::IdentHash& destination) const;        
+            std::shared_ptr<ClientDestination> LoadLocalDestination (const std::string& filename, bool isPublic);
+
+            AddressBook& GetAddressBook () { return m_AddressBook; };
+            const SAMBridge * GetSAMBridge () const { return m_SamBridge; };
+        
+        private:
+
+            void ReadTunnels ();
+    
+        private:
+
+            std::mutex m_DestinationsMutex;
+            std::map<i2p::data::IdentHash, std::shared_ptr<ClientDestination> > m_Destinations;
+            std::shared_ptr<ClientDestination>  m_SharedLocalDestination;   
+
+            AddressBook m_AddressBook;
+
+            i2p::proxy::HTTPProxy * m_HttpProxy;
+            i2p::proxy::SOCKSProxy * m_SocksProxy;
+            std::map<int, std::unique_ptr<I2PClientTunnel> > m_ClientTunnels; // port->tunnel
+            std::map<i2p::data::IdentHash, std::unique_ptr<I2PServerTunnel> > m_ServerTunnels; // destination->tunnel
+            SAMBridge * m_SamBridge;
+            BOBCommandChannel * m_BOBCommandChannel;
+            i2pcontrol::I2PControlService * m_I2PControlService;
+
+        public:
+            // for HTTP
+            const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
+    };
+    
+    extern ClientContext context;   
+}       
+}   
+
+#endif

client/Daemon.cpp

@@ -0,0 +1,157 @@
+#include <thread>
+
+#include "Daemon.h"
+
+#include "util/Log.h"
+#include "version.h"
+#include "transport/Transports.h"
+#include "transport/NTCPSession.h"
+#include "RouterInfo.h"
+#include "RouterContext.h"
+#include "tunnel/Tunnel.h"
+#include "NetworkDatabase.h"
+#include "Garlic.h"
+#include "util/util.h"
+#include "Streaming.h"
+#include "Destination.h"
+#include "HTTPServer.h"
+#include "ClientContext.h"
+
+namespace i2p
+{
+    namespace util
+    {
+        class Daemon_Singleton::Daemon_Singleton_Private
+        {
+        public:
+            Daemon_Singleton_Private() : httpServer(nullptr)
+            {};
+            ~Daemon_Singleton_Private() 
+            {
+                delete httpServer;
+            };
+
+            i2p::util::HTTPServer *httpServer;
+        };
+
+        Daemon_Singleton::Daemon_Singleton() : running(1), d(*new Daemon_Singleton_Private()) {};
+        Daemon_Singleton::~Daemon_Singleton() {
+            delete &d;
+        };
+
+        bool Daemon_Singleton::IsService () const
+        {
+#ifndef _WIN32
+            return i2p::util::config::GetArg("-service", 0);
+#else
+            return false;
+#endif
+        }
+
+        bool Daemon_Singleton::init(int argc, char* argv[])
+        {
+            i2p::util::config::OptionParser(argc, argv);
+            i2p::context.Init ();
+
+            LogPrint("\n\n\n\ni2pd starting\n");
+            LogPrint("Version ", VERSION);
+            LogPrint("data directory: ", i2p::util::filesystem::GetDataDir().string());
+            i2p::util::filesystem::ReadConfigFile(
+                i2p::util::config::mapArgs, i2p::util::config::mapMultiArgs
+            );
+
+            if(i2p::util::config::HasArg("-install")) {
+                try {
+                    i2p::util::filesystem::InstallFiles();
+                    LogPrint("Successfully installed all files.");
+                } catch(const std::runtime_error& e) {
+                    LogPrint(eLogError, "Failed to install: ", e.what());
+                    return false;
+                }
+            }
+
+            isDaemon = i2p::util::config::GetArg("-daemon", 0);
+            isLogging = i2p::util::config::GetArg("-log", 1);
+
+            int port = i2p::util::config::GetArg("-port", 0);
+            if (port)
+                i2p::context.UpdatePort (port);                 
+            const char * host = i2p::util::config::GetCharArg("-host", "");
+            if (host && host[0])
+                i2p::context.UpdateAddress (boost::asio::ip::address::from_string (host));  
+
+            i2p::context.SetSupportsV6 (i2p::util::config::GetArg("-v6", 0));
+            i2p::context.SetFloodfill (i2p::util::config::GetArg("-floodfill", 0));
+            auto bandwidth = i2p::util::config::GetArg("-bandwidth", "");
+            if (bandwidth.length () > 0)
+            {
+                if (bandwidth[0] > 'L')
+                    i2p::context.SetHighBandwidth ();
+                else
+                    i2p::context.SetLowBandwidth ();
+            }   
+
+            LogPrint("CMD parameters:");
+            for (int i = 0; i < argc; ++i)
+                LogPrint(i, "  ", argv[i]);
+
+            return true;
+        }
+            
+        bool Daemon_Singleton::start()
+        {
+            // initialize log           
+            if (isLogging)
+            {
+                if (isDaemon)
+                {
+                    std::string logfile_path = IsService () ? "/var/log" : i2p::util::filesystem::GetDataDir().string();
+#ifndef _WIN32
+                    logfile_path.append("/i2pd.log");
+#else
+                    logfile_path.append("\\i2pd.log");
+#endif
+                    StartLog (logfile_path);
+                }
+                else
+                    StartLog (""); // write to stdout
+            }
+            d.httpServer = new i2p::util::HTTPServer(
+                i2p::util::config::GetArg("-httpaddress", "127.0.0.1"),
+                i2p::util::config::GetArg("-httpport", 7070)
+            );
+            d.httpServer->Start();
+            LogPrint("HTTP Server started");
+            i2p::data::netdb.Start();
+            LogPrint("NetDB started");
+            i2p::transport::transports.Start();
+            LogPrint("Transports started");
+            i2p::tunnel::tunnels.Start();
+            LogPrint("Tunnels started");
+            i2p::client::context.Start ();
+            LogPrint("Client started");
+            return true;
+        }
+
+        bool Daemon_Singleton::stop()
+        {
+            LogPrint("Shutdown started.");
+            i2p::client::context.Stop();
+            LogPrint("Client stopped");
+            i2p::tunnel::tunnels.Stop();
+            LogPrint("Tunnels stopped");
+            i2p::transport::transports.Stop();
+            LogPrint("Transports stopped");
+            i2p::data::netdb.Stop();
+            LogPrint("NetDB stopped");
+            d.httpServer->Stop();
+            LogPrint("HTTP Server stopped");
+
+            StopLog ();
+
+            delete d.httpServer; d.httpServer = nullptr;
+
+            return true;
+        }
+    }
+}

client/Daemon.h

@@ -0,0 +1,73 @@
+#pragma once
+#include <string>
+
+#ifdef _WIN32
+#define Daemon i2p::util::DaemonWin32::Instance()
+#else
+#define Daemon i2p::util::DaemonLinux::Instance()
+#endif
+
+namespace i2p
+{
+    namespace util
+    {
+        class Daemon_Singleton_Private;
+        class Daemon_Singleton
+        {
+        public:
+            virtual bool init(int argc, char* argv[]);
+            virtual bool start();
+            virtual bool stop();
+
+            int isLogging;
+            int isDaemon;
+            
+            int running;
+
+        protected:
+            Daemon_Singleton();
+            virtual ~Daemon_Singleton();
+
+            bool IsService () const;                
+
+            // d-pointer for httpServer, httpProxy, etc.
+            class Daemon_Singleton_Private;
+            Daemon_Singleton_Private &d;
+        };
+
+#ifdef _WIN32
+        class DaemonWin32 : public Daemon_Singleton
+        {
+        public:
+            static DaemonWin32& Instance()
+            {
+                static DaemonWin32 instance;
+                return instance;
+            }
+
+            virtual bool init(int argc, char* argv[]);
+            virtual bool start();
+            virtual bool stop();
+        };
+#else
+        class DaemonLinux : public Daemon_Singleton
+        {
+        public:
+            DaemonLinux() = default;
+
+            static DaemonLinux& Instance()
+            {
+                static DaemonLinux instance;
+                return instance;
+            }
+
+            virtual bool start();
+            virtual bool stop();
+         private:
+                std::string pidfile;
+                int pidFilehandle;
+
+        };
+#endif
+    }
+}

client/DaemonLinux.cpp

@@ -0,0 +1,119 @@
+#include "Daemon.h"
+
+#ifndef _WIN32
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include "util/Log.h"
+#include "util/util.h"
+
+
+void handle_signal(int sig)
+{
+    switch (sig)
+    {
+    case SIGHUP:
+        if (i2p::util::config::GetArg("daemon", 0) == 1)
+        {
+            static bool first=true;
+            if (first)
+            {
+                first=false;
+                return;
+            }
+        }
+        LogPrint("Reloading config.");
+        i2p::util::filesystem::ReadConfigFile(i2p::util::config::mapArgs, i2p::util::config::mapMultiArgs);
+        break;
+    case SIGABRT:
+    case SIGTERM:
+    case SIGINT:
+        Daemon.running = 0; // Exit loop
+        break;
+    }
+}
+
+
+namespace i2p
+{
+    namespace util
+    {
+        bool DaemonLinux::start()
+        {
+            if (isDaemon == 1)
+            {
+                pid_t pid;
+                pid = fork();
+                if (pid > 0) // parent
+                    ::exit (EXIT_SUCCESS);
+
+                if (pid < 0) // error
+                    return false;
+
+                // child
+                umask(0);
+                int sid = setsid();
+                if (sid < 0)
+                {
+                    LogPrint("Error, could not create process group.");
+                    return false;
+                }
+                std::string d(i2p::util::filesystem::GetDataDir().string ()); // make a copy
+                chdir(d.c_str());
+
+                // close stdin/stdout/stderr descriptors
+                ::close (0);
+                ::open ("/dev/null", O_RDWR);
+                ::close (1);
+                ::open ("/dev/null", O_RDWR);   
+                ::close (2);
+                ::open ("/dev/null", O_RDWR);
+            }
+
+            // Pidfile
+            pidfile = IsService () ? "/var/run" : i2p::util::filesystem::GetDataDir().string();
+            pidfile.append("/i2pd.pid");
+            pidFilehandle = open(pidfile.c_str(), O_RDWR | O_CREAT, 0600);
+            if (pidFilehandle == -1)
+            {
+                LogPrint("Error, could not create pid file (", pidfile, ")\nIs an instance already running?");
+                return false;
+            }
+            if (lockf(pidFilehandle, F_TLOCK, 0) == -1)
+            {
+                LogPrint("Error, could not lock pid file (", pidfile, ")\nIs an instance already running?");
+                return false;
+            }
+            char pid[10];
+            sprintf(pid, "%d\n", getpid());
+            write(pidFilehandle, pid, strlen(pid));
+
+            // Signal handler
+            struct sigaction sa;
+            sa.sa_handler = handle_signal;
+            sigemptyset(&sa.sa_mask);
+            sa.sa_flags = SA_RESTART;
+            sigaction(SIGHUP, &sa, 0);
+            sigaction(SIGABRT, &sa, 0);
+            sigaction(SIGTERM, &sa, 0);
+            sigaction(SIGINT, &sa, 0);
+
+            return Daemon_Singleton::start();
+        }
+
+        bool DaemonLinux::stop()
+        {
+            close(pidFilehandle);
+            unlink(pidfile.c_str());
+
+            return Daemon_Singleton::stop();            
+        }
+
+    }
+}
+
+#endif

client/DaemonWin32.cpp

@@ -0,0 +1,83 @@
+#include "Daemon.h"
+#include "util/util.h"
+#include "util/Log.h"
+
+#ifdef _WIN32
+
+#include "Win32Service.h"
+
+namespace i2p
+{
+    namespace util
+    {
+        bool DaemonWin32::init(int argc, char* argv[])
+        {
+            setlocale(LC_CTYPE, "");
+            SetConsoleCP(1251);
+            SetConsoleOutputCP(1251);
+            setlocale(LC_ALL, "Russian");
+
+            if (!Daemon_Singleton::init(argc, argv)) return false;
+            if (I2PService::isService())
+                isDaemon = 1;
+            else
+                isDaemon = 0;
+
+            std::string serviceControl = i2p::util::config::GetArg("-service", "none");
+            if (serviceControl == "install")
+            {
+                InstallService(
+                    SERVICE_NAME,               // Name of service
+                    SERVICE_DISPLAY_NAME,       // Name to display
+                    SERVICE_START_TYPE,         // Service start type
+                    SERVICE_DEPENDENCIES,       // Dependencies
+                    SERVICE_ACCOUNT,            // Service running account
+                    SERVICE_PASSWORD            // Password of the account
+                    );
+                exit(0);
+            }
+            else if (serviceControl == "remove")
+            {
+                UninstallService(SERVICE_NAME);
+                exit(0);
+            }
+            else if (serviceControl != "none")
+            {
+                printf(" --service=install  to install the service.\n");
+                printf(" --service=remove   to remove the service.\n");
+            }
+            
+            if (isDaemon == 1)
+            {
+                LogPrint("Service session");
+                I2PService service(SERVICE_NAME);
+                if (!I2PService::Run(service))
+                {
+                    LogPrint("Service failed to run w/err 0x%08lx\n", GetLastError());
+                    exit(EXIT_FAILURE);
+                }
+                exit(EXIT_SUCCESS);
+            }
+            else
+                LogPrint("User session");
+
+            return true;
+        }
+        bool DaemonWin32::start()
+        {
+            setlocale(LC_CTYPE, "");
+            SetConsoleCP(1251);
+            SetConsoleOutputCP(1251);
+            setlocale(LC_ALL, "Russian");
+
+            return Daemon_Singleton::start();
+        }
+
+        bool DaemonWin32::stop()
+        {
+            return Daemon_Singleton::stop();
+        }
+    }
+}
+
+#endif

client/HTTPProxy.cpp

@@ -0,0 +1,299 @@
+#include <cstring>
+#include <cassert>
+#include <boost/lexical_cast.hpp>
+#include <boost/regex.hpp>
+#include <string>
+#include <atomic>
+#include "HTTPProxy.h"
+#include "util/util.h"
+#include "Identity.h"
+#include "Streaming.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "util/I2PEndian.h"
+#include "I2PTunnel.h"
+
+namespace i2p
+{
+namespace proxy
+{
+    static const size_t http_buffer_size = 8192;
+    class HTTPProxyHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this<HTTPProxyHandler> 
+    {
+        private:
+            enum state 
+            {
+                GET_METHOD,
+                GET_HOSTNAME,
+                GET_HTTPV,
+                GET_HTTPVNL, //TODO: fallback to finding Host: header if needed
+                DONE
+            };
+
+            void EnterState(state nstate);
+            bool HandleData(uint8_t *http_buff, std::size_t len);
+            void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+            void Terminate();
+            void AsyncSockRead();
+            void HTTPRequestFailed(/*std::string message*/);
+            void ExtractRequest();
+            bool ValidateHTTPRequest();
+            void HandleJumpServices();
+            bool CreateHTTPRequest(uint8_t *http_buff, std::size_t len);
+            void SentHTTPFailed(const boost::system::error_code & ecode);
+            void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
+
+            uint8_t m_http_buff[http_buffer_size];
+            std::shared_ptr<boost::asio::ip::tcp::socket> m_sock;
+            std::string m_request; //Data left to be sent
+            std::string m_url; //URL
+            std::string m_method; //Method
+            std::string m_version; //HTTP version
+            std::string m_address; //Address
+            std::string m_path; //Path
+            int m_port; //Port
+            state m_state;//Parsing state
+
+        public:
+
+            HTTPProxyHandler(HTTPProxyServer * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock) : 
+                I2PServiceHandler(parent), m_sock(sock)
+                { EnterState(GET_METHOD); }
+            ~HTTPProxyHandler() { Terminate(); }
+            void Handle () { AsyncSockRead(); }
+    };
+
+    void HTTPProxyHandler::AsyncSockRead()
+    {
+        LogPrint(eLogDebug,"--- HTTP Proxy async sock read");
+        if(m_sock) {
+            m_sock->async_receive(boost::asio::buffer(m_http_buff, http_buffer_size),
+                        std::bind(&HTTPProxyHandler::HandleSockRecv, shared_from_this(),
+                                std::placeholders::_1, std::placeholders::_2));
+        } else {
+            LogPrint(eLogError,"--- HTTP Proxy no socket for read");
+        }
+    }
+
+    void HTTPProxyHandler::Terminate() {
+        if (Kill()) return;
+        if (m_sock) 
+        {
+            LogPrint(eLogDebug,"--- HTTP Proxy close sock");
+            m_sock->close();
+            m_sock = nullptr;
+        }
+        Done(shared_from_this());
+    }
+
+    /* All hope is lost beyond this point */
+    //TODO: handle this appropriately
+    void HTTPProxyHandler::HTTPRequestFailed(/*HTTPProxyHandler::errTypes error*/)
+    {
+        static std::string response = "HTTP/1.0 500 Internal Server Error\r\nContent-type: text/html\r\nContent-length: 0\r\n";
+        boost::asio::async_write(*m_sock, boost::asio::buffer(response,response.size()),
+                     std::bind(&HTTPProxyHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1));
+    }
+
+    void HTTPProxyHandler::EnterState(HTTPProxyHandler::state nstate) 
+    {
+        m_state = nstate;
+    }
+
+    void HTTPProxyHandler::ExtractRequest()
+    {
+        LogPrint(eLogDebug,"--- HTTP Proxy method is: ", m_method, "\nRequest is: ", m_url);
+        std::string server="";
+        std::string port="80";
+        boost::regex rHTTP("http://(.*?)(:(\\d+))?(/.*)");
+        boost::smatch m;
+        std::string path;
+        if(boost::regex_search(m_url, m, rHTTP, boost::match_extra)) 
+        {
+            server=m[1].str();
+            if (m[2].str() != "")  port=m[3].str();
+            path=m[4].str();
+        }
+        LogPrint(eLogDebug,"--- HTTP Proxy server is: ",server, " port is: ", port, "\n path is: ",path);
+        m_address = server;
+        m_port = boost::lexical_cast<int>(port);
+        m_path = path;
+    }
+
+    bool HTTPProxyHandler::ValidateHTTPRequest() 
+    {
+        if ( m_version != "HTTP/1.0" && m_version != "HTTP/1.1" ) 
+        {
+            LogPrint(eLogError,"--- HTTP Proxy unsupported version: ", m_version);
+            HTTPRequestFailed(); //TODO: send right stuff
+            return false;
+        }
+        return true;
+    }
+
+    void HTTPProxyHandler::HandleJumpServices() 
+    {
+        static const char * helpermark1 = "?i2paddresshelper=";
+        static const char * helpermark2 = "&i2paddresshelper=";
+        size_t addressHelperPos1 = m_path.rfind (helpermark1);
+        size_t addressHelperPos2 = m_path.rfind (helpermark2);
+        size_t addressHelperPos;
+        if (addressHelperPos1 == std::string::npos)
+        {
+            if (addressHelperPos2 == std::string::npos)
+                return; //Not a jump service
+            else
+                addressHelperPos = addressHelperPos2;
+        }
+        else
+        {
+            if (addressHelperPos2 == std::string::npos)
+                addressHelperPos = addressHelperPos1;
+            else if ( addressHelperPos1 > addressHelperPos2 )
+                addressHelperPos = addressHelperPos1;
+            else
+                addressHelperPos = addressHelperPos2;
+        }
+        auto base64 = m_path.substr (addressHelperPos + strlen(helpermark1));
+        base64 = i2p::util::http::urlDecode(base64); //Some of the symbols may be urlencoded
+        LogPrint (eLogDebug,"Jump service for ", m_address, " found at ", base64, ". Inserting to address book");
+        //TODO: this is very dangerous and broken. We should ask the user before doing anything see http://pastethis.i2p/raw/pn5fL4YNJL7OSWj3Sc6N/
+        //TODO: we could redirect the user again to avoid dirtiness in the browser
+        i2p::client::context.GetAddressBook ().InsertAddress (m_address, base64);
+        m_path.erase(addressHelperPos);
+    }
+
+    bool HTTPProxyHandler::CreateHTTPRequest(uint8_t *http_buff, std::size_t len) 
+    {
+        ExtractRequest(); //TODO: parse earlier
+        if (!ValidateHTTPRequest()) return false;
+        HandleJumpServices();
+        m_request = m_method;
+        m_request.push_back(' ');
+        m_request += m_path;
+        m_request.push_back(' ');
+        m_request += m_version;
+        m_request.push_back('\r');
+        m_request.push_back('\n');
+        m_request.append("Connection: close\r\n");
+        m_request.append(reinterpret_cast<const char *>(http_buff),len);
+        return true;
+    }
+
+    bool HTTPProxyHandler::HandleData(uint8_t *http_buff, std::size_t len)
+    {
+        assert(len); // This should always be called with a least a byte left to parse
+        while (len > 0) 
+        {
+            //TODO: fallback to finding Host: header if needed
+            switch (m_state) 
+            {
+                case GET_METHOD:
+                    switch (*http_buff) 
+                    {
+                        case ' ': EnterState(GET_HOSTNAME); break;
+                        default: m_method.push_back(*http_buff); break;
+                    }
+                break;
+                case GET_HOSTNAME:
+                    switch (*http_buff) 
+                    {
+                        case ' ': EnterState(GET_HTTPV); break;
+                        default: m_url.push_back(*http_buff); break;
+                    }
+                break;
+                case GET_HTTPV:
+                    switch (*http_buff) 
+                    {
+                        case '\r': EnterState(GET_HTTPVNL); break;
+                        default: m_version.push_back(*http_buff); break;
+                    }
+                break;
+                case GET_HTTPVNL:
+                    switch (*http_buff) 
+                    {
+                        case '\n': EnterState(DONE); break;
+                        default:
+                            LogPrint(eLogError,"--- HTTP Proxy rejected invalid request ending with: ", ((int)*http_buff));
+                            HTTPRequestFailed(); //TODO: add correct code
+                            return false;
+                    }
+                break;
+                default:
+                    LogPrint(eLogError,"--- HTTP Proxy invalid state: ", m_state);
+                    HTTPRequestFailed(); //TODO: add correct code 500
+                    return false;
+            }
+            http_buff++;
+            len--;
+            if (m_state == DONE)
+                return CreateHTTPRequest(http_buff,len);
+        }
+        return true;
+    }
+
+    void HTTPProxyHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
+    {
+        LogPrint(eLogDebug,"--- HTTP Proxy sock recv: ", len);
+        if(ecode) 
+        {
+            LogPrint(eLogWarning," --- HTTP Proxy sock recv got error: ", ecode);
+                        Terminate();
+            return;
+        }
+
+        if (HandleData(m_http_buff, len)) 
+        {
+            if (m_state == DONE) 
+            {
+                LogPrint(eLogInfo,"--- HTTP Proxy requested: ", m_url);
+                GetOwner()->CreateStream (std::bind (&HTTPProxyHandler::HandleStreamRequestComplete,
+                        shared_from_this(), std::placeholders::_1), m_address, m_port);
+            } 
+            else 
+                AsyncSockRead();
+        }
+
+    }
+
+    void HTTPProxyHandler::SentHTTPFailed(const boost::system::error_code & ecode)
+    {
+        if (!ecode)
+            Terminate();
+        else 
+        {
+            LogPrint (eLogError,"--- HTTP Proxy Closing socket after sending failure because: ", ecode.message ());
+            Terminate();
+        }
+    }
+
+    void HTTPProxyHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream) 
+        {
+            if (Kill()) return;
+            LogPrint (eLogInfo,"--- HTTP Proxy New I2PTunnel connection");
+            auto connection = std::make_shared<i2p::client::I2PTunnelConnection>(GetOwner(), m_sock, stream);
+            GetOwner()->AddHandler (connection);
+            connection->I2PConnect (reinterpret_cast<const uint8_t*>(m_request.data()), m_request.size());
+            Done(shared_from_this());
+        } 
+        else 
+        {
+            LogPrint (eLogError,"--- HTTP Proxy Issue when creating the stream, check the previous warnings for more info.");
+            HTTPRequestFailed(); // TODO: Send correct error message host unreachable
+        }
+    }
+
+    HTTPProxyServer::HTTPProxyServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination): 
+        TCPIPAcceptor(address, port, localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination ()) 
+    {
+    }
+    
+    std::shared_ptr<i2p::client::I2PServiceHandler> HTTPProxyServer::CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+    {
+        return std::make_shared<HTTPProxyHandler> (this, socket);
+    }
+
+}
+}

client/HTTPProxy.h

@@ -0,0 +1,32 @@
+#ifndef HTTP_PROXY_H__
+#define HTTP_PROXY_H__
+
+#include <memory>
+#include <set>
+#include <boost/asio.hpp>
+#include <mutex>
+#include "I2PService.h"
+#include "Destination.h"
+
+namespace i2p
+{
+namespace proxy
+{
+    class HTTPProxyServer: public i2p::client::TCPIPAcceptor
+    {
+        public:
+
+            HTTPProxyServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
+            ~HTTPProxyServer() {};
+
+        protected:
+            // Implements TCPIPAcceptor
+            std::shared_ptr<i2p::client::I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+            const char* GetName() { return "HTTP Proxy"; }
+    };
+
+    typedef HTTPProxyServer HTTPProxy;
+}
+}
+
+#endif

client/HTTPServer.cpp

@@ -0,0 +1,264 @@
+#include <boost/bind.hpp>
+#include <ctime>
+#include <fstream>
+#include "util/Log.h"
+#include "util/util.h"
+#include "util/I2PEndian.h"
+#include "HTTPServer.h"
+
+namespace i2p {
+namespace util {
+
+HTTPConnection::HTTPConnection(boost::asio::ip::tcp::socket* socket,
+ std::shared_ptr<client::i2pcontrol::I2PControlSession> session)
+    : m_Socket(socket), m_BufferLen(0), m_Request(), m_Reply(), m_Session(session)
+{
+    
+}
+
+void HTTPConnection::Terminate()
+{
+    m_Socket->close();
+}
+
+void HTTPConnection::Receive()
+{
+    m_Socket->async_read_some(
+        boost::asio::buffer(m_Buffer, HTTP_CONNECTION_BUFFER_SIZE), std::bind(
+            &HTTPConnection::HandleReceive, shared_from_this(),
+            std::placeholders::_1, std::placeholders::_2
+        )
+    );
+}
+
+void HTTPConnection::HandleReceive(const boost::system::error_code& e, std::size_t nb_bytes)
+{
+    if(!e) {
+        m_Buffer[nb_bytes] = 0;
+        m_BufferLen = nb_bytes;
+        const std::string data = std::string(m_Buffer, m_Buffer + m_BufferLen);
+        if(!m_Request.hasData()) // New request
+            m_Request = i2p::util::http::Request(data);
+        else 
+            m_Request.update(data);
+
+        if(m_Request.isComplete()) {
+            RunRequest();
+            m_Request.clear();
+        } else {
+            Receive();
+        }
+    } else if(e != boost::asio::error::operation_aborted)
+        Terminate();
+}
+
+void HTTPConnection::RunRequest()
+{
+    try {
+      if(m_Request.getMethod() == "GET")
+          return HandleRequest();
+      if(m_Request.getHeader("Content-Type").find("application/json") != std::string::npos)
+          return HandleI2PControlRequest();
+    } catch(...) {
+        // Ignore the error for now, probably Content-Type doesn't exist
+        // Could also be invalid json data
+    }
+    // Unsupported method
+    m_Reply = i2p::util::http::Response(502, "");
+    SendReply();
+}
+
+void HTTPConnection::ExtractParams(const std::string& str, std::map<std::string, std::string>& params)
+{
+    if(str[0] != '&') return;
+    size_t pos = 1, end;
+    do
+    {
+        end = str.find('&', pos);
+        std::string param = str.substr(pos, end - pos);
+        LogPrint(param);
+        size_t e = param.find('=');
+        if(e != std::string::npos)
+            params[param.substr(0, e)] = param.substr(e+1);
+        pos = end + 1;
+    }   
+    while(end != std::string::npos);
+}
+
+void HTTPConnection::HandleWriteReply(const boost::system::error_code& e)
+{
+    if(e != boost::asio::error::operation_aborted) {
+        boost::system::error_code ignored_ec;
+        m_Socket->shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
+        Terminate();
+    }
+}
+
+void HTTPConnection::Send404Reply()
+{
+    try {
+        const std::string error_page = "404.html";
+        m_Reply = i2p::util::http::Response(404, GetFileContents(error_page, true));
+        m_Reply.setHeader("Content-Type", i2p::util::http::getMimeType(error_page));
+    } catch(const std::runtime_error&) {
+        // Failed to load 404.html, assume the webui is incorrectly installed
+        m_Reply = i2p::util::http::Response(404,
+            "<!DOCTYPE HTML><html>"
+            "<head><title>Error: 404 - webui not installed</title></head><body>"
+                "<p>It looks like your webui installation is broken.</p>"
+                "<p>Run the following command to (re)install it:</p>"
+                "<pre>./i2pd --install=/path/to/webui</pre>"
+                "<p>Or from a directory containing a folder named webui:</p>"
+                "<pre>./i2pd --install</pre>"
+                "<p>The webui folder should come with the binaries.</p>"
+            "</body></html>"
+        );
+    }
+    SendReply();
+}
+
+std::string HTTPConnection::GetFileContents(const std::string& filename, bool preprocess) const
+{
+    boost::system::error_code e;
+
+     // Use canonical to avoid .. or . in path
+    const boost::filesystem::path address = boost::filesystem::canonical(
+        i2p::util::filesystem::GetWebuiDataDir() / filename, e
+    );
+
+    const std::string address_str = address.string();
+    
+    std::ifstream ifs(address_str, std::ios_base::in | std::ios_base::binary);
+    if(e || !ifs || !isAllowed(address_str))
+        throw std::runtime_error("Cannot load " + address_str + ".");
+
+    std::string str;
+    ifs.seekg(0, ifs.end);
+    str.resize(ifs.tellg());
+    ifs.seekg(0, ifs.beg);
+    ifs.read(&str[0], str.size());
+    ifs.close();
+    
+    if(preprocess)
+        return i2p::util::http::preprocessContent(str, address.parent_path().string());
+    else
+        return str;
+}
+
+void HTTPConnection::HandleRequest()
+{
+
+    std::string uri = m_Request.getUri();
+    if(uri == "/")
+        uri = "index.html";
+
+    try {
+        m_Reply = i2p::util::http::Response(200, GetFileContents(uri, true));
+        m_Reply.setHeader("Content-Type", i2p::util::http::getMimeType(uri) + "; charset=UTF-8");
+        SendReply();
+    } catch(const std::runtime_error&) {
+        // Cannot open the file for some reason, send 404
+        Send404Reply();
+    }
+}
+
+void HTTPConnection::HandleI2PControlRequest()
+{
+    std::stringstream ss(m_Request.getContent());
+    const client::i2pcontrol::I2PControlSession::Response rsp = m_Session->handleRequest(ss);
+    m_Reply = i2p::util::http::Response(200, rsp.toJsonString());
+    m_Reply.setHeader("Content-Type", "application/json");
+    SendReply();
+}
+
+bool HTTPConnection::isAllowed(const std::string& address) const
+{
+    const std::size_t pos_dot = address.find_last_of('.');
+    const std::size_t pos_slash = address.find_last_of('/');
+    if(pos_dot == std::string::npos || pos_dot == address.size() - 1)
+        return false;
+    if(pos_slash != std::string::npos && pos_dot < pos_slash)
+        return false;
+    return true;
+}
+
+void HTTPConnection::SendReply()
+{
+    // we need the date header to be compliant with HTTP 1.1
+    std::time_t time_now = std::time(nullptr);
+    char time_buff[128];
+    if(std::strftime(time_buff, sizeof(time_buff), "%a, %d %b %Y %H:%M:%S GMT", std::gmtime(&time_now)) ) {
+        m_Reply.setHeader("Date", std::string(time_buff));
+        m_Reply.setContentLength();
+    }
+    boost::asio::async_write(
+        *m_Socket, boost::asio::buffer(m_Reply.toString()),
+        std::bind(&HTTPConnection::HandleWriteReply, shared_from_this(), std::placeholders::_1)
+    );
+}
+
+HTTPServer::HTTPServer(const std::string& address, int port):
+    m_Thread(nullptr), m_Work(m_Service),
+    m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
+        boost::asio::ip::address::from_string(address), port)
+    ),
+    m_NewSocket(nullptr),
+    m_Session(std::make_shared<client::i2pcontrol::I2PControlSession>(m_Service))
+{
+
+}
+
+HTTPServer::~HTTPServer()
+{
+    Stop();
+}
+
+void HTTPServer::Start()
+{
+    m_Thread = new std::thread(std::bind(&HTTPServer::Run, this));
+    m_Acceptor.listen();
+    m_Session->start();
+    Accept();
+}
+
+void HTTPServer::Stop()
+{
+    m_Session->stop();
+    m_Acceptor.close();
+    m_Service.stop();
+    if(m_Thread)
+    {
+        m_Thread->join();
+        delete m_Thread;
+        m_Thread = nullptr;
+    }
+}
+
+void HTTPServer::Run()
+{
+    m_Service.run();
+}
+
+void HTTPServer::Accept()
+{
+    m_NewSocket = new boost::asio::ip::tcp::socket(m_Service);
+    m_Acceptor.async_accept(*m_NewSocket, boost::bind(&HTTPServer::HandleAccept, this,
+        boost::asio::placeholders::error));
+}
+
+void HTTPServer::HandleAccept(const boost::system::error_code& ecode)
+{
+    if(!ecode) {
+        CreateConnection(m_NewSocket);
+        Accept();
+    }
+}
+
+void HTTPServer::CreateConnection(boost::asio::ip::tcp::socket* m_NewSocket)
+{
+    auto conn = std::make_shared<HTTPConnection>(m_NewSocket, m_Session);
+    conn->Receive();
+}
+
+}
+}

client/HTTPServer.h

@@ -0,0 +1,88 @@
+#ifndef HTTP_SERVER_H__
+#define HTTP_SERVER_H__
+
+#include <sstream>
+#include <thread>
+#include <memory>
+#include <boost/asio.hpp>
+#include <boost/array.hpp>
+#include "i2pcontrol/I2PControl.h"
+#include "util/HTTP.h"
+
+namespace i2p {
+namespace util {
+
+const size_t HTTP_CONNECTION_BUFFER_SIZE = 8192;    
+const int HTTP_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
+
+class HTTPConnection: public std::enable_shared_from_this<HTTPConnection> {
+public:
+
+    HTTPConnection(boost::asio::ip::tcp::socket* socket,
+        std::shared_ptr<i2p::client::i2pcontrol::I2PControlSession> session);
+
+    ~HTTPConnection() { delete m_Socket; }
+    void Receive();
+    
+private:
+
+    void Terminate();
+    void HandleReceive(const boost::system::error_code& ecode, std::size_t bytes_transferred);
+    void RunRequest();
+    void HandleWriteReply(const boost::system::error_code& ecode);
+    void SendReply();
+
+    void Send404Reply();
+
+    /*
+     * @throw std::runtime_error when the file is not accessible
+     */
+    std::string GetFileContents(const std::string& filename, bool preprocess) const;
+
+    void HandleRequest();
+    void HandleI2PControlRequest();
+    void ExtractParams(const std::string& str, std::map<std::string, std::string>& params);
+    
+    bool isAllowed(const std::string& address) const;
+private:
+    boost::asio::ip::tcp::socket* m_Socket;
+    char m_Buffer[HTTP_CONNECTION_BUFFER_SIZE + 1];
+    size_t m_BufferLen;
+    util::http::Request m_Request;
+    util::http::Response m_Reply;
+    std::shared_ptr<i2p::client::i2pcontrol::I2PControlSession> m_Session;
+};
+
+class HTTPServer {
+public:
+
+    HTTPServer(const std::string& address, int port);
+    virtual ~HTTPServer();
+
+    void Start();
+    void Stop();
+
+private:
+
+    void Run();
+    void Accept();
+    void HandleAccept(const boost::system::error_code& ecode);
+    
+private:
+
+    std::thread * m_Thread;
+    boost::asio::io_service m_Service;
+    boost::asio::io_service::work m_Work;
+    boost::asio::ip::tcp::acceptor m_Acceptor;
+    boost::asio::ip::tcp::socket * m_NewSocket;
+    std::shared_ptr<i2p::client::i2pcontrol::I2PControlSession> m_Session;
+
+protected:
+    void CreateConnection(boost::asio::ip::tcp::socket* m_NewSocket);
+};
+}
+}
+
+#endif
+
+

client/I2PService.cpp

@@ -0,0 +1,79 @@
+#include "Destination.h"
+#include "Identity.h"
+#include "ClientContext.h"
+#include "I2PService.h"
+
+
+namespace i2p
+{
+namespace client
+{
+    static const i2p::data::SigningKeyType I2P_SERVICE_DEFAULT_KEY_TYPE = i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256;
+
+    I2PService::I2PService (std::shared_ptr<ClientDestination> localDestination):
+        m_LocalDestination (localDestination ? localDestination :
+                    i2p::client::context.CreateNewLocalDestination (false, I2P_SERVICE_DEFAULT_KEY_TYPE))
+    {
+    }
+    
+    I2PService::I2PService (i2p::data::SigningKeyType kt):
+        m_LocalDestination (i2p::client::context.CreateNewLocalDestination (false, kt))
+    {
+    }
+    
+    void I2PService::CreateStream (StreamRequestComplete streamRequestComplete, const std::string& dest, int port) {
+        assert(streamRequestComplete);
+        i2p::data::IdentHash identHash;
+        if (i2p::client::context.GetAddressBook ().GetIdentHash (dest, identHash))
+            m_LocalDestination->CreateStream (streamRequestComplete, identHash, port);
+        else
+        {
+            LogPrint (eLogWarning, "Remote destination ", dest, " not found");
+            streamRequestComplete (nullptr);
+        }
+    }
+
+    void TCPIPAcceptor::Start ()
+    {
+        m_Acceptor.listen ();
+        Accept ();
+    }
+
+    void TCPIPAcceptor::Stop ()
+    {
+        m_Acceptor.close();
+        m_Timer.cancel ();
+        ClearHandlers();
+    }
+
+    void TCPIPAcceptor::Accept ()
+    {
+        auto newSocket = std::make_shared<boost::asio::ip::tcp::socket> (GetService ());
+        m_Acceptor.async_accept (*newSocket, std::bind (&TCPIPAcceptor::HandleAccept, this,
+            std::placeholders::_1, newSocket));
+    }
+
+    void TCPIPAcceptor::HandleAccept (const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+    {
+        if (!ecode)
+        {
+            LogPrint(eLogDebug,"--- ",GetName()," accepted");
+            auto handler = CreateHandler(socket);
+            if (handler) 
+            {
+                AddHandler(handler);
+                handler->Handle();
+            } 
+            else 
+                socket->close();
+            Accept();
+        }
+        else
+        {
+            if (ecode != boost::asio::error::operation_aborted)
+                LogPrint (eLogError,"--- ",GetName()," Closing socket on accept because: ", ecode.message ());
+        }
+    }
+
+}
+}

client/I2PService.h

@@ -0,0 +1,107 @@
+#ifndef I2PSERVICE_H__
+#define I2PSERVICE_H__
+
+#include <atomic>
+#include <mutex>
+#include <unordered_set>
+#include <memory>
+#include <boost/asio.hpp>
+#include "Destination.h"
+#include "Identity.h"
+
+namespace i2p
+{
+namespace client
+{
+    class I2PServiceHandler;
+    class I2PService
+    {
+        public:
+            I2PService (std::shared_ptr<ClientDestination> localDestination  = nullptr);
+            I2PService (i2p::data::SigningKeyType kt);
+            virtual ~I2PService () { ClearHandlers (); }
+
+            inline void AddHandler (std::shared_ptr<I2PServiceHandler> conn)
+            {
+                std::unique_lock<std::mutex> l(m_HandlersMutex);
+                m_Handlers.insert(conn);
+            }
+            inline void RemoveHandler (std::shared_ptr<I2PServiceHandler> conn)
+            {
+                std::unique_lock<std::mutex> l(m_HandlersMutex);
+                m_Handlers.erase(conn);
+            }
+            inline void ClearHandlers ()
+            {
+                std::unique_lock<std::mutex> l(m_HandlersMutex);
+                m_Handlers.clear();
+            }
+
+            inline std::shared_ptr<ClientDestination> GetLocalDestination () { return m_LocalDestination; }
+            inline void SetLocalDestination (std::shared_ptr<ClientDestination> dest) { m_LocalDestination = dest; }
+            void CreateStream (StreamRequestComplete streamRequestComplete, const std::string& dest, int port = 0);
+
+            inline boost::asio::io_service& GetService () { return m_LocalDestination->GetService (); }
+
+            virtual void Start () = 0;
+            virtual void Stop () = 0;
+
+            virtual const char* GetName() { return "Generic I2P Service"; }
+        private:
+
+            std::shared_ptr<ClientDestination> m_LocalDestination;
+            std::unordered_set<std::shared_ptr<I2PServiceHandler> > m_Handlers;
+            std::mutex m_HandlersMutex;
+    };
+
+    /*Simple interface for I2PHandlers, allows detection of finalization amongst other things */
+    class I2PServiceHandler
+    {
+        public:
+            I2PServiceHandler(I2PService * parent) : m_Service(parent), m_Dead(false) { }
+            virtual ~I2PServiceHandler() { }
+            //If you override this make sure you call it from the children
+            virtual void Handle() {}; //Start handling the socket
+        protected:
+            // Call when terminating or handing over to avoid race conditions
+            inline bool Kill () { return m_Dead.exchange(true); }
+            // Call to know if the handler is dead
+            inline bool Dead () { return m_Dead; }
+            // Call when done to clean up (make sure Kill is called first)
+            inline void Done (std::shared_ptr<I2PServiceHandler> me) { if(m_Service) m_Service->RemoveHandler(me); }
+            // Call to talk with the owner
+            inline I2PService * GetOwner() { return m_Service; }
+        private:
+            I2PService *m_Service;
+            std::atomic<bool> m_Dead; //To avoid cleaning up multiple times
+    };
+
+    /* TODO: support IPv6 too */
+    //This is a service that listens for connections on the IP network and interacts with I2P
+    class TCPIPAcceptor: public I2PService
+    {
+        public:
+            TCPIPAcceptor(const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination = nullptr)
+                : I2PService(localDestination), m_Acceptor(GetService(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address), port)),
+                  m_Timer (GetService()) {}
+            TCPIPAcceptor(const std::string& address, int port, i2p::data::SigningKeyType kt)
+                : I2PService(kt), m_Acceptor(GetService(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address), port)),
+                  m_Timer(GetService()) {}
+            virtual ~TCPIPAcceptor () { TCPIPAcceptor::Stop(); }
+            //If you override this make sure you call it from the children
+            void Start ();
+            //If you override this make sure you call it from the children
+            void Stop ();
+        protected:
+            virtual std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket) = 0;
+            virtual const char* GetName() { return "Generic TCP/IP accepting daemon"; }
+        private:
+            void Accept();
+            void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+            boost::asio::ip::tcp::acceptor m_Acceptor;
+            boost::asio::deadline_timer m_Timer;
+    };
+}
+}
+
+#endif

client/I2PTunnel.cpp

@@ -0,0 +1,405 @@
+#include <cassert>
+#include "util/Log.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "I2PTunnel.h"
+
+namespace i2p
+{
+namespace client
+{
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+        std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port): 
+        I2PServiceHandler(owner), m_Socket (socket), m_RemoteEndpoint (socket->remote_endpoint ()),
+        m_IsQuiet (true)
+    {
+        m_Stream = GetOwner()->GetLocalDestination ()->CreateStream (leaseSet, port);
+    }   
+
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<i2p::stream::Stream> stream):
+        I2PServiceHandler(owner), m_Socket (socket), m_Stream (stream),
+        m_RemoteEndpoint (socket->remote_endpoint ()), m_IsQuiet (true)
+    {
+    }
+
+    I2PTunnelConnection::I2PTunnelConnection (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, const boost::asio::ip::tcp::endpoint& target, bool quiet):
+        I2PServiceHandler(owner), m_Socket (socket), m_Stream (stream),
+        m_RemoteEndpoint (target), m_IsQuiet (quiet)
+    {
+    }
+
+    I2PTunnelConnection::~I2PTunnelConnection ()
+    {
+    }   
+
+    void I2PTunnelConnection::I2PConnect (const uint8_t * msg, size_t len)
+    {
+        if (m_Stream)
+        {
+            if (msg)
+                m_Stream->Send (msg, len); // connect and send
+            else    
+                m_Stream->Send (m_Buffer, 0); // connect
+        }
+        StreamReceive ();
+        Receive ();
+    }
+        
+    void I2PTunnelConnection::Connect ()
+    {
+        if (m_Socket)
+            m_Socket->async_connect (m_RemoteEndpoint, std::bind (&I2PTunnelConnection::HandleConnect,
+                shared_from_this (), std::placeholders::_1));
+    }   
+        
+    void I2PTunnelConnection::Terminate ()
+    {
+        if (Kill()) return;
+        if (m_Stream)
+        {
+            m_Stream->Close ();
+            m_Stream.reset ();
+        }   
+        m_Socket->close ();
+        Done(shared_from_this ());
+    }           
+
+    void I2PTunnelConnection::Receive ()
+    {
+        m_Socket->async_read_some (boost::asio::buffer(m_Buffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),                
+            std::bind(&I2PTunnelConnection::HandleReceived, shared_from_this (), 
+            std::placeholders::_1, std::placeholders::_2));
+    }   
+    
+    void I2PTunnelConnection::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {   
+            if (m_Stream)
+            {   
+                auto s = shared_from_this ();
+                m_Stream->AsyncSend (m_Buffer, bytes_transferred,
+                    [s](const boost::system::error_code& ecode)
+                    {
+                        if (!ecode)
+                            s->Receive ();
+                        else
+                            s->Terminate ();
+                    });
+            }   
+        }
+    }   
+
+    void I2PTunnelConnection::HandleWrite (const boost::system::error_code& ecode)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel write error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+            StreamReceive ();
+    }
+
+    void I2PTunnelConnection::StreamReceive ()
+    {
+        if (m_Stream)
+            m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),
+                std::bind (&I2PTunnelConnection::HandleStreamReceive, shared_from_this (),
+                    std::placeholders::_1, std::placeholders::_2),
+                I2P_TUNNEL_CONNECTION_MAX_IDLE);
+    }   
+
+    void I2PTunnelConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel stream read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+            Write (m_StreamBuffer, bytes_transferred);
+    }
+
+    void I2PTunnelConnection::Write (const uint8_t * buf, size_t len)
+    {
+        m_Socket->async_send (boost::asio::buffer (buf, len),
+            std::bind (&I2PTunnelConnection::HandleWrite, shared_from_this (), std::placeholders::_1));
+    }
+
+    void I2PTunnelConnection::HandleConnect (const boost::system::error_code& ecode)
+    {
+        if (ecode)
+        {
+            LogPrint ("I2PTunnel connect error: ", ecode.message ());
+            Terminate ();
+        }
+        else
+        {
+            LogPrint ("I2PTunnel connected");
+            if (m_IsQuiet)
+                StreamReceive ();
+            else
+            {
+                // send destination first like received from I2P
+                std::string dest = m_Stream->GetRemoteIdentity ().ToBase64 ();
+                dest += "\n";
+                memcpy (m_StreamBuffer, dest.c_str (), dest.size ());
+                HandleStreamReceive (boost::system::error_code (), dest.size ());
+            }   
+            Receive (); 
+        }
+    }
+
+    I2PTunnelConnectionHTTP::I2PTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+        const boost::asio::ip::tcp::endpoint& target, const std::string& host):
+        I2PTunnelConnection (owner, stream, socket, target), m_Host (host), m_HeaderSent (false)
+    {
+    }
+
+    void I2PTunnelConnectionHTTP::Write (const uint8_t * buf, size_t len)
+    {
+        if (m_HeaderSent)
+            I2PTunnelConnection::Write (buf, len);
+        else
+        {   
+            m_InHeader.clear ();
+            m_InHeader.write ((const char *)buf, len);
+            std::string line;
+            bool endOfHeader = false;
+            while (!endOfHeader)
+            {
+                std::getline(m_InHeader, line);
+                if (!m_InHeader.fail ())
+                {
+                    if (line.find ("Host:") != std::string::npos)
+                        m_OutHeader << "Host: " << m_Host << "\r\n";
+                    else
+                        m_OutHeader << line << "\n";
+                    if (line == "\r") endOfHeader = true;
+                }
+                else
+                    break;
+            }
+
+            if (endOfHeader)
+            {
+                m_OutHeader << m_InHeader.str (); // data right after header
+                m_HeaderSent = true;
+                I2PTunnelConnection::Write ((uint8_t *)m_OutHeader.str ().c_str (), m_OutHeader.str ().length ());
+            }
+        }   
+    }
+
+    /* This handler tries to stablish a connection with the desired server and dies if it fails to do so */
+    class I2PClientTunnelHandler: public I2PServiceHandler, public std::enable_shared_from_this<I2PClientTunnelHandler>
+    {
+        public:
+            I2PClientTunnelHandler (I2PClientTunnel * parent, i2p::data::IdentHash destination,
+                int destinationPort, std::shared_ptr<boost::asio::ip::tcp::socket> socket):
+                I2PServiceHandler(parent), m_DestinationIdentHash(destination), 
+                m_DestinationPort (destinationPort), m_Socket(socket) {};
+            void Handle();
+            void Terminate();
+        private:
+            void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
+            i2p::data::IdentHash m_DestinationIdentHash;
+            int m_DestinationPort;
+            std::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
+    };
+
+    void I2PClientTunnelHandler::Handle()
+    {
+        GetOwner()->GetLocalDestination ()->CreateStream ( 
+            std::bind (&I2PClientTunnelHandler::HandleStreamRequestComplete, shared_from_this(), std::placeholders::_1), 
+            m_DestinationIdentHash, m_DestinationPort);
+    }
+
+    void I2PClientTunnelHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {
+            if (Kill()) return;
+            LogPrint (eLogInfo,"New I2PTunnel connection");
+            auto connection = std::make_shared<I2PTunnelConnection>(GetOwner(), m_Socket, stream);
+            GetOwner()->AddHandler (connection);
+            connection->I2PConnect ();
+            Done(shared_from_this());
+        }
+        else
+        {
+            LogPrint (eLogError,"I2P Client Tunnel Issue when creating the stream, check the previous warnings for more info.");
+            Terminate();
+        }
+    }
+
+    void I2PClientTunnelHandler::Terminate()
+    {
+        if (Kill()) return;
+        if (m_Socket)
+        {
+            m_Socket->close();
+            m_Socket = nullptr;
+        }
+        Done(shared_from_this());
+    }
+
+    I2PClientTunnel::I2PClientTunnel(
+        const std::string& destination, const std::string& address, int port,
+        std::shared_ptr<ClientDestination> localDestination, int destinationPort
+    )
+        : TCPIPAcceptor(address, port, localDestination), m_Destination(destination),
+          m_DestinationIdentHash(nullptr), m_DestinationPort(destinationPort)
+    {}  
+
+    void I2PClientTunnel::Start ()
+    {
+        TCPIPAcceptor::Start ();
+        GetIdentHash();
+    }
+
+    void I2PClientTunnel::Stop ()
+    {
+        TCPIPAcceptor::Stop();
+        auto *originalIdentHash = m_DestinationIdentHash;
+        m_DestinationIdentHash = nullptr;
+        delete originalIdentHash;
+    }
+
+    /* HACK: maybe we should create a caching IdentHash provider in AddressBook */
+    const i2p::data::IdentHash * I2PClientTunnel::GetIdentHash ()
+    {
+        if (!m_DestinationIdentHash)
+        {
+            i2p::data::IdentHash identHash;
+            if (i2p::client::context.GetAddressBook ().GetIdentHash (m_Destination, identHash))
+                m_DestinationIdentHash = new i2p::data::IdentHash (identHash);
+            else
+                LogPrint (eLogWarning,"Remote destination ", m_Destination, " not found");
+        }
+        return m_DestinationIdentHash;
+    }
+
+    std::shared_ptr<I2PServiceHandler> I2PClientTunnel::CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+    {
+        const i2p::data::IdentHash *identHash = GetIdentHash();
+        if (identHash)
+            return  std::make_shared<I2PClientTunnelHandler>(this, *identHash, m_DestinationPort, socket);
+        else
+            return nullptr;
+    }
+
+    I2PServerTunnel::I2PServerTunnel (const std::string& address, int port, 
+        std::shared_ptr<ClientDestination> localDestination, int inport): 
+        I2PService (localDestination), m_Address (address), m_Port (port), m_IsAccessList (false)
+    {
+        m_PortDestination = localDestination->CreateStreamingDestination (inport > 0 ? inport : port);
+    }
+    
+    void I2PServerTunnel::Start ()
+    {
+        m_Endpoint.port (m_Port);   
+        boost::system::error_code ec;
+        auto addr = boost::asio::ip::address::from_string (m_Address, ec);
+        if (!ec)    
+        {
+            m_Endpoint.address (addr);
+            Accept ();
+        }
+        else
+        {
+            auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(GetService ());
+            resolver->async_resolve (boost::asio::ip::tcp::resolver::query (m_Address, ""), 
+                std::bind (&I2PServerTunnel::HandleResolve, this, 
+                    std::placeholders::_1, std::placeholders::_2, resolver));
+        }   
+    }
+
+    void I2PServerTunnel::Stop ()
+    {
+        ClearHandlers ();
+    }   
+
+    void I2PServerTunnel::HandleResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it, 
+        std::shared_ptr<boost::asio::ip::tcp::resolver> )
+    {   
+        if (!ecode)
+        {   
+            auto addr = (*it).endpoint ().address ();
+            LogPrint (eLogInfo, "server tunnel ", (*it).host_name (), " has been resolved to ", addr);  
+            m_Endpoint.address (addr);
+            Accept ();  
+        }   
+        else
+            LogPrint (eLogError, "Unable to resolve server tunnel address: ", ecode.message ());
+    }
+
+    void I2PServerTunnel::SetAccessList (const std::set<i2p::data::IdentHash>& accessList)
+    {
+        m_AccessList = accessList;
+        m_IsAccessList = true;      
+    }
+
+    void I2PServerTunnel::Accept ()
+    {
+        if (m_PortDestination)
+            m_PortDestination->SetAcceptor (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
+
+        auto localDestination = GetLocalDestination (); 
+        if (localDestination)
+        {
+            if (!localDestination->IsAcceptingStreams ()) // set it as default if not set yet
+                localDestination->AcceptStreams (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
+        }
+        else
+            LogPrint ("Local destination not set for server tunnel");
+    }
+
+    void I2PServerTunnel::HandleAccept (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {   
+            if (m_IsAccessList)
+            {
+                if (!m_AccessList.count (stream->GetRemoteIdentity ().GetIdentHash ()))
+                {
+                    LogPrint (eLogWarning, "Address ", stream->GetRemoteIdentity ().GetIdentHash ().ToBase32 (), " is not in white list. Incoming connection dropped");
+                    stream->Close ();
+                    return;
+                }
+            }
+            CreateI2PConnection (stream);
+        }   
+    }
+
+    void I2PServerTunnel::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        auto conn = std::make_shared<I2PTunnelConnection> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint ());
+        AddHandler (conn);
+        conn->Connect ();
+    }
+
+    I2PServerTunnelHTTP::I2PServerTunnelHTTP (const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, int inport):
+        I2PServerTunnel (address, port, localDestination, inport)
+    {
+    }
+
+    void I2PServerTunnelHTTP::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        auto conn = std::make_shared<I2PTunnelConnectionHTTP> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint (), GetAddress ());
+        AddHandler (conn);
+        conn->Connect ();
+    }
+}       
+}   

client/I2PTunnel.h

@@ -0,0 +1,156 @@
+#ifndef I2PTUNNEL_H__
+#define I2PTUNNEL_H__
+
+#include <inttypes.h>
+#include <string>
+#include <set>
+#include <memory>
+#include <sstream>
+#include <boost/asio.hpp>
+#include "Identity.h"
+#include "Destination.h"
+#include "Streaming.h"
+#include "I2PService.h"
+
+namespace i2p
+{
+namespace client
+{
+    const size_t I2P_TUNNEL_CONNECTION_BUFFER_SIZE = 8192;
+    const int I2P_TUNNEL_CONNECTION_MAX_IDLE = 3600; // in seconds  
+    const int I2P_TUNNEL_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
+
+
+    class I2PTunnelConnection: public I2PServiceHandler, public std::enable_shared_from_this<I2PTunnelConnection>
+    {
+        public:
+
+            I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+                std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port = 0); // to I2P
+            I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+                std::shared_ptr<i2p::stream::Stream> stream); // to I2P using simplified API 
+            I2PTunnelConnection (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,  std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+                const boost::asio::ip::tcp::endpoint& target, bool quiet = true); // from I2P
+            ~I2PTunnelConnection ();
+            void I2PConnect (const uint8_t * msg = nullptr, size_t len = 0);
+            void Connect ();
+            
+        protected:
+
+            void Terminate ();  
+
+            void Receive ();
+            void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);    
+            virtual void Write (const uint8_t * buf, size_t len); // can be overloaded
+            void HandleWrite (const boost::system::error_code& ecode);  
+
+            void StreamReceive ();
+            void HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void HandleConnect (const boost::system::error_code& ecode);
+
+        private:
+
+            uint8_t m_Buffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE], m_StreamBuffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE];
+            std::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
+            std::shared_ptr<i2p::stream::Stream> m_Stream;
+            boost::asio::ip::tcp::endpoint m_RemoteEndpoint;
+            bool m_IsQuiet; // don't send destination
+    };
+
+    class I2PTunnelConnectionHTTP: public I2PTunnelConnection
+    {
+        public:
+            
+            I2PTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+                std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+                const boost::asio::ip::tcp::endpoint& target, const std::string& host); 
+
+        protected:
+
+            void Write (const uint8_t * buf, size_t len);
+
+        private:
+        
+            std::string m_Host;
+            std::stringstream m_InHeader, m_OutHeader;
+            bool m_HeaderSent;
+    };
+
+    class I2PClientTunnel: public TCPIPAcceptor
+    {
+        protected:
+
+            // Implements TCPIPAcceptor
+            std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+            const char* GetName() { return "I2P Client Tunnel"; }
+
+        public:
+
+            I2PClientTunnel(
+                const std::string& destination, const std::string& address, int port,
+                std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0
+            );
+            ~I2PClientTunnel () {}
+    
+            void Start ();
+            void Stop ();
+
+        private:
+
+            const i2p::data::IdentHash * GetIdentHash ();
+
+            std::string m_Destination;
+            const i2p::data::IdentHash * m_DestinationIdentHash;
+            int m_DestinationPort;  
+    };  
+
+    class I2PServerTunnel: public I2PService
+    {
+        public:
+
+            I2PServerTunnel (const std::string& address, int port, 
+                std::shared_ptr<ClientDestination> localDestination, int inport = 0);   
+
+            void Start ();
+            void Stop ();
+
+            void SetAccessList (const std::set<i2p::data::IdentHash>& accessList); 
+
+            const std::string& GetAddress() const { return m_Address; }
+            int GetPort () const { return m_Port; };
+            const boost::asio::ip::tcp::endpoint& GetEndpoint () const { return m_Endpoint; }
+
+        private:
+
+            void HandleResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it, 
+                std::shared_ptr<boost::asio::ip::tcp::resolver> resolver);
+
+            void Accept ();
+            void HandleAccept (std::shared_ptr<i2p::stream::Stream> stream);
+            virtual void CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
+
+        private:
+
+            std::string m_Address;
+            int m_Port;
+            boost::asio::ip::tcp::endpoint m_Endpoint;  
+            std::shared_ptr<i2p::stream::StreamingDestination> m_PortDestination;
+            std::set<i2p::data::IdentHash> m_AccessList;
+            bool m_IsAccessList;            
+    };
+
+    class I2PServerTunnelHTTP: public I2PServerTunnel
+    {
+        public:
+
+            I2PServerTunnelHTTP (const std::string& address, int port, 
+                std::shared_ptr<ClientDestination> localDestination, int inport = 0);   
+
+        private:
+
+            void CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream); 
+    };
+}
+}   
+
+#endif

client/SAM.cpp

@@ -0,0 +1,941 @@
+#include <string.h>
+#include <stdio.h>
+#ifdef _MSC_VER
+#include <stdlib.h>
+#endif
+#include <boost/lexical_cast.hpp>
+#include "util/base64.h"
+#include "Identity.h"
+#include "util/Log.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "SAM.h"
+
+namespace i2p
+{
+namespace client
+{
+    SAMSocket::SAMSocket (SAMBridge& owner): 
+        m_Owner (owner), m_Socket (m_Owner.GetService ()), m_Timer (m_Owner.GetService ()),
+        m_BufferOffset (0), m_SocketType (eSAMSocketTypeUnknown), m_IsSilent (false), 
+        m_Stream (nullptr), m_Session (nullptr)
+    {
+    }
+
+    SAMSocket::~SAMSocket ()
+    {
+        Terminate ();
+    }   
+
+    void SAMSocket::CloseStream ()
+    {
+        if (m_Stream)
+        {   
+            m_Stream->Close ();
+            m_Stream.reset ();
+        }   
+    }   
+        
+    void SAMSocket::Terminate ()
+    {
+        CloseStream ();
+        
+        switch (m_SocketType)
+        {
+            case eSAMSocketTypeUDPForward:
+            case eSAMSocketTypeSession:
+                m_Owner.CloseSession (m_ID);
+            break;
+            case eSAMSocketTypeStream:
+            {
+                if (m_Session)
+                    m_Session->sockets.remove (shared_from_this ());
+                break;
+            }
+            case eSAMSocketTypeAcceptor:
+            {
+                if (m_Session)
+                {
+                    m_Session->sockets.remove (shared_from_this ());
+                    m_Session->localDestination->StopAcceptingStreams ();
+                }
+                break;
+            }
+            default:
+                ;
+        }
+        m_SocketType = eSAMSocketTypeTerminated;
+        m_Socket.close ();
+    }
+
+    void SAMSocket::ReceiveHandshake ()
+    {
+        m_Socket.async_read_some (boost::asio::buffer(m_Buffer, SAM_SOCKET_BUFFER_SIZE),                
+            std::bind(&SAMSocket::HandleHandshakeReceived, shared_from_this (), 
+            std::placeholders::_1, std::placeholders::_2));
+    }
+
+    void SAMSocket::HandleHandshakeReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM handshake read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {   
+            m_Buffer[bytes_transferred] = 0;
+            char * eol = (char *)memchr (m_Buffer, '\n', bytes_transferred);
+            if (eol)
+                *eol = 0;
+            LogPrint ("SAM handshake ", m_Buffer);
+            char * separator = strchr (m_Buffer, ' ');
+            if (separator)
+            {
+                separator = strchr (separator + 1, ' ');    
+                if (separator) 
+                    *separator = 0;
+            }
+
+            if (!strcmp (m_Buffer, SAM_HANDSHAKE))
+            {
+                std::string version("3.0");
+                // try to find MIN and MAX, 3.0 if not found
+                if (separator)
+                {
+                    separator++;
+                    std::map<std::string, std::string> params;
+                    ExtractParams (separator, params);
+                    auto it = params.find (SAM_PARAM_MAX);
+                    // TODO: check MIN as well
+                    if (it != params.end ())
+                        version = it->second;
+                }
+                if (version[0] == '3') // we support v3 (3.0 and 3.1) only
+                {
+#ifdef _MSC_VER
+                    size_t l = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_HANDSHAKE_REPLY, version.c_str ());
+#else       
+                    size_t l = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_HANDSHAKE_REPLY, version.c_str ());
+#endif
+                    boost::asio::async_write (m_Socket, boost::asio::buffer (m_Buffer, l), boost::asio::transfer_all (),
+                        std::bind(&SAMSocket::HandleHandshakeReplySent, shared_from_this (), 
+                        std::placeholders::_1, std::placeholders::_2));
+                }   
+                else
+                    SendMessageReply (SAM_HANDSHAKE_I2P_ERROR, strlen (SAM_HANDSHAKE_I2P_ERROR), true);
+            }
+            else
+            {
+                LogPrint ("SAM handshake mismatch");
+                Terminate ();
+            }
+        }
+    }
+
+    void SAMSocket::HandleHandshakeReplySent (const boost::system::error_code& ecode, std::size_t)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM handshake reply send error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            m_Socket.async_read_some (boost::asio::buffer(m_Buffer, SAM_SOCKET_BUFFER_SIZE),                
+                std::bind(&SAMSocket::HandleMessage, shared_from_this (), 
+                std::placeholders::_1, std::placeholders::_2)); 
+        }   
+    }
+
+    void SAMSocket::SendMessageReply (const char * msg, size_t len, bool close)
+    {
+        if (!m_IsSilent) 
+            boost::asio::async_write (m_Socket, boost::asio::buffer (msg, len), boost::asio::transfer_all (),
+                std::bind(&SAMSocket::HandleMessageReplySent, shared_from_this (), 
+                std::placeholders::_1, std::placeholders::_2, close));
+        else
+        {
+            if (close)
+                Terminate ();
+            else
+                Receive (); 
+        }       
+    }
+
+    void SAMSocket::HandleMessageReplySent (const boost::system::error_code& ecode, std::size_t, bool close)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM reply send error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            if (close)
+                Terminate ();
+            else
+                Receive (); 
+        }   
+    }
+
+    void SAMSocket::HandleMessage (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            bytes_transferred += m_BufferOffset;
+            m_BufferOffset = 0;
+            m_Buffer[bytes_transferred] = 0;
+            char * eol = (char *)memchr (m_Buffer, '\n', bytes_transferred);
+            if (eol)
+            {
+                *eol = 0;
+                char * separator = strchr (m_Buffer, ' ');
+                if (separator)
+                {
+                    separator = strchr (separator + 1, ' ');    
+                    if (separator) 
+                        *separator = 0;
+                    else
+                        separator = eol;
+
+                    if (!strcmp (m_Buffer, SAM_SESSION_CREATE))
+                        ProcessSessionCreate (separator + 1, bytes_transferred - (separator - m_Buffer) - 1);
+                    else if (!strcmp (m_Buffer, SAM_STREAM_CONNECT))
+                        ProcessStreamConnect (separator + 1, bytes_transferred - (separator - m_Buffer) - 1);
+                    else if (!strcmp (m_Buffer, SAM_STREAM_ACCEPT))
+                        ProcessStreamAccept (separator + 1, bytes_transferred - (separator - m_Buffer) - 1);
+                    else if (!strcmp (m_Buffer, SAM_DEST_GENERATE))
+                        ProcessDestGenerate ();
+                    else if (!strcmp (m_Buffer, SAM_NAMING_LOOKUP))
+                        ProcessNamingLookup (separator + 1, bytes_transferred - (separator - m_Buffer) - 1);
+                    else if (!strcmp (m_Buffer, SAM_DATAGRAM_SEND))
+                    {
+                        size_t len = bytes_transferred - (separator - m_Buffer) - 1;
+                        size_t processed = ProcessDatagramSend (separator + 1, len, eol + 1);
+                        if (processed < len)
+                        {
+                            m_BufferOffset = len - processed;
+                            if (processed > 0)
+                                memmove (m_Buffer, separator + 1 + processed, m_BufferOffset);
+                            else
+                            {
+                                // restore string back
+                                *separator = ' ';
+                                *eol = '\n';
+                            }
+                        }   
+                        // since it's SAM v1 reply is not expected
+                        Receive ();
+                    }
+                    else        
+                    {   
+                        LogPrint (eLogError, "SAM unexpected message ", m_Buffer);      
+                        Terminate ();
+                    }
+                }
+                else
+                {
+                    LogPrint (eLogError, "SAM malformed message ", m_Buffer);
+                    Terminate ();
+                }
+            }
+            else
+            {   
+                LogPrint (eLogWarning, "SAM incomplete message ", bytes_transferred);
+                m_BufferOffset = bytes_transferred;
+                // try to receive remaining message
+                Receive ();
+            }
+        }
+    }
+
+    void SAMSocket::ProcessSessionCreate (char * buf, size_t)
+    {
+        LogPrint ("SAM session create: ", buf);
+        std::map<std::string, std::string> params;
+        ExtractParams (buf, params);
+        std::string& style = params[SAM_PARAM_STYLE]; 
+        std::string& id = params[SAM_PARAM_ID];
+        std::string& destination = params[SAM_PARAM_DESTINATION];
+        m_ID = id; 
+        if (m_Owner.FindSession (id))
+        {
+            // session exists
+            SendMessageReply (SAM_SESSION_CREATE_DUPLICATED_ID, strlen(SAM_SESSION_CREATE_DUPLICATED_ID), true);
+            return;
+        }
+
+        // create destination   
+        m_Session = m_Owner.CreateSession (id, destination == SAM_VALUE_TRANSIENT ? "" : destination, &params); 
+        if (m_Session)
+        {
+            m_SocketType = eSAMSocketTypeSession;
+            if (style == SAM_VALUE_DATAGRAM)
+            {
+                auto dest = m_Session->localDestination->CreateDatagramDestination ();
+                auto portitr = params.find(SAM_PARAM_PORT);
+                
+                if ( portitr != params.end() ) {
+                    // port parameter set, this means they want to do UDP forward
+                    auto port = boost::lexical_cast<int> (portitr->second);
+                    // XXX: have default host configurable?
+                    std::string host = "127.0.0.1";
+                    
+                    auto hostitr = params.find(SAM_PARAM_HOST);
+                    if ( hostitr != params.end() ) {
+                        // host parameter set use that instead of loopback
+                        host = hostitr->second;
+                    }
+                    // set forward address
+                    m_udpForward = boost::asio::ip::udp::endpoint(boost::asio::ip::address::from_string(host), port);
+                    // we are now a udp forward socket
+                    m_SocketType = eSAMSocketTypeUDPForward;
+                }
+                dest->SetReceiver (std::bind (&SAMSocket::HandleI2PDatagramReceive, shared_from_this (), 
+                                              std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
+                 
+            }
+
+            if (m_Session->localDestination->IsReady ())
+                SendSessionCreateReplyOk ();
+            else
+            {
+                m_Timer.expires_from_now (boost::posix_time::seconds(SAM_SESSION_READINESS_CHECK_INTERVAL));
+                m_Timer.async_wait (std::bind (&SAMSocket::HandleSessionReadinessCheckTimer,
+                    shared_from_this (), std::placeholders::_1));   
+            }
+        }
+        else
+            SendMessageReply (SAM_SESSION_CREATE_DUPLICATED_DEST, strlen(SAM_SESSION_CREATE_DUPLICATED_DEST), true);
+    }
+
+    void SAMSocket::HandleSessionReadinessCheckTimer (const boost::system::error_code& ecode)
+    {
+        if (ecode != boost::asio::error::operation_aborted)
+        {
+            if (m_Session->localDestination->IsReady ())
+                SendSessionCreateReplyOk ();
+            else
+            {
+                m_Timer.expires_from_now (boost::posix_time::seconds(SAM_SESSION_READINESS_CHECK_INTERVAL));
+                m_Timer.async_wait (std::bind (&SAMSocket::HandleSessionReadinessCheckTimer,
+                    shared_from_this (), std::placeholders::_1));
+            }   
+        }
+    }
+
+    void SAMSocket::SendSessionCreateReplyOk ()
+    {
+        uint8_t buf[1024];
+        char priv[1024];
+        size_t l = m_Session->localDestination->GetPrivateKeys ().ToBuffer (buf, 1024);
+        size_t l1 = i2p::util::ByteStreamToBase64 (buf, l, priv, 1024);
+        priv[l1] = 0;
+#ifdef _MSC_VER
+        size_t l2 = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_SESSION_CREATE_REPLY_OK, priv);
+#else       
+        size_t l2 = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_SESSION_CREATE_REPLY_OK, priv);
+#endif
+        SendMessageReply (m_Buffer, l2, false);
+    }
+
+    void SAMSocket::ProcessStreamConnect (char * buf, size_t)
+    {
+        LogPrint (eLogDebug, "SAM stream connect: ", buf);
+        std::map<std::string, std::string> params;
+        ExtractParams (buf, params);
+        std::string& id = params[SAM_PARAM_ID];
+        std::string& destination = params[SAM_PARAM_DESTINATION];
+        std::string& silent = params[SAM_PARAM_SILENT];
+        if (silent == SAM_VALUE_TRUE) m_IsSilent = true;    
+        m_ID = id;
+        m_Session = m_Owner.FindSession (id);
+        if (m_Session)
+        {
+            i2p::data::IdentityEx dest;
+            size_t len = dest.FromBase64(destination);
+            if (len > 0)
+            {
+                context.GetAddressBook().InsertAddress(dest);
+                auto leaseSet = m_Session->localDestination->FindLeaseSet(dest.GetIdentHash());
+                if (leaseSet)
+                    Connect(leaseSet);
+                else
+                {
+                    m_Session->localDestination->RequestDestination(dest.GetIdentHash(),
+                        std::bind(&SAMSocket::HandleConnectLeaseSetRequestComplete,
+                        shared_from_this(), std::placeholders::_1));
+                }
+            }
+            else
+                SendMessageReply(SAM_SESSION_STATUS_INVALID_KEY, strlen(SAM_SESSION_STATUS_INVALID_KEY), true);
+        }
+        else
+            SendMessageReply (SAM_STREAM_STATUS_INVALID_ID, strlen(SAM_STREAM_STATUS_INVALID_ID), true);        
+    }
+
+    void SAMSocket::Connect (std::shared_ptr<const i2p::data::LeaseSet> remote)
+    {
+        m_SocketType = eSAMSocketTypeStream;
+        m_Session->sockets.push_back (shared_from_this ());
+        m_Stream = m_Session->localDestination->CreateStream (remote);
+        m_Stream->Send ((uint8_t *)m_Buffer, 0); // connect
+        I2PReceive ();          
+        SendMessageReply (SAM_STREAM_STATUS_OK, strlen(SAM_STREAM_STATUS_OK), false);
+    }
+
+    void SAMSocket::HandleConnectLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet)
+    {
+        if (leaseSet)
+            Connect (leaseSet);
+        else
+        {
+            LogPrint ("SAM destination to connect not found");
+            SendMessageReply (SAM_STREAM_STATUS_CANT_REACH_PEER, strlen(SAM_STREAM_STATUS_CANT_REACH_PEER), true);
+        }
+    }
+
+    void SAMSocket::ProcessStreamAccept (char * buf, size_t)
+    {
+        LogPrint (eLogDebug, "SAM stream accept: ", buf);
+        std::map<std::string, std::string> params;
+        ExtractParams (buf, params);
+        std::string& id = params[SAM_PARAM_ID];
+        std::string& silent = params[SAM_PARAM_SILENT];
+        if (silent == SAM_VALUE_TRUE) m_IsSilent = true;    
+        m_ID = id;
+        m_Session = m_Owner.FindSession (id);
+        if (m_Session)
+        {
+            if (!m_Session->localDestination->IsAcceptingStreams ())
+            {
+                m_SocketType = eSAMSocketTypeAcceptor;
+                m_Session->sockets.push_back (shared_from_this ());
+                m_Session->localDestination->AcceptStreams (std::bind (&SAMSocket::HandleI2PAccept, shared_from_this (), std::placeholders::_1));
+                SendMessageReply (SAM_STREAM_STATUS_OK, strlen(SAM_STREAM_STATUS_OK), false);
+            }
+            else
+                SendMessageReply (SAM_STREAM_STATUS_I2P_ERROR, strlen(SAM_STREAM_STATUS_I2P_ERROR), true);
+        }   
+        else
+            SendMessageReply (SAM_STREAM_STATUS_INVALID_ID, strlen(SAM_STREAM_STATUS_INVALID_ID), true);
+    }
+
+    size_t SAMSocket::ProcessDatagramSend (char * buf, size_t len, const char * data)
+    {
+        LogPrint (eLogDebug, "SAM datagram send: ", buf, " ", len);
+        std::map<std::string, std::string> params;
+        ExtractParams (buf, params);
+        size_t size = boost::lexical_cast<int>(params[SAM_PARAM_SIZE]), offset = data - buf;
+        if (offset + size <= len)
+        {   
+            if (m_Session)
+            {   
+                auto d = m_Session->localDestination->GetDatagramDestination ();
+                if (d)
+                {
+                    i2p::data::IdentityEx dest;
+                    dest.FromBase64 (params[SAM_PARAM_DESTINATION]);
+                    d->SendDatagramTo ((const uint8_t *)data, size, dest.GetIdentHash ());
+                }
+                else
+                    LogPrint (eLogError, "SAM missing datagram destination");
+            }
+            else
+                LogPrint (eLogError, "SAM session is not created from DATAGRAM SEND");
+        }   
+        else
+        {
+            LogPrint (eLogWarning, "SAM sent datagram size ", size, " exceeds buffer ", len - offset);
+            return 0; // try to receive more
+        }   
+        return offset + size;
+    }   
+        
+    void SAMSocket::ProcessDestGenerate ()
+    {
+        LogPrint (eLogDebug, "SAM dest generate");
+        auto keys = i2p::data::PrivateKeys::CreateRandomKeys ();
+#ifdef _MSC_VER
+        size_t len = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_DEST_REPLY, 
+            keys.GetPublic ().ToBase64 ().c_str (), keys.ToBase64 ().c_str ()); 
+#else                                   
+        size_t len = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_DEST_REPLY, 
+            keys.GetPublic ().ToBase64 ().c_str (), keys.ToBase64 ().c_str ());
+#endif
+        SendMessageReply (m_Buffer, len, false);
+    }
+
+    void SAMSocket::ProcessNamingLookup (char * buf, size_t)
+    {
+        LogPrint (eLogDebug, "SAM naming lookup: ", buf);
+        std::map<std::string, std::string> params;
+        ExtractParams (buf, params);
+        std::string& name = params[SAM_PARAM_NAME];
+        i2p::data::IdentityEx identity;
+        i2p::data::IdentHash ident;
+        if (name == "ME")
+            SendNamingLookupReply (m_Session->localDestination->GetIdentity ());
+        else if (context.GetAddressBook ().GetAddress (name, identity))
+            SendNamingLookupReply (identity);
+        else if (m_Session && m_Session->localDestination &&
+            context.GetAddressBook ().GetIdentHash (name, ident))
+        {
+            auto leaseSet = m_Session->localDestination->FindLeaseSet (ident);
+            if (leaseSet)
+                SendNamingLookupReply (leaseSet->GetIdentity ());
+            else
+                m_Session->localDestination->RequestDestination (ident, 
+                    std::bind (&SAMSocket::HandleNamingLookupLeaseSetRequestComplete,
+                    shared_from_this (), std::placeholders::_1, ident));    
+        }   
+        else 
+        {
+            LogPrint ("SAM naming failed. Unknown address ", name);
+#ifdef _MSC_VER
+            size_t len = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY_INVALID_KEY, name.c_str());
+#else               
+            size_t len = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY_INVALID_KEY, name.c_str());
+#endif
+            SendMessageReply (m_Buffer, len, false);
+        }
+    }   
+
+    void  SAMSocket::HandleNamingLookupLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, i2p::data::IdentHash ident)
+    {
+        if (leaseSet)
+        {   
+            context.GetAddressBook ().InsertAddress (leaseSet->GetIdentity ());
+            SendNamingLookupReply (leaseSet->GetIdentity ());
+        }   
+        else
+        {
+            LogPrint (eLogInfo, "SAM naming lookup failed. LeaseSet for ", ident.ToBase32 (), " not found");
+#ifdef _MSC_VER
+            size_t len = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY_INVALID_KEY, 
+                context.GetAddressBook ().ToAddress (ident).c_str());
+#else               
+            size_t len = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY_INVALID_KEY,
+                context.GetAddressBook ().ToAddress (ident).c_str());
+#endif
+            SendMessageReply (m_Buffer, len, false);
+        }
+    }   
+        
+    void SAMSocket::SendNamingLookupReply (const i2p::data::IdentityEx& identity)
+    {
+        auto base64 = identity.ToBase64 ();
+#ifdef _MSC_VER
+        size_t l = sprintf_s (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY, base64.c_str ());     
+#else           
+        size_t l = snprintf (m_Buffer, SAM_SOCKET_BUFFER_SIZE, SAM_NAMING_REPLY, base64.c_str ());
+#endif
+        SendMessageReply (m_Buffer, l, false);
+    }
+
+    void SAMSocket::ExtractParams (char * buf, std::map<std::string, std::string>& params)
+    {
+        char * separator;   
+        do
+        {
+            separator = strchr (buf, ' ');
+            if (separator) *separator = 0;
+            char * value = strchr (buf, '=');
+            if (value)
+            {
+                *value = 0;
+                value++;
+                params[buf] = value;
+            }   
+            buf = separator + 1;
+        }
+        while (separator);
+    }   
+
+    void SAMSocket::Receive ()
+    {
+        if (m_BufferOffset >= SAM_SOCKET_BUFFER_SIZE)
+        {
+            LogPrint (eLogError, "Buffer is full. Terminate");
+            Terminate ();
+            return;
+        }
+        m_Socket.async_read_some (boost::asio::buffer(m_Buffer + m_BufferOffset, SAM_SOCKET_BUFFER_SIZE - m_BufferOffset),                
+            std::bind((m_SocketType == eSAMSocketTypeStream) ? &SAMSocket::HandleReceived : &SAMSocket::HandleMessage,
+            shared_from_this (), std::placeholders::_1, std::placeholders::_2));
+    }
+
+    void SAMSocket::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            if (m_Stream)
+            {   
+                auto s = shared_from_this ();
+                m_Stream->AsyncSend ((uint8_t *)m_Buffer, bytes_transferred,
+                    [s](const boost::system::error_code& ecode)
+                    {
+                        if (!ecode)
+                            s->Receive ();
+                        else
+                            s->Terminate ();
+                    });
+            }   
+        }
+    }
+
+    void SAMSocket::I2PReceive ()
+    {
+        if (m_Stream)
+            m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, SAM_SOCKET_BUFFER_SIZE),
+                std::bind (&SAMSocket::HandleI2PReceive, shared_from_this (),
+                    std::placeholders::_1, std::placeholders::_2),
+                SAM_SOCKET_CONNECTION_MAX_IDLE);
+    }   
+
+    void SAMSocket::HandleI2PReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM stream read error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+        {
+            boost::asio::async_write (m_Socket, boost::asio::buffer (m_StreamBuffer, bytes_transferred),
+                std::bind (&SAMSocket::HandleWriteI2PData, shared_from_this (), std::placeholders::_1));
+        }
+    }
+
+    void SAMSocket::HandleWriteI2PData (const boost::system::error_code& ecode)
+    {
+        if (ecode)
+        {
+            LogPrint ("SAM socket write error: ", ecode.message ());
+            if (ecode != boost::asio::error::operation_aborted)
+                Terminate ();
+        }
+        else
+            I2PReceive ();
+    }
+
+    void SAMSocket::HandleI2PAccept (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream)
+        {
+            LogPrint ("SAM incoming I2P connection for session ", m_ID);
+            m_Stream = stream;
+            context.GetAddressBook ().InsertAddress (stream->GetRemoteIdentity ());
+            auto session = m_Owner.FindSession (m_ID);
+            if (session)    
+                session->localDestination->StopAcceptingStreams (); 
+            m_SocketType = eSAMSocketTypeStream;
+            if (!m_IsSilent)
+            {
+                // send remote peer address
+                uint8_t ident[1024];
+                size_t l = stream->GetRemoteIdentity ().ToBuffer (ident, 1024);
+                size_t l1 = i2p::util::ByteStreamToBase64 (ident, l, (char *)m_StreamBuffer, SAM_SOCKET_BUFFER_SIZE);
+                m_StreamBuffer[l1] = '\n';
+                HandleI2PReceive (boost::system::error_code (), l1 +1); // we send identity like it has been received from stream
+            }   
+            else
+                I2PReceive ();
+        }
+        else
+            LogPrint (eLogInfo, "SAM I2P acceptor has been reset");
+    }   
+
+    void SAMSocket::HandleI2PDatagramReceive (const i2p::data::IdentityEx& from, uint16_t, uint16_t, const uint8_t * buf, size_t len)
+    {
+        LogPrint (eLogDebug, "SAM datagram received ", len);
+        if (m_SocketType == eSAMSocketTypeUDPForward)
+        {
+            // use the bridge to forward it via udp
+            m_Owner.ForwardUDP(m_udpForward, from, buf, len); 
+        } else {
+            auto base64 = from.ToBase64 ();
+            // use the session socket
+#ifdef _MSC_VER
+            size_t l = sprintf_s ((char *)m_StreamBuffer, SAM_SOCKET_BUFFER_SIZE, SAM_DATAGRAM_RECEIVED, base64.c_str (), len);     
+#else           
+            size_t l = snprintf ((char *)m_StreamBuffer, SAM_SOCKET_BUFFER_SIZE, SAM_DATAGRAM_RECEIVED, base64.c_str (), len);  
+#endif
+            if (len < SAM_SOCKET_BUFFER_SIZE - l)   
+            {   
+                memcpy (m_StreamBuffer + l, buf, len);
+                boost::asio::async_write (m_Socket, boost::asio::buffer (m_StreamBuffer, len + l),
+                                          std::bind (&SAMSocket::HandleWriteI2PData, shared_from_this (), std::placeholders::_1));
+            }
+            else
+                LogPrint (eLogWarning, "SAM received datagram size ", len," exceeds buffer");
+        }
+    }
+
+    SAMSession::SAMSession (std::shared_ptr<ClientDestination> dest):
+        localDestination (dest)
+    {
+    }
+        
+    SAMSession::~SAMSession ()
+    {
+        for (auto it: sockets)
+            it->SetSocketType (eSAMSocketTypeTerminated);
+        i2p::client::context.DeleteLocalDestination (localDestination);
+    }
+
+    void SAMSession::CloseStreams ()
+    {
+        for (auto it: sockets)
+        {   
+            it->CloseStream ();
+            it->SetSocketType (eSAMSocketTypeTerminated);
+        }   
+        sockets.clear ();
+    }
+
+    SAMBridge::SAMBridge(const std::string& address, int port)
+        : m_IsRunning (false), m_Thread (nullptr),
+          m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
+            boost::asio::ip::address::from_string(address), port)
+          ),
+          m_DatagramEndpoint(boost::asio::ip::address::from_string(address), port - 1),
+          m_DatagramSocket(m_Service, m_DatagramEndpoint),
+          m_Forward(nullptr)
+    {
+    }
+
+    SAMBridge::~SAMBridge ()
+    {
+        if (m_IsRunning)
+            Stop ();
+    }   
+
+    void SAMBridge::Start ()
+    {
+        Accept ();
+        ReceiveDatagram ();
+        m_IsRunning = true;
+        m_Thread = new std::thread (std::bind (&SAMBridge::Run, this));
+    }
+
+    void SAMBridge::Stop ()
+    {
+        m_IsRunning = false;
+        m_Acceptor.cancel ();
+        for (auto it: m_Sessions)
+            delete it.second;
+        m_Sessions.clear ();
+        m_Service.stop ();
+        if (m_Thread)
+        {   
+            m_Thread->join (); 
+            delete m_Thread;
+            m_Thread = nullptr;
+        }   
+    }
+
+    void SAMBridge::Run () 
+    { 
+        while (m_IsRunning)
+        {
+            try
+            {   
+                m_Service.run ();
+            }
+            catch (std::exception& ex)
+            {
+                LogPrint ("SAM: ", ex.what ());
+            }   
+        }   
+    }
+
+    void SAMBridge::Accept ()
+    {
+        auto newSocket = std::make_shared<SAMSocket> (*this);
+        m_Acceptor.async_accept (newSocket->GetSocket (), std::bind (&SAMBridge::HandleAccept, this,
+            std::placeholders::_1, newSocket));
+    }
+
+    void SAMBridge::HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<SAMSocket> socket)
+    {
+        if (!ecode)
+        {
+            boost::system::error_code ec;
+            auto ep = socket->GetSocket ().remote_endpoint (ec);
+            if (!ec)
+            {   
+                LogPrint ("New SAM connection from ", ep);
+                socket->ReceiveHandshake ();
+            }
+            else
+                LogPrint (eLogError, "SAM connection from error ", ec.message ());
+        }
+        else
+            LogPrint ("SAM accept error: ",  ecode.message ());
+
+        if (ecode != boost::asio::error::operation_aborted)
+            Accept ();
+    }
+
+    SAMSession * SAMBridge::CreateSession (const std::string& id, const std::string& destination, 
+        const std::map<std::string, std::string> * params)
+    {
+        std::shared_ptr<ClientDestination> localDestination = nullptr; 
+        if (destination != "")
+        {
+            i2p::data::PrivateKeys keys;
+            keys.FromBase64 (destination);
+            localDestination = i2p::client::context.CreateNewLocalDestination (keys, true, params);
+        }
+        else // transient
+        {
+            // extract signature type
+            i2p::data::SigningKeyType signatureType = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1;
+            if (params)
+            {
+                auto it = params->find (SAM_PARAM_SIGNATURE_TYPE);
+                if (it != params->end ())
+                    // TODO: extract string values  
+                    signatureType = boost::lexical_cast<int> (it->second);
+            }
+            localDestination = i2p::client::context.CreateNewLocalDestination (true, signatureType, params); 
+        }
+        if (localDestination)
+        {
+            std::unique_lock<std::mutex> l(m_SessionsMutex);
+            auto ret = m_Sessions.insert (std::pair<std::string, SAMSession *>(id, new SAMSession (localDestination)));
+            if (!ret.second)
+                LogPrint ("Session ", id, " already exists");
+            return ret.first->second;
+        }
+        return nullptr;
+    }
+
+    void SAMBridge::CloseSession (const std::string& id)
+    {
+        std::unique_lock<std::mutex> l(m_SessionsMutex);
+        auto it = m_Sessions.find (id);
+        if (it != m_Sessions.end ())
+        {
+            auto session = it->second;
+            session->localDestination->StopAcceptingStreams ();
+            session->CloseStreams ();
+            m_Sessions.erase (it);
+            delete session;
+        }
+    }
+
+    SAMSession * SAMBridge::FindSession (const std::string& id) const
+    {
+        std::unique_lock<std::mutex> l(m_SessionsMutex);
+        auto it = m_Sessions.find (id);
+        if (it != m_Sessions.end ())
+            return it->second;
+        return nullptr;
+    }
+
+    void SAMBridge::ReceiveDatagram ()
+    {
+        m_DatagramSocket.async_receive_from (
+            boost::asio::buffer (m_DatagramReceiveBuffer, i2p::datagram::MAX_DATAGRAM_SIZE), 
+            m_SenderEndpoint,
+            std::bind (&SAMBridge::HandleReceivedDatagram, this, std::placeholders::_1, std::placeholders::_2)); 
+    }
+
+    void SAMBridge::HandleReceivedDatagram (const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if (!ecode)
+        {
+            m_DatagramReceiveBuffer[bytes_transferred] = 0;
+            char * eol = strchr ((char *)m_DatagramReceiveBuffer, '\n');
+            *eol = 0; eol++;
+            size_t payloadLen = bytes_transferred - ((uint8_t *)eol - m_DatagramReceiveBuffer); 
+            LogPrint ("SAM datagram received ", m_DatagramReceiveBuffer," size=", payloadLen);
+            char * sessionID = strchr ((char *)m_DatagramReceiveBuffer, ' ');
+            if (sessionID)
+            {
+                sessionID++;
+                char * destination = strchr (sessionID, ' ');
+                if (destination)
+                {
+                    *destination = 0; destination++;
+                    auto session = FindSession (sessionID);
+                    if (session)
+                    {   
+                        i2p::data::IdentityEx dest;
+                        dest.FromBase64 (destination);
+                        session->localDestination->GetDatagramDestination ()->
+                            SendDatagramTo ((uint8_t *)eol, payloadLen, dest.GetIdentHash ());
+                    }   
+                    else
+                        LogPrint ("Session ", sessionID, " not found");
+                }
+                else
+                    LogPrint ("Missing destination key");
+            }
+            else
+                LogPrint ("Missing sessionID");
+            ReceiveDatagram ();
+        }
+        else
+            LogPrint ("SAM datagram receive error: ", ecode.message ());
+    }
+
+    void SAMBridge::ForwardUDP(const boost::asio::ip::udp::endpoint & to_ep, const i2p::data::IdentityEx& from, const uint8_t * buff, size_t bufflen)
+    {
+
+        if (m_Forward)
+        {
+            // drop, we are already trying to send
+            LogPrint(eLogWarning, "Dropping a forwarded datagram");
+        } else {
+            auto base64 = from.ToBase64();
+            auto b64_size = base64.size();
+            std::size_t forward_len = bufflen + sizeof(char) + b64_size;
+            m_Forward = new uint8_t[forward_len];
+            // make datagram
+            memcpy(m_Forward, base64.c_str(), b64_size);
+            memset(m_Forward + b64_size, 10, 1);
+            memcpy(m_Forward + b64_size + 1, buff, bufflen);
+            // async sendto
+            m_DatagramSocket.async_send_to(
+                boost::asio::buffer(m_Forward, forward_len),
+                to_ep,
+                std::bind(&SAMBridge::HandleForwardedUDP, this, std::placeholders::_1, std::placeholders::_2));
+        }
+            
+    }
+
+    void SAMBridge::HandleForwardedUDP(const boost::system::error_code& ecode, std::size_t bytes_transferred)
+    {
+        if(!ecode)
+        {
+            LogPrint("Forwarded ", bytes_transferred, "B");
+        }
+        if(m_Forward)
+        {
+            delete [] m_Forward;
+            m_Forward = nullptr;
+        }
+    }
+    
+}
+}

client/SAM.h

@@ -0,0 +1,201 @@
+#ifndef SAM_H__
+#define SAM_H__
+
+#include <inttypes.h>
+#include <string>
+#include <map>
+#include <list>
+#include <thread>
+#include <mutex>
+#include <memory>
+#include <boost/asio.hpp>
+#include "Identity.h"
+#include "LeaseSet.h"
+#include "Streaming.h"
+#include "Destination.h"
+
+namespace i2p
+{
+namespace client
+{
+    const size_t SAM_SOCKET_BUFFER_SIZE = 8192;
+    const int SAM_SOCKET_CONNECTION_MAX_IDLE = 3600; // in seconds
+    const int SAM_SESSION_READINESS_CHECK_INTERVAL = 20; // in seconds  
+    const char SAM_HANDSHAKE[] = "HELLO VERSION";
+    const char SAM_HANDSHAKE_REPLY[] = "HELLO REPLY RESULT=OK VERSION=%s\n";
+    const char SAM_HANDSHAKE_I2P_ERROR[] = "HELLO REPLY RESULT=I2P_ERROR\n";    
+    const char SAM_SESSION_CREATE[] = "SESSION CREATE";
+    const char SAM_SESSION_CREATE_REPLY_OK[] = "SESSION STATUS RESULT=OK DESTINATION=%s\n";
+    const char SAM_SESSION_CREATE_DUPLICATED_ID[] = "SESSION STATUS RESULT=DUPLICATED_ID\n";
+    const char SAM_SESSION_CREATE_DUPLICATED_DEST[] = "SESSION STATUS RESULT=DUPLICATED_DEST\n";    
+    const char SAM_SESSION_STATUS_INVALID_KEY[] = "SESSION STATUS RESULT=INVALID_KEY\n";
+    const char SAM_STREAM_CONNECT[] = "STREAM CONNECT";
+    const char SAM_STREAM_STATUS_OK[] = "STREAM STATUS RESULT=OK\n";
+    const char SAM_STREAM_STATUS_INVALID_ID[] = "STREAM STATUS RESULT=INVALID_ID\n";
+    const char SAM_STREAM_STATUS_CANT_REACH_PEER[] = "STREAM STATUS RESULT=CANT_REACH_PEER\n";
+    const char SAM_STREAM_STATUS_I2P_ERROR[] = "STREAM STATUS RESULT=I2P_ERROR\n";
+    const char SAM_STREAM_ACCEPT[] = "STREAM ACCEPT";   
+    const char SAM_DATAGRAM_SEND[] = "DATAGRAM SEND";
+    const char SAM_DEST_GENERATE[] = "DEST GENERATE";
+    const char SAM_DEST_REPLY[] = "DEST REPLY PUB=%s PRIV=%s\n";    
+    const char SAM_DEST_REPLY_I2P_ERROR[] = "DEST REPLY RESULT=I2P_ERROR\n";
+    const char SAM_NAMING_LOOKUP[] = "NAMING LOOKUP";
+    const char SAM_NAMING_REPLY[] = "NAMING REPLY RESULT=OK NAME=ME VALUE=%s\n";
+    const char SAM_DATAGRAM_RECEIVED[] = "DATAGRAM RECEIVED DESTINATION=%s SIZE=%lu\n"; 
+    const char SAM_NAMING_REPLY_INVALID_KEY[] = "NAMING REPLY RESULT=INVALID_KEY NAME=%s\n";
+    const char SAM_NAMING_REPLY_KEY_NOT_FOUND[] = "NAMING REPLY RESULT=INVALID_KEY_NOT_FOUND NAME=%s\n";
+    const char SAM_PARAM_MIN[] = "MIN"; 
+    const char SAM_PARAM_MAX[] = "MAX";             
+    const char SAM_PARAM_STYLE[] = "STYLE";     
+    const char SAM_PARAM_ID[] = "ID";   
+    const char SAM_PARAM_SILENT[] = "SILENT";
+    const char SAM_PARAM_DESTINATION[] = "DESTINATION"; 
+    const char SAM_PARAM_NAME[] = "NAME";
+    const char SAM_PARAM_SIGNATURE_TYPE[] = "SIGNATURE_TYPE";   
+    const char SAM_PARAM_SIZE[] = "SIZE";
+    const char SAM_PARAM_FORWARD[] = "FORWARD";
+    const char SAM_PARAM_HOST[] = "HOST";
+    const char SAM_PARAM_PORT[] = "PORT";
+    const char SAM_VALUE_TRANSIENT[] = "TRANSIENT"; 
+    const char SAM_VALUE_STREAM[] = "STREAM";
+    const char SAM_VALUE_DATAGRAM[] = "DATAGRAM";
+    const char SAM_VALUE_RAW[] = "RAW";
+    const char SAM_VALUE_TRUE[] = "true";   
+    const char SAM_VALUE_FALSE[] = "false"; 
+
+    enum SAMSocketType
+    {
+        eSAMSocketTypeUnknown,
+        eSAMSocketTypeSession,
+        eSAMSocketTypeStream,
+        eSAMSocketTypeAcceptor,
+        eSAMSocketTypeUDPForward,
+        eSAMSocketTypeTerminated,
+    };
+
+    class SAMBridge;
+    struct SAMSession;
+    class SAMSocket: public std::enable_shared_from_this<SAMSocket>
+    {
+        public:
+
+            SAMSocket (SAMBridge& owner);
+            ~SAMSocket ();          
+            void CloseStream (); // TODO: implement it better   
+
+            boost::asio::ip::tcp::socket& GetSocket () { return m_Socket; };
+            void ReceiveHandshake ();
+            void SetSocketType (SAMSocketType socketType) { m_SocketType = socketType; };
+            SAMSocketType GetSocketType () const { return m_SocketType; };
+
+        private:
+
+            void Terminate ();  
+            void HandleHandshakeReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void HandleHandshakeReplySent (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void HandleMessage (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void SendMessageReply (const char * msg, size_t len, bool close);           
+            void HandleMessageReplySent (const boost::system::error_code& ecode, std::size_t bytes_transferred, bool close);
+            void Receive ();
+            void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+
+            void I2PReceive (); 
+            void HandleI2PReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void HandleI2PAccept (std::shared_ptr<i2p::stream::Stream> stream);
+            void HandleWriteI2PData (const boost::system::error_code& ecode);
+            void HandleI2PDatagramReceive (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
+
+            void ProcessSessionCreate (char * buf, size_t len);
+            void ProcessStreamConnect (char * buf, size_t len);
+            void ProcessStreamAccept (char * buf, size_t len);
+            void ProcessDestGenerate ();
+            void ProcessNamingLookup (char * buf, size_t len);
+            size_t ProcessDatagramSend (char * buf, size_t len, const char * data); // from SAM 1.0 
+            void ExtractParams (char * buf, std::map<std::string, std::string>& params);
+
+            void Connect (std::shared_ptr<const i2p::data::LeaseSet> remote);
+            void HandleConnectLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet);
+            void SendNamingLookupReply (const i2p::data::IdentityEx& identity);
+            void HandleNamingLookupLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, i2p::data::IdentHash ident);
+            void HandleSessionReadinessCheckTimer (const boost::system::error_code& ecode);
+            void SendSessionCreateReplyOk ();
+
+        private:
+
+            SAMBridge& m_Owner;
+            boost::asio::ip::udp::endpoint m_udpForward;
+            boost::asio::ip::tcp::socket m_Socket;
+            boost::asio::deadline_timer m_Timer;
+            char m_Buffer[SAM_SOCKET_BUFFER_SIZE + 1];
+            size_t m_BufferOffset;
+            uint8_t m_StreamBuffer[SAM_SOCKET_BUFFER_SIZE];
+            SAMSocketType m_SocketType;
+            std::string m_ID; // nickname
+            bool m_IsSilent;
+            std::shared_ptr<i2p::stream::Stream> m_Stream;
+            SAMSession * m_Session;
+    };  
+
+    struct SAMSession
+    {
+        std::shared_ptr<ClientDestination> localDestination;
+        std::list<std::shared_ptr<SAMSocket> > sockets;
+        
+        SAMSession (std::shared_ptr<ClientDestination> dest);       
+        ~SAMSession ();
+
+        void CloseStreams ();
+    };
+
+    class SAMBridge
+    {
+        public:
+
+            SAMBridge(const std::string& address, int port);
+            ~SAMBridge ();
+
+            void Start ();
+            void Stop ();
+            
+            boost::asio::io_service& GetService () { return m_Service; };
+            SAMSession * CreateSession (const std::string& id, const std::string& destination, // empty string  means transient
+                const std::map<std::string, std::string> * params);
+            void CloseSession (const std::string& id);
+            SAMSession * FindSession (const std::string& id) const;
+
+            // forward a datagram to a udp endpoint
+            void ForwardUDP(const boost::asio::ip::udp::endpoint & to_ep, const i2p::data::IdentityEx& from, const uint8_t * buff, size_t bufflen);
+      
+        private:
+
+            void Run ();
+
+            void Accept ();
+            void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<SAMSocket> socket);
+
+            void ReceiveDatagram ();
+            void HandleReceivedDatagram (const boost::system::error_code& ecode, std::size_t bytes_transferred);
+            void HandleForwardedUDP(const boost::system::error_code& ecode, std::size_t bytes_transferrted);
+      
+        private:
+
+            bool m_IsRunning;
+            std::thread * m_Thread; 
+            boost::asio::io_service m_Service;
+            boost::asio::ip::tcp::acceptor m_Acceptor;
+            boost::asio::ip::udp::endpoint m_DatagramEndpoint, m_SenderEndpoint;
+            boost::asio::ip::udp::socket m_DatagramSocket;
+            mutable std::mutex m_SessionsMutex;
+            std::map<std::string, SAMSession *> m_Sessions;
+            uint8_t m_DatagramReceiveBuffer[i2p::datagram::MAX_DATAGRAM_SIZE+1];
+            uint8_t * m_Forward; // current buffer to forward or nullptr if there is none to forward now
+        public:
+
+            // for HTTP
+            const decltype(m_Sessions)& GetSessions () const { return m_Sessions; };
+    };      
+}
+}
+
+#endif
+

client/SOCKS.cpp

@@ -0,0 +1,577 @@
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <atomic>
+#include "SOCKS.h"
+#include "Identity.h"
+#include "Streaming.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "util/I2PEndian.h"
+#include "I2PTunnel.h"
+
+namespace i2p
+{
+namespace proxy
+{
+    static const size_t socks_buffer_size = 8192;
+    static const size_t max_socks_hostname_size = 255; // Limit for socks5 and bad idea to traverse
+
+    struct SOCKSDnsAddress 
+    {
+        uint8_t size;
+        char value[max_socks_hostname_size];
+        void FromString (std::string str) 
+        {
+            size = str.length();
+            if (str.length() > max_socks_hostname_size) size = max_socks_hostname_size;
+            memcpy(value,str.c_str(),size);
+        }
+        std::string ToString() { return std::string(value, size); }
+        void push_back (char c) { value[size++] = c; }
+    };
+
+    class SOCKSServer;
+    class SOCKSHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this<SOCKSHandler> 
+    {
+        private:
+            enum state 
+            {
+                GET_SOCKSV,
+                GET_COMMAND,
+                GET_PORT,
+                GET_IPV4,
+                GET4_IDENT,
+                GET4A_HOST,
+                GET5_AUTHNUM,
+                GET5_AUTH,
+                GET5_REQUESTV,
+                GET5_GETRSV,
+                GET5_GETADDRTYPE,
+                GET5_IPV6,
+                GET5_HOST_SIZE,
+                GET5_HOST,
+                DONE
+            };
+            enum authMethods 
+            {
+                AUTH_NONE = 0, //No authentication, skip to next step
+                AUTH_GSSAPI = 1, //GSSAPI authentication
+                AUTH_USERPASSWD = 2, //Username and password
+                AUTH_UNACCEPTABLE = 0xff //No acceptable method found
+            };
+            enum addrTypes 
+            {
+                ADDR_IPV4 = 1, //IPv4 address (4 octets)
+                ADDR_DNS = 3, // DNS name (up to 255 octets)
+                ADDR_IPV6 = 4 //IPV6 address (16 octets)
+            };
+            enum errTypes 
+            {
+                SOCKS5_OK = 0, // No error for SOCKS5
+                SOCKS5_GEN_FAIL = 1, // General server failure
+                SOCKS5_RULE_DENIED = 2, // Connection disallowed by ruleset
+                SOCKS5_NET_UNREACH = 3, // Network unreachable
+                SOCKS5_HOST_UNREACH = 4, // Host unreachable
+                SOCKS5_CONN_REFUSED = 5, // Connection refused by the peer
+                SOCKS5_TTL_EXPIRED = 6, // TTL Expired
+                SOCKS5_CMD_UNSUP = 7, // Command unsupported
+                SOCKS5_ADDR_UNSUP = 8, // Address type unsupported
+                SOCKS4_OK = 90, // No error for SOCKS4
+                SOCKS4_FAIL = 91, // Failed establishing connecting or not allowed
+                SOCKS4_IDENTD_MISSING = 92, // Couldn't connect to the identd server
+                SOCKS4_IDENTD_DIFFER = 93 // The ID reported by the application and by identd differ
+            };
+            enum cmdTypes 
+            {
+                CMD_CONNECT = 1, // TCP Connect
+                CMD_BIND = 2, // TCP Bind
+                CMD_UDP = 3 // UDP associate
+            };
+            enum socksVersions 
+            {
+                SOCKS4 = 4, // SOCKS4
+                SOCKS5 = 5 // SOCKS5
+            };
+            union address 
+            {
+                uint32_t ip;
+                SOCKSDnsAddress dns;
+                uint8_t ipv6[16];
+            };
+
+            void EnterState(state nstate, uint8_t parseleft = 1);
+            bool HandleData(uint8_t *sock_buff, std::size_t len);
+            bool ValidateSOCKSRequest();
+            void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+            void Terminate();
+            void AsyncSockRead();
+            boost::asio::const_buffers_1 GenerateSOCKS5SelectAuth(authMethods method);
+            boost::asio::const_buffers_1 GenerateSOCKS4Response(errTypes error, uint32_t ip, uint16_t port);
+            boost::asio::const_buffers_1 GenerateSOCKS5Response(errTypes error, addrTypes type, const address &addr, uint16_t port);
+            bool Socks5ChooseAuth();
+            void SocksRequestFailed(errTypes error);
+            void SocksRequestSuccess();
+            void SentSocksFailed(const boost::system::error_code & ecode);
+            void SentSocksDone(const boost::system::error_code & ecode);
+            void SentSocksResponse(const boost::system::error_code & ecode);
+            void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
+
+            uint8_t m_sock_buff[socks_buffer_size];
+            std::shared_ptr<boost::asio::ip::tcp::socket> m_sock;
+            std::shared_ptr<i2p::stream::Stream> m_stream;
+            uint8_t *m_remaining_data; //Data left to be sent
+            uint8_t m_response[7+max_socks_hostname_size];
+            address m_address; //Address
+            std::size_t m_remaining_data_len; //Size of the data left to be sent
+            uint32_t m_4aip; //Used in 4a requests
+            uint16_t m_port;
+            uint8_t m_command;
+            uint8_t m_parseleft; //Octets left to parse
+            authMethods m_authchosen; //Authentication chosen
+            addrTypes m_addrtype; //Address type chosen
+            socksVersions m_socksv; //Socks version
+            cmdTypes m_cmd; // Command requested
+            state m_state;
+
+        public:
+            SOCKSHandler(SOCKSServer * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock) :
+                I2PServiceHandler(parent), m_sock(sock), m_stream(nullptr),
+                m_authchosen(AUTH_UNACCEPTABLE), m_addrtype(ADDR_IPV4)
+                { m_address.ip = 0; EnterState(GET_SOCKSV); }
+            ~SOCKSHandler() { Terminate(); }
+            void Handle() { AsyncSockRead(); }
+    };
+
+    void SOCKSHandler::AsyncSockRead()
+    {
+        LogPrint(eLogDebug,"--- SOCKS async sock read");
+        if(m_sock)
+            m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
+                        std::bind(&SOCKSHandler::HandleSockRecv, shared_from_this(),
+                                std::placeholders::_1, std::placeholders::_2));
+        else 
+            LogPrint(eLogError,"--- SOCKS no socket for read");
+    }
+
+    void SOCKSHandler::Terminate() 
+    {
+        if (Kill()) return;
+        if (m_sock) 
+        {
+            LogPrint(eLogDebug,"--- SOCKS close sock");
+            m_sock->close();
+            m_sock = nullptr;
+        }
+        if (m_stream) 
+        {
+            LogPrint(eLogDebug,"--- SOCKS close stream");
+            m_stream.reset ();
+        }
+        Done(shared_from_this());
+    }
+
+    boost::asio::const_buffers_1 SOCKSHandler::GenerateSOCKS4Response(SOCKSHandler::errTypes error, uint32_t ip, uint16_t port)
+    {
+        assert(error >= SOCKS4_OK);
+        m_response[0] = '\x00'; //Version
+        m_response[1] = error; //Response code
+        htobe16buf(m_response+2,port); //Port
+        htobe32buf(m_response+4,ip); //IP
+        return boost::asio::const_buffers_1(m_response,8);
+    }
+
+    boost::asio::const_buffers_1 SOCKSHandler::GenerateSOCKS5Response(SOCKSHandler::errTypes error, SOCKSHandler::addrTypes type, const SOCKSHandler::address &addr, uint16_t port)
+    {
+        size_t size = 6;
+        assert(error <= SOCKS5_ADDR_UNSUP);
+        m_response[0] = '\x05'; //Version
+        m_response[1] = error; //Response code
+        m_response[2] = '\x00'; //RSV
+        m_response[3] = type; //Address type
+        switch (type) 
+        {
+            case ADDR_IPV4:
+                size = 10;
+                htobe32buf(m_response+4,addr.ip);
+                break;
+            case ADDR_IPV6:
+                size = 22;
+                memcpy(m_response+4,addr.ipv6, 16);
+                break;
+            case ADDR_DNS:
+                size = 7+addr.dns.size;
+                m_response[4] = addr.dns.size;
+                memcpy(m_response+5,addr.dns.value, addr.dns.size);
+                break;
+        }
+        htobe16buf(m_response+size-2,port); //Port
+        return boost::asio::const_buffers_1(m_response,size);
+    }
+
+    bool SOCKSHandler::Socks5ChooseAuth()
+    {
+        m_response[0] = '\x05'; //Version
+        m_response[1] = m_authchosen; //Response code
+        boost::asio::const_buffers_1 response(m_response,2);
+        if (m_authchosen == AUTH_UNACCEPTABLE) 
+        {
+            LogPrint(eLogWarning,"--- SOCKS5 authentication negotiation failed");
+            boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksFailed,
+                                          shared_from_this(), std::placeholders::_1));
+            return false;
+        } 
+        else 
+        {
+            LogPrint(eLogDebug,"--- SOCKS5 choosing authentication method: ", m_authchosen);
+            boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksResponse,
+                                          shared_from_this(), std::placeholders::_1));
+            return true;
+        }
+    }
+
+    /* All hope is lost beyond this point */
+    void SOCKSHandler::SocksRequestFailed(SOCKSHandler::errTypes error)
+    {
+        boost::asio::const_buffers_1 response(nullptr,0);
+        assert(error != SOCKS4_OK && error != SOCKS5_OK);
+        switch (m_socksv) 
+        {
+            case SOCKS4:
+                LogPrint(eLogWarning,"--- SOCKS4 failed: ", error);
+                if (error < SOCKS4_OK) error = SOCKS4_FAIL; //Transparently map SOCKS5 errors
+                response = GenerateSOCKS4Response(error, m_4aip, m_port);
+            break;
+            case SOCKS5:
+                LogPrint(eLogWarning,"--- SOCKS5 failed: ", error);
+                response = GenerateSOCKS5Response(error, m_addrtype, m_address, m_port);
+            break;
+        }
+        boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksFailed,
+                                      shared_from_this(), std::placeholders::_1));
+    }
+
+    void SOCKSHandler::SocksRequestSuccess()
+    {
+        boost::asio::const_buffers_1 response(nullptr,0);
+        //TODO: this should depend on things like the command type and callbacks may change
+        switch (m_socksv) 
+        {
+            case SOCKS4:
+                LogPrint(eLogInfo,"--- SOCKS4 connection success");
+                response = GenerateSOCKS4Response(SOCKS4_OK, m_4aip, m_port);
+            break;
+            case SOCKS5:
+                LogPrint(eLogInfo,"--- SOCKS5 connection success");
+                auto s = i2p::client::context.GetAddressBook().ToAddress(GetOwner()->GetLocalDestination()->GetIdentHash());
+                address ad; ad.dns.FromString(s);
+                //HACK only 16 bits passed in port as SOCKS5 doesn't allow for more
+                response = GenerateSOCKS5Response(SOCKS5_OK, ADDR_DNS, ad, m_stream->GetRecvStreamID());
+            break;
+        }
+        boost::asio::async_write(*m_sock, response, std::bind(&SOCKSHandler::SentSocksDone,
+                                      shared_from_this(), std::placeholders::_1));
+    }
+
+    void SOCKSHandler::EnterState(SOCKSHandler::state nstate, uint8_t parseleft) {
+        switch (nstate) 
+        {
+            case GET_PORT: parseleft = 2; break;
+            case GET_IPV4: m_addrtype = ADDR_IPV4; m_address.ip = 0; parseleft = 4; break;
+            case GET4_IDENT: m_4aip = m_address.ip; break;
+            case GET4A_HOST:
+            case GET5_HOST: m_addrtype = ADDR_DNS; m_address.dns.size = 0; break;
+            case GET5_IPV6: m_addrtype = ADDR_IPV6; parseleft = 16; break;
+            default:;
+        }
+        m_parseleft = parseleft;
+        m_state = nstate;
+    }
+
+    bool SOCKSHandler::ValidateSOCKSRequest() 
+    {
+        if ( m_cmd != CMD_CONNECT ) 
+        {
+            //TODO: we need to support binds and other shit!
+            LogPrint(eLogError,"--- SOCKS unsupported command: ", m_cmd);
+            SocksRequestFailed(SOCKS5_CMD_UNSUP);
+            return false;
+        }
+        //TODO: we may want to support other address types!
+        if ( m_addrtype != ADDR_DNS ) 
+        {
+            switch (m_socksv) 
+            {
+                case SOCKS5:
+                    LogPrint(eLogError,"--- SOCKS5 unsupported address type: ", m_addrtype);
+                break;
+                case SOCKS4:
+                    LogPrint(eLogError,"--- SOCKS4a rejected because it's actually SOCKS4");
+                break;
+            }
+            SocksRequestFailed(SOCKS5_ADDR_UNSUP);
+            return false;
+        }
+        //TODO: we may want to support other domains
+        if(m_addrtype == ADDR_DNS && m_address.dns.ToString().find(".i2p") == std::string::npos) 
+        {
+            LogPrint(eLogError,"--- SOCKS invalid hostname: ", m_address.dns.ToString());
+            SocksRequestFailed(SOCKS5_ADDR_UNSUP);
+            return false;
+        }
+        return true;
+    }
+
+    bool SOCKSHandler::HandleData(uint8_t *sock_buff, std::size_t len)
+    {
+        assert(len); // This should always be called with a least a byte left to parse
+        while (len > 0) 
+        {
+            switch (m_state) 
+            {
+                case GET_SOCKSV:
+                    m_socksv = (SOCKSHandler::socksVersions) *sock_buff;
+                    switch (*sock_buff) 
+                    {
+                        case SOCKS4:
+                            EnterState(GET_COMMAND); //Initialize the parser at the right position
+                        break;
+                        case SOCKS5:
+                            EnterState(GET5_AUTHNUM); //Initialize the parser at the right position
+                        break;
+                        default:
+                            LogPrint(eLogError,"--- SOCKS rejected invalid version: ", ((int)*sock_buff));
+                            Terminate();
+                            return false;
+                    }
+                break;
+                case GET5_AUTHNUM:
+                    EnterState(GET5_AUTH, *sock_buff);
+                break;
+                case GET5_AUTH:
+                    m_parseleft --;
+                    if (*sock_buff == AUTH_NONE)
+                        m_authchosen = AUTH_NONE;
+                    if ( m_parseleft == 0 ) 
+                    {
+                        if (!Socks5ChooseAuth()) return false;
+                        EnterState(GET5_REQUESTV);
+                    }
+                break;
+                case GET_COMMAND:
+                    switch (*sock_buff) 
+                    {
+                        case CMD_CONNECT:
+                        case CMD_BIND:
+                        break;
+                        case CMD_UDP:
+                            if (m_socksv == SOCKS5) break;
+                        default:
+                            LogPrint(eLogError,"--- SOCKS invalid command: ", ((int)*sock_buff));
+                            SocksRequestFailed(SOCKS5_GEN_FAIL);
+                            return false;
+                    }
+                    m_cmd = (SOCKSHandler::cmdTypes)*sock_buff;
+                    switch (m_socksv) 
+                    {
+                        case SOCKS5: EnterState(GET5_GETRSV); break;
+                        case SOCKS4: EnterState(GET_PORT); break;
+                    }
+                break;
+                case GET_PORT:
+                    m_port = (m_port << 8)|((uint16_t)*sock_buff);
+                    m_parseleft--;
+                    if (m_parseleft == 0) 
+                    {
+                        switch (m_socksv) 
+                        {
+                            case SOCKS5: EnterState(DONE); break;
+                            case SOCKS4: EnterState(GET_IPV4); break;
+                        }
+                    }
+                break;
+                case GET_IPV4:
+                    m_address.ip = (m_address.ip << 8)|((uint32_t)*sock_buff);
+                    m_parseleft--;
+                    if (m_parseleft == 0) 
+                    {
+                        switch (m_socksv) 
+                        {
+                            case SOCKS5: EnterState(GET_PORT); break;
+                            case SOCKS4: EnterState(GET4_IDENT); m_4aip = m_address.ip; break;
+                        }
+                    }
+                break;
+                case GET4_IDENT:
+                    if (!*sock_buff) 
+                    {
+                        if( m_4aip == 0 || m_4aip > 255 )
+                            EnterState(DONE);
+                        else
+                            EnterState(GET4A_HOST);
+                    }
+                break;
+                case GET4A_HOST:
+                    if (!*sock_buff) 
+                    {
+                        EnterState(DONE);
+                        break;
+                    }
+                    if (m_address.dns.size >= max_socks_hostname_size) 
+                    {
+                        LogPrint(eLogError,"--- SOCKS4a destination is too large");
+                        SocksRequestFailed(SOCKS4_FAIL);
+                        return false;
+                    }
+                    m_address.dns.push_back(*sock_buff);
+                break;
+                case GET5_REQUESTV:
+                    if (*sock_buff != SOCKS5) 
+                    {
+                        LogPrint(eLogError,"--- SOCKS5 rejected unknown request version: ", ((int)*sock_buff));
+                        SocksRequestFailed(SOCKS5_GEN_FAIL);
+                        return false;
+                    }
+                    EnterState(GET_COMMAND);
+                break;
+                case GET5_GETRSV:
+                    if ( *sock_buff != 0 ) 
+                    {
+                        LogPrint(eLogError,"--- SOCKS5 unknown reserved field: ", ((int)*sock_buff));
+                        SocksRequestFailed(SOCKS5_GEN_FAIL);
+                        return false;
+                    }
+                    EnterState(GET5_GETADDRTYPE);
+                break;
+                case GET5_GETADDRTYPE:
+                    switch (*sock_buff) 
+                    {
+                        case ADDR_IPV4: EnterState(GET_IPV4); break;
+                        case ADDR_IPV6: EnterState(GET5_IPV6); break;
+                        case ADDR_DNS : EnterState(GET5_HOST_SIZE); break;
+                        default:
+                            LogPrint(eLogError,"--- SOCKS5 unknown address type: ", ((int)*sock_buff));
+                            SocksRequestFailed(SOCKS5_GEN_FAIL);
+                            return false;
+                    }
+                break;
+                case GET5_IPV6:
+                    m_address.ipv6[16-m_parseleft] = *sock_buff;
+                    m_parseleft--;
+                    if (m_parseleft == 0) EnterState(GET_PORT);
+                break;
+                case GET5_HOST_SIZE:
+                    EnterState(GET5_HOST, *sock_buff);
+                break;
+                case GET5_HOST:
+                    m_address.dns.push_back(*sock_buff);
+                    m_parseleft--;
+                    if (m_parseleft == 0) EnterState(GET_PORT);
+                break;
+                default:
+                    LogPrint(eLogError,"--- SOCKS parse state?? ", m_state);
+                    Terminate();
+                    return false;
+            }
+            sock_buff++;
+            len--;
+            if (m_state == DONE) 
+            {
+                m_remaining_data_len = len;
+                m_remaining_data = sock_buff;
+                return ValidateSOCKSRequest();
+            }
+        }
+        return true;
+    }
+
+    void SOCKSHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
+    {
+        LogPrint(eLogDebug,"--- SOCKS sock recv: ", len);
+        if(ecode) 
+        {
+            LogPrint(eLogWarning," --- SOCKS sock recv got error: ", ecode);
+            Terminate();
+            return;
+        }
+
+        if (HandleData(m_sock_buff, len)) 
+        {
+            if (m_state == DONE) 
+            {
+                LogPrint(eLogInfo,"--- SOCKS requested ", m_address.dns.ToString(), ":" , m_port);
+                GetOwner()->CreateStream ( std::bind (&SOCKSHandler::HandleStreamRequestComplete,
+                        shared_from_this(), std::placeholders::_1), m_address.dns.ToString(), m_port);
+            } 
+            else
+                AsyncSockRead();
+        }
+    }
+
+    void SOCKSHandler::SentSocksFailed(const boost::system::error_code & ecode)
+    {
+        if (!ecode) 
+            Terminate();
+        else 
+        {
+            LogPrint (eLogError,"--- SOCKS Closing socket after sending failure because: ", ecode.message ());
+            Terminate();
+        }
+    }
+
+    void SOCKSHandler::SentSocksDone(const boost::system::error_code & ecode)
+    {
+        if (!ecode) 
+        {
+            if (Kill()) return;
+            LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
+            auto connection = std::make_shared<i2p::client::I2PTunnelConnection>(GetOwner(), m_sock, m_stream);
+            GetOwner()->AddHandler (connection);
+            connection->I2PConnect (m_remaining_data,m_remaining_data_len);
+            Done(shared_from_this());
+        }
+        else
+        {
+            LogPrint (eLogError,"--- SOCKS Closing socket after completion reply because: ", ecode.message ());
+            Terminate();
+        }
+    }
+
+    void SOCKSHandler::SentSocksResponse(const boost::system::error_code & ecode)
+    {
+        if (ecode) 
+        {
+            LogPrint (eLogError,"--- SOCKS Closing socket after sending reply because: ", ecode.message ());
+            Terminate();
+        }
+    }
+
+    void SOCKSHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+        if (stream) 
+        {
+            m_stream = stream;
+            SocksRequestSuccess();
+        } 
+        else 
+        {
+            LogPrint (eLogError,"--- SOCKS Issue when creating the stream, check the previous warnings for more info.");
+            SocksRequestFailed(SOCKS5_HOST_UNREACH);
+        }
+    }
+
+    SOCKSServer::SOCKSServer(const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination)
+        : TCPIPAcceptor(
+            address, port,
+            localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination()
+        ) 
+    {
+    }
+    
+    std::shared_ptr<i2p::client::I2PServiceHandler> SOCKSServer::CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+    {
+        return std::make_shared<SOCKSHandler> (this, socket);
+    }
+
+}
+}

client/SOCKS.h

@@ -0,0 +1,33 @@
+#ifndef SOCKS_H__
+#define SOCKS_H__
+
+#include <memory>
+#include <set>
+#include <boost/asio.hpp>
+#include <mutex>
+#include "I2PService.h"
+
+namespace i2p
+{
+namespace proxy
+{
+    class SOCKSServer: public i2p::client::TCPIPAcceptor
+    {
+        public:
+
+            SOCKSServer(const std::string& address, int port,
+                std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
+            ~SOCKSServer() {};
+
+        protected:
+            // Implements TCPIPAcceptor
+            std::shared_ptr<i2p::client::I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+            const char* GetName() { return "SOCKS"; }
+    };
+
+    typedef SOCKSServer SOCKSProxy;
+}
+}
+
+
+#endif

client/Win32Service.cpp

@@ -8,13 +8,14 @@
 #include <windows.h>
 
 #include "Daemon.h"
-#include "Log.h"
+#include "util/Log.h"
 
 I2PService *I2PService::s_service = NULL;
 
 BOOL I2PService::isService()
 {
 	BOOL bIsService = FALSE;
+
 	HWINSTA hWinStation = GetProcessWindowStation();
 	if (hWinStation != NULL)
 	{
@@ -30,23 +31,28 @@ BOOL I2PService::isService()
 BOOL I2PService::Run(I2PService &service)
 {
 	s_service = &service;
+
 	SERVICE_TABLE_ENTRY serviceTable[] =
 	{
 		{ service.m_name, ServiceMain },
 		{ NULL, NULL }
 	};
+
 	return StartServiceCtrlDispatcher(serviceTable);
 }
 
+
 void WINAPI I2PService::ServiceMain(DWORD dwArgc, PSTR *pszArgv)
 {
 	assert(s_service != NULL);
+
 	s_service->m_statusHandle = RegisterServiceCtrlHandler(
 		s_service->m_name, ServiceCtrlHandler);
 	if (s_service->m_statusHandle == NULL)
 	{
 		throw GetLastError();
 	}
+
 	s_service->Start(dwArgc, pszArgv);
 }
 
@@ -55,23 +61,27 @@ void WINAPI I2PService::ServiceCtrlHandler(DWORD dwCtrl)
 {
 	switch (dwCtrl)
 	{
-		case SERVICE_CONTROL_STOP: s_service->Stop(); break;
-		case SERVICE_CONTROL_PAUSE: s_service->Pause(); break;
-		case SERVICE_CONTROL_CONTINUE: s_service->Continue(); break;
-		case SERVICE_CONTROL_SHUTDOWN: s_service->Shutdown(); break;
-		case SERVICE_CONTROL_INTERROGATE: break;
-		default: break;
+	case SERVICE_CONTROL_STOP: s_service->Stop(); break;
+	case SERVICE_CONTROL_PAUSE: s_service->Pause(); break;
+	case SERVICE_CONTROL_CONTINUE: s_service->Continue(); break;
+	case SERVICE_CONTROL_SHUTDOWN: s_service->Shutdown(); break;
+	case SERVICE_CONTROL_INTERROGATE: break;
+	default: break;
 	}
 }
 
+
 I2PService::I2PService(PSTR pszServiceName,
 	BOOL fCanStop,
 	BOOL fCanShutdown,
 	BOOL fCanPauseContinue)
 {
-	m_name = (pszServiceName == NULL) ? (PSTR)"" : pszServiceName;
+	m_name = (pszServiceName == NULL) ? "" : pszServiceName;
+
 	m_statusHandle = NULL;
+
 	m_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+
 	m_status.dwCurrentState = SERVICE_START_PENDING;
 
 	DWORD dwControlsAccepted = 0;
@@ -81,14 +91,16 @@ I2PService::I2PService(PSTR pszServiceName,
 		dwControlsAccepted |= SERVICE_ACCEPT_SHUTDOWN;
 	if (fCanPauseContinue)
 		dwControlsAccepted |= SERVICE_ACCEPT_PAUSE_CONTINUE;
-
 	m_status.dwControlsAccepted = dwControlsAccepted;
+
 	m_status.dwWin32ExitCode = NO_ERROR;
 	m_status.dwServiceSpecificExitCode = 0;
 	m_status.dwCheckPoint = 0;
 	m_status.dwWaitHint = 0;
+
 	m_fStopping = FALSE;
-	// Create a manual-reset event that is not signaled at first to indicate
+
+	// Create a manual-reset event that is not signaled at first to indicate 
 	// the stopped signal of the service.
 	m_hStoppedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 	if (m_hStoppedEvent == NULL)
@@ -97,6 +109,7 @@ I2PService::I2PService(PSTR pszServiceName,
 	}
 }
 
+
 I2PService::~I2PService(void)
 {
 	if (m_hStoppedEvent)
@@ -106,73 +119,93 @@ I2PService::~I2PService(void)
 	}
 }
 
+
 void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
 {
 	try
 	{
 		SetServiceStatus(SERVICE_START_PENDING);
+
 		OnStart(dwArgc, pszArgv);
+
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint(eLogError, "Win32Service Start", dwError);
+		LogPrint("Win32Service Start", dwError);
+
 		SetServiceStatus(SERVICE_STOPPED, dwError);
 	}
 	catch (...)
 	{
-		LogPrint(eLogError, "Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
+		LogPrint("Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
+
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 }
 
+
 void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
 {
-	LogPrint(eLogInfo, "Win32Service in OnStart", EVENTLOG_INFORMATION_TYPE);
+	LogPrint("Win32Service in OnStart",
+		EVENTLOG_INFORMATION_TYPE);
+
 	Daemon.start();
+
 	//i2p::util::config::OptionParser(dwArgc, pszArgv);
 	//i2p::util::filesystem::ReadConfigFile(i2p::util::config::mapArgs, i2p::util::config::mapMultiArgs);
 	//i2p::context.OverrideNTCPAddress(i2p::util::config::GetCharArg("-host", "127.0.0.1"),
 	//	i2p::util::config::GetArg("-port", 17070));
+
 	_worker = new std::thread(std::bind(&I2PService::WorkerThread, this));
 }
 
+
 void I2PService::WorkerThread()
 {
 	while (!m_fStopping)
 	{
-		::Sleep(1000); // Simulate some lengthy operations.
+		::Sleep(1000);  // Simulate some lengthy operations.
 	}
+
 	// Signal the stopped event.
 	SetEvent(m_hStoppedEvent);
 }
 
+
 void I2PService::Stop()
 {
 	DWORD dwOriginalState = m_status.dwCurrentState;
 	try
 	{
 		SetServiceStatus(SERVICE_STOP_PENDING);
+
 		OnStop();
+
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint(eLogInfo, "Win32Service Stop", dwError);
+		LogPrint("Win32Service Stop", dwError);
+
 		SetServiceStatus(dwOriginalState);
 	}
 	catch (...)
 	{
-		LogPrint(eLogError, "Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
+		LogPrint("Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
+
 		SetServiceStatus(dwOriginalState);
 	}
 }
 
+
 void I2PService::OnStop()
 {
 	// Log a service stop message to the Application log.
-	LogPrint(eLogInfo, "Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
+	LogPrint("Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
+
 	Daemon.stop();
+
 	m_fStopping = TRUE;
 	if (WaitForSingleObject(m_hStoppedEvent, INFINITE) != WAIT_OBJECT_0)
 	{
@@ -182,83 +215,102 @@ void I2PService::OnStop()
 	delete _worker;
 }
 
+
 void I2PService::Pause()
 {
 	try
 	{
 		SetServiceStatus(SERVICE_PAUSE_PENDING);
+
 		OnPause();
+
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint(eLogError, "Win32Service Pause", dwError);
+		LogPrint("Win32Service Pause", dwError);
+
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (...)
 	{
-		LogPrint(eLogError, "Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
+		LogPrint("Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
+
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 }
 
+
 void I2PService::OnPause()
 {
 }
 
+
 void I2PService::Continue()
 {
 	try
 	{
 		SetServiceStatus(SERVICE_CONTINUE_PENDING);
+
 		OnContinue();
+
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint(eLogError, "Win32Service Continue", dwError);
+		LogPrint("Win32Service Continue", dwError);
+
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 	catch (...)
 	{
-		LogPrint(eLogError, "Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
+		LogPrint("Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
+
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 }
 
+
 void I2PService::OnContinue()
 {
 }
 
+
 void I2PService::Shutdown()
 {
 	try
 	{
 		OnShutdown();
+
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint(eLogError, "Win32Service Shutdown", dwError);
+		LogPrint("Win32Service Shutdown", dwError);
 	}
 	catch (...)
 	{
-		LogPrint(eLogError, "Win32Service failed to shut down.", EVENTLOG_ERROR_TYPE);
+		LogPrint("Win32Service failed to shut down.", EVENTLOG_ERROR_TYPE);
 	}
 }
 
+
 void I2PService::OnShutdown()
 {
 }
 
+
 void I2PService::SetServiceStatus(DWORD dwCurrentState,
 	DWORD dwWin32ExitCode,
 	DWORD dwWaitHint)
 {
 	static DWORD dwCheckPoint = 1;
+
+
 	m_status.dwCurrentState = dwCurrentState;
 	m_status.dwWin32ExitCode = dwWin32ExitCode;
 	m_status.dwWaitHint = dwWaitHint;
+
 	m_status.dwCheckPoint =
 		((dwCurrentState == SERVICE_RUNNING) ||
 		(dwCurrentState == SERVICE_STOPPED)) ?
@@ -283,7 +335,12 @@ void FreeHandles(SC_HANDLE schSCManager, SC_HANDLE schService)
 	}
 }
 
-void InstallService(PCSTR pszServiceName, PCSTR pszDisplayName, DWORD dwStartType, PCSTR pszDependencies, PCSTR pszAccount, PCSTR pszPassword)
+void InstallService(PSTR pszServiceName,
+	PSTR pszDisplayName,
+	DWORD dwStartType,
+	PSTR pszDependencies,
+	PSTR pszAccount,
+	PSTR pszPassword)
 {
 	printf("Try to install Win32Service (%s).\n", pszServiceName);
 
@@ -297,10 +354,10 @@ void InstallService(PCSTR pszServiceName, PCSTR pszDisplayName, DWORD dwStartTyp
 		FreeHandles(schSCManager, schService);
 		return;
 	}
-	strncat(szPath, " --daemon", MAX_PATH);
 
 	// Open the local default service control manager database
-	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE);
+	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT |
+		SC_MANAGER_CREATE_SERVICE);
 	if (schSCManager == NULL)
 	{
 		printf("OpenSCManager failed w/err 0x%08lx\n", GetLastError());
@@ -324,7 +381,6 @@ void InstallService(PCSTR pszServiceName, PCSTR pszDisplayName, DWORD dwStartTyp
 		pszAccount,                     // Service running account
 		pszPassword                     // Password of the account
 		);
-
 	if (schService == NULL)
 	{
 		printf("CreateService failed w/err 0x%08lx\n", GetLastError());
@@ -338,7 +394,7 @@ void InstallService(PCSTR pszServiceName, PCSTR pszDisplayName, DWORD dwStartTyp
 	FreeHandles(schSCManager, schService);
 }
 
-void UninstallService(PCSTR pszServiceName)
+void UninstallService(PSTR pszServiceName)
 {
 	printf("Try to uninstall Win32Service (%s).\n", pszServiceName);
 
@@ -356,7 +412,8 @@ void UninstallService(PCSTR pszServiceName)
 	}
 
 	// Open the service with delete, stop, and query status permissions
-	schService = OpenService(schSCManager, pszServiceName, SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE);
+	schService = OpenService(schSCManager, pszServiceName, SERVICE_STOP |
+		SERVICE_QUERY_STATUS | DELETE);
 	if (schService == NULL)
 	{
 		printf("OpenService failed w/err 0x%08lx\n", GetLastError());

client/Win32Service.h

@@ -2,14 +2,16 @@
 #define WIN_32_SERVICE_H__
 
 #include <thread>
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+
 #ifdef _WIN32
 // Internal name of the service
-#define SERVICE_NAME             "i2pdService"
+#define SERVICE_NAME             "i2pService"
 
 // Displayed name of the service
-#define SERVICE_DISPLAY_NAME     "i2pd router service"
+#define SERVICE_DISPLAY_NAME     "i2p router service"
 
 // Service start options.
 #define SERVICE_START_TYPE       SERVICE_DEMAND_START
@@ -24,6 +26,7 @@
 #define SERVICE_PASSWORD         NULL
 #endif
 
+
 class I2PService
 {
 public:
@@ -70,15 +73,13 @@ private:
 	std::thread* _worker;
 };
 
-void InstallService(
-	PCSTR pszServiceName,
-	PCSTR pszDisplayName,
+void InstallService(PSTR pszServiceName,
+	PSTR pszDisplayName,
 	DWORD dwStartType,
-	PCSTR pszDependencies,
-	PCSTR pszAccount,
-	PCSTR pszPassword
-	);
+	PSTR pszDependencies,
+	PSTR pszAccount,
+	PSTR pszPassword);
 
-void UninstallService(PCSTR pszServiceName);
+void UninstallService(PSTR pszServiceName);
 
 #endif // WIN_32_SERVICE_H__

client/i2p.cpp

@@ -0,0 +1,19 @@
+#include <thread>
+#include <stdlib.h>
+#include "Daemon.h"
+#include "Reseed.h"
+
+int main(int argc, char* argv[])
+{
+    if(!Daemon.init(argc, argv))
+        return EXIT_FAILURE;
+
+    if(Daemon.start()) {
+        while (Daemon.running) {
+            //TODO Meeh: Find something better to do here.
+            std::this_thread::sleep_for (std::chrono::seconds(1));
+        }
+    }
+    Daemon.stop();
+    return EXIT_SUCCESS;
+}

client/i2pcontrol/I2PControl.cpp

@@ -0,0 +1,536 @@
+// There is bug in boost 1.49 with gcc 4.7 coming with Debian Wheezy
+// #define GCC47_BOOST149 ((BOOST_VERSION == 104900) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 7))
+// TODO: handle this somewhere, but definitely not here
+
+#include "I2PControl.h"
+#include <iomanip>
+#include <sstream>
+
+#include <cryptopp/osrng.h>
+#include <cryptopp/hex.h>
+#include <cryptopp/filters.h>
+
+#include <boost/property_tree/json_parser.hpp>
+#include "util/util.h"
+#include "util/Log.h"
+#include "util/Timestamp.h"
+#include "transport/Transports.h"
+#include "tunnel/Tunnel.h"
+#include "NetworkDatabase.h"
+#include "version.h"
+#include "Daemon.h"
+
+namespace i2p {
+namespace client {
+namespace i2pcontrol {
+
+JsonObject::JsonObject(const std::string& value)
+    : children(), value("\"" + value + "\"")
+{
+
+}
+
+JsonObject::JsonObject(int value)
+    : children(), value(std::to_string(value))
+{
+
+}
+
+JsonObject::JsonObject(double v)
+    : children(), value()
+{
+    std::ostringstream oss;
+    oss << std::fixed << std::setprecision(2) << v;
+    value = oss.str();
+}
+
+JsonObject& JsonObject::operator[](const std::string& key)
+{
+    return children[key];
+}
+
+std::string JsonObject::toString() const
+{
+    if(children.empty())
+        return value;
+
+    std::ostringstream oss;
+    oss << '{';
+    for(auto it = children.begin(); it != children.end(); ++it) {
+        if(it != children.begin())
+            oss << ',';
+        oss << '"' << it->first << "\":" << it->second.toString();
+    }
+    oss << '}';
+    return oss.str();
+}
+
+JsonObject tunnelToJsonObject(i2p::tunnel::Tunnel* tunnel)
+{
+    JsonObject obj;
+
+    std::stringstream ss;
+    tunnel->GetTunnelConfig()->Print(ss); // TODO: use a JsonObject
+    obj["layout"] = JsonObject(ss.str());
+
+    const auto state = tunnel->GetState(); 
+    if(state == i2p::tunnel::eTunnelStateFailed)
+       obj["state"] = JsonObject("failed");
+    else if(state == i2p::tunnel::eTunnelStateExpiring)
+       obj["state"] = JsonObject("expiring");
+
+    return obj;
+}
+
+I2PControlSession::Response::Response(const std::string& version)
+    : id(), version(version), error(ErrorCode::None), parameters()
+{
+
+}
+
+std::string I2PControlSession::Response::toJsonString() const
+{
+    std::ostringstream oss;
+    oss << "{\"id\":" << id << ",\"result\":{";                  
+    for(auto it = parameters.begin(); it != parameters.end(); ++it) {
+        if(it != parameters.begin())
+            oss << ',';
+        oss << '"' << it->first << "\":" << it->second;
+    }
+    oss << "},\"jsonrpc\":\"" << version << '"';
+    if(error != ErrorCode::None)
+        oss << ",\"error\":{\"code\":" << -static_cast<int>(error)
+            << ",\"message\":\"" << getErrorMsg() << "\"" << "}";
+    oss << "}";
+    return oss.str();
+}
+
+std::string I2PControlSession::Response::getErrorMsg() const
+{
+    switch(error) {
+        case ErrorCode::MethodNotFound:
+            return "Method not found.";
+        case ErrorCode::InvalidParameters:
+            return "Invalid parameters.";
+        case ErrorCode::InvalidRequest:
+            return "Invalid request.";
+        case ErrorCode::ParseError:
+            return "Json parse error.";
+        case ErrorCode::InvalidPassword:
+            return "Invalid password.";
+        case ErrorCode::NoToken:
+            return "No authentication token given.";
+        case ErrorCode::NonexistentToken:
+            return "Nonexistent authentication token given.";
+        case ErrorCode::ExpiredToken:
+            return "Expired authentication token given.";
+        case ErrorCode::UnspecifiedVersion:
+            return "Version not specified.";
+        case ErrorCode::UnsupportedVersion:
+            return "Version not supported.";
+        default:
+            return "";
+    };
+}
+
+void I2PControlSession::Response::setParam(const std::string& param, const std::string& value)
+{
+    parameters[param] = value.empty() ? "null" : "\"" + value + "\"";
+}
+
+void I2PControlSession::Response::setParam(const std::string& param, int value)
+{
+    parameters[param] = std::to_string(value);  
+}
+
+void I2PControlSession::Response::setParam(const std::string& param, double value)
+{
+    std::ostringstream oss;
+    oss << std::fixed << std::setprecision(2) << value;
+    parameters[param] = oss.str();
+}
+
+void I2PControlSession::Response::setParam(const std::string& param, const JsonObject& value)
+{
+    parameters[param] = value.toString();
+}
+
+void I2PControlSession::Response::setError(ErrorCode code)
+{
+    error = code;
+}
+
+void I2PControlSession::Response::setId(const std::string& identifier)
+{
+    id = identifier;
+}
+
+I2PControlSession::I2PControlSession(boost::asio::io_service& ios, const std::string& pass)
+    : password(pass), tokens(), tokensMutex(),
+      service(ios), shutdownTimer(ios), expireTokensTimer(ios)
+{
+    using namespace i2p::client::i2pcontrol::constants;
+    // Method handlers
+    methodHandlers[METHOD_AUTHENTICATE] = &I2PControlSession::handleAuthenticate; 
+    methodHandlers[METHOD_ECHO] = &I2PControlSession::handleEcho;
+    methodHandlers[METHOD_I2PCONTROL] = &I2PControlSession::handleI2PControl;
+    methodHandlers[METHOD_ROUTER_INFO] = &I2PControlSession::handleRouterInfo;
+    methodHandlers[METHOD_ROUTER_MANAGER] = &I2PControlSession::handleRouterManager;
+    methodHandlers[METHOD_NETWORK_SETTING] = &I2PControlSession::handleNetworkSetting; 
+    // RouterInfo handlers
+    routerInfoHandlers[ROUTER_INFO_UPTIME] = &I2PControlSession::handleUptime;
+    routerInfoHandlers[ROUTER_INFO_VERSION] = &I2PControlSession::handleVersion;
+    routerInfoHandlers[ROUTER_INFO_STATUS] = &I2PControlSession::handleStatus;
+    routerInfoHandlers[ROUTER_INFO_DATAPATH] = &I2PControlSession::handleDatapath;
+    routerInfoHandlers[ROUTER_INFO_NETDB_KNOWNPEERS]= &I2PControlSession::handleNetDbKnownPeers;
+    routerInfoHandlers[ROUTER_INFO_NETDB_ACTIVEPEERS] = &I2PControlSession::handleNetDbActivePeers;
+    routerInfoHandlers[ROUTER_INFO_NETDB_LEASESETS] = &I2PControlSession::handleNetDbLeaseSets;
+    routerInfoHandlers[ROUTER_INFO_NETDB_FLOODFILLS] = &I2PControlSession::handleNetDbFloodfills;
+    routerInfoHandlers[ROUTER_INFO_NET_STATUS] = &I2PControlSession::handleNetStatus;
+    routerInfoHandlers[ROUTER_INFO_TUNNELS_PARTICIPATING] = &I2PControlSession::handleTunnelsParticipating;
+    routerInfoHandlers[ROUTER_INFO_TUNNELS_CREATION_SUCCESS] = &I2PControlSession::handleTunnelsCreationSuccess;
+    routerInfoHandlers[ROUTER_INFO_TUNNELS_IN_LIST] = &I2PControlSession::handleTunnelsInList;
+    routerInfoHandlers[ROUTER_INFO_TUNNELS_OUT_LIST] = &I2PControlSession::handleTunnelsOutList;
+    routerInfoHandlers[ROUTER_INFO_BW_IB_1S] = &I2PControlSession::handleInBandwidth1S;
+    routerInfoHandlers[ROUTER_INFO_BW_OB_1S] = &I2PControlSession::handleOutBandwidth1S;
+
+    // RouterManager handlers
+    routerManagerHandlers[ROUTER_MANAGER_SHUTDOWN] = &I2PControlSession::handleShutdown; 
+    routerManagerHandlers[ROUTER_MANAGER_SHUTDOWN_GRACEFUL] = &I2PControlSession::handleShutdownGraceful;
+    routerManagerHandlers[ROUTER_MANAGER_RESEED] = &I2PControlSession::handleReseed;
+}
+
+void I2PControlSession::start()
+{
+    startExpireTokensJob();
+}
+
+void I2PControlSession::stop()
+{
+    boost::system::error_code e; // Make sure this doesn't throw
+    shutdownTimer.cancel(e);
+    expireTokensTimer.cancel(e);
+}
+
+I2PControlSession::Response I2PControlSession::handleRequest(std::stringstream& request)
+{
+    boost::property_tree::ptree pt;
+    boost::property_tree::read_json(request, pt);
+
+    Response response;
+    try { 
+        response.setId(pt.get<std::string>(constants::PROPERTY_ID));
+
+        std::string method = pt.get<std::string>(constants::PROPERTY_METHOD);
+        auto it = methodHandlers.find(method);
+        if(it == methodHandlers.end()) { // Not found
+            LogPrint(eLogWarning, "Unknown I2PControl method ", method);
+            response.setError(ErrorCode::MethodNotFound);
+            return response;
+        }
+
+        PropertyTree params = pt.get_child(constants::PROPERTY_PARAMS);
+        if(method != constants::METHOD_AUTHENTICATE && !authenticate(params, response)) {
+            LogPrint(eLogWarning, "I2PControl invalid token presented");
+            return response;
+        }
+        // Call the appropriate handler
+        (this->*(it->second))(params, response);
+
+    } catch(const boost::property_tree::ptree_error& error) {
+        response.setError(ErrorCode::ParseError);
+    } catch(...) {
+        response.setError(ErrorCode::InternalError);
+    }
+
+    return response;
+}
+
+bool I2PControlSession::authenticate(const PropertyTree& pt, Response& response)
+{
+    try {
+        std::string token = pt.get<std::string>(constants::PARAM_TOKEN); 
+
+        std::lock_guard<std::mutex> lock(tokensMutex);
+        auto it = tokens.find(token);
+        if(it == tokens.end()) {
+            response.setError(ErrorCode::NonexistentToken);
+            return false;
+        } else if(util::GetSecondsSinceEpoch() - it->second > constants::TOKEN_LIFETIME) {
+            response.setError(ErrorCode::ExpiredToken);
+            return false; 
+        }
+
+    } catch(const boost::property_tree::ptree_error& error) {
+        response.setError(ErrorCode::NoToken);
+        return false;
+    }
+
+    return true;
+}
+
+std::string I2PControlSession::generateToken() const
+{
+    byte random_data[constants::TOKEN_SIZE] = {};
+    CryptoPP::AutoSeededRandomPool rng;
+    rng.GenerateBlock(random_data, constants::TOKEN_SIZE);
+    std::string token;
+    CryptoPP::StringSource ss(
+        random_data, constants::TOKEN_SIZE, true,
+        new CryptoPP::HexEncoder(new CryptoPP::StringSink(token))
+    );
+    return token;
+}
+
+void I2PControlSession::handleAuthenticate(const PropertyTree& pt, Response& response)
+{
+    const int api = pt.get<int>(constants::PARAM_API);
+    const std::string given_pass = pt.get<std::string>(constants::PARAM_PASSWORD);
+    LogPrint(eLogDebug, "I2PControl Authenticate API = ", api, " Password = ", given_pass);
+    if(given_pass != password) {
+        LogPrint(
+            eLogError, "I2PControl Authenticate Invalid password ", given_pass,
+            " expected ", password
+        );
+        response.setError(ErrorCode::InvalidPassword);
+        return;
+    }
+    const std::string token = generateToken();
+    response.setParam(constants::PARAM_API, api);
+    response.setParam(constants::PARAM_TOKEN, token);
+
+    std::lock_guard<std::mutex> lock(tokensMutex);
+    tokens.insert(std::make_pair(token, util::GetSecondsSinceEpoch()));
+}
+
+void I2PControlSession::handleEcho(const PropertyTree& pt, Response& response)
+{
+    const std::string echo = pt.get<std::string>(constants::PARAM_ECHO);
+    LogPrint(eLogDebug, "I2PControl Echo Echo = ", echo);
+    response.setParam(constants::PARAM_RESULT, echo);
+}
+
+void I2PControlSession::handleI2PControl(const PropertyTree&, Response&)
+{
+    LogPrint(eLogDebug, "I2PControl I2PControl");
+    // TODO: implement
+    
+}
+
+void I2PControlSession::handleRouterInfo(const PropertyTree& pt, Response& response)
+{
+    LogPrint(eLogDebug, "I2PControl RouterInfo");
+    for(const auto& pair : pt) {
+        if(pair.first == constants::PARAM_TOKEN)
+            continue;
+        LogPrint(eLogDebug, pair.first);
+        auto it = routerInfoHandlers.find(pair.first);
+        if(it != routerInfoHandlers.end()) {
+            (this->*(it->second))(response);
+        } else {
+            LogPrint(eLogError, "I2PControl RouterInfo unknown request ", pair.first);
+            response.setError(ErrorCode::InvalidRequest);
+        }
+    }
+}
+
+void I2PControlSession::handleRouterManager(const PropertyTree& pt, Response& response)
+{
+    LogPrint(eLogDebug, "I2PControl RouterManager");
+    for(const auto& pair : pt) {
+        if(pair.first == constants::PARAM_TOKEN)
+            continue;
+        LogPrint(eLogDebug, pair.first);
+        auto it = routerManagerHandlers.find(pair.first);
+        if(it != routerManagerHandlers.end()) {
+            (this->*(it->second))(response);
+        } else {
+            LogPrint(eLogError, "I2PControl RouterManager unknown request ", pair.first);
+            response.setError(ErrorCode::InvalidRequest);
+        }
+    }
+}
+
+void I2PControlSession::handleNetworkSetting(const PropertyTree&, Response&)
+{
+    // TODO: implement
+}
+
+void I2PControlSession::handleUptime(Response& response)
+{
+    response.setParam(constants::ROUTER_INFO_UPTIME, (int)i2p::context.GetUptime()*1000);
+}
+
+void I2PControlSession::handleVersion(Response& response)
+{
+    response.setParam(constants::ROUTER_INFO_VERSION, VERSION);    
+}
+
+void I2PControlSession::handleStatus(Response& response)
+{
+    response.setParam(constants::ROUTER_INFO_STATUS, "???"); // TODO:
+}
+
+void I2PControlSession::handleDatapath(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_DATAPATH,
+        i2p::util::filesystem::GetDefaultDataDir().string()
+    );
+}
+
+void I2PControlSession::handleNetDbKnownPeers(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_NETDB_KNOWNPEERS, i2p::data::netdb.GetNumRouters()
+    );
+}
+
+void I2PControlSession::handleNetDbActivePeers(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_NETDB_ACTIVEPEERS,
+        (int)i2p::transport::transports.GetPeers().size()
+    );
+}
+
+void I2PControlSession::handleNetDbFloodfills(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_NETDB_FLOODFILLS,
+        (int)i2p::data::netdb.GetNumFloodfills()
+    );
+}
+
+void I2PControlSession::handleNetDbLeaseSets(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_NETDB_LEASESETS,
+        (int)i2p::data::netdb.GetNumLeaseSets()
+    );
+}
+
+void I2PControlSession::handleNetStatus(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_NET_STATUS, (int)i2p::context.GetStatus()
+    );  
+}
+
+void I2PControlSession::handleTunnelsParticipating(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_TUNNELS_PARTICIPATING,
+        (int)i2p::tunnel::tunnels.GetTransitTunnels().size()
+    );
+}
+
+void I2PControlSession::handleTunnelsCreationSuccess(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_TUNNELS_CREATION_SUCCESS,
+        i2p::tunnel::tunnels.GetTunnelCreationSuccessRate()
+    );
+}
+
+void I2PControlSession::handleTunnelsInList(Response& response)
+{
+    JsonObject list;
+
+    for(auto pair : i2p::tunnel::tunnels.GetInboundTunnels()) {
+        const std::string id = std::to_string(pair.first);
+        list[id] = tunnelToJsonObject(pair.second.get());
+        list[id]["bytes"] = JsonObject(
+            static_cast<int>(pair.second->GetNumReceivedBytes())
+        );
+    }
+    response.setParam(constants::ROUTER_INFO_TUNNELS_IN_LIST, list);
+}
+
+void I2PControlSession::handleTunnelsOutList(Response& response)
+{
+    JsonObject list;
+    for(auto tunnel : i2p::tunnel::tunnels.GetOutboundTunnels()) {
+        const std::string id = std::to_string(tunnel->GetTunnelID());
+        list[id] = tunnelToJsonObject(tunnel.get());
+        list[id]["bytes"] = JsonObject(
+            static_cast<int>(tunnel->GetNumSentBytes())
+        );
+    }
+    response.setParam(constants::ROUTER_INFO_TUNNELS_OUT_LIST, list);
+}
+
+void I2PControlSession::handleInBandwidth1S(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_BW_IB_1S,
+        (double)i2p::transport::transports.GetInBandwidth()
+    );
+}
+
+void I2PControlSession::handleOutBandwidth1S(Response& response)
+{
+    response.setParam(
+        constants::ROUTER_INFO_BW_OB_1S,
+        (double)i2p::transport::transports.GetOutBandwidth()
+    );
+}
+
+void I2PControlSession::handleShutdown(Response& response)
+{
+    LogPrint(eLogInfo, "Shutdown requested");
+    response.setParam(constants::ROUTER_MANAGER_SHUTDOWN, "");
+    // 1 second to make sure response has been sent
+    shutdownTimer.expires_from_now(boost::posix_time::seconds(1));
+    shutdownTimer.async_wait([](const boost::system::error_code&) {
+        Daemon.running = 0; 
+    });
+}
+
+void I2PControlSession::handleShutdownGraceful(Response& response)
+{
+    i2p::context.SetAcceptsTunnels(false);
+    int timeout = i2p::tunnel::tunnels.GetTransitTunnelsExpirationTimeout();
+    LogPrint(eLogInfo, "Graceful shutdown requested. Will shutdown after ", timeout, " seconds");
+    response.setParam(constants::ROUTER_MANAGER_SHUTDOWN_GRACEFUL, "");
+    shutdownTimer.expires_from_now(boost::posix_time::seconds(timeout + 1));
+    shutdownTimer.async_wait([](const boost::system::error_code&) {
+        Daemon.running = 0; 
+    });
+}
+
+void I2PControlSession::handleReseed(Response& response)
+{
+    LogPrint(eLogInfo, "Reseed requested");
+    response.setParam(constants::ROUTER_MANAGER_SHUTDOWN, ""); 
+    i2p::data::netdb.Reseed();
+}
+
+void I2PControlSession::expireTokens(const boost::system::error_code& error)
+{
+    if(error == boost::asio::error::operation_aborted)
+        return; // Do not restart timer, shutting down
+
+    startExpireTokensJob();
+    LogPrint(eLogDebug, "I2PControl is expiring tokens.");
+    const uint64_t now = util::GetSecondsSinceEpoch();
+    std::lock_guard<std::mutex> lock(tokensMutex);
+    for(auto it = tokens.begin(); it != tokens.end(); ) {
+        if(now - it->second > constants::TOKEN_LIFETIME)
+            it = tokens.erase(it);
+        else
+            ++it;
+    }
+}
+
+void I2PControlSession::startExpireTokensJob()
+{
+    expireTokensTimer.expires_from_now(boost::posix_time::seconds(constants::TOKEN_LIFETIME));
+    expireTokensTimer.async_wait(std::bind(
+        &I2PControlSession::expireTokens, shared_from_this(), std::placeholders::_1
+    ));
+}
+
+}
+}
+}

client/i2pcontrol/I2PControl.h

@@ -0,0 +1,268 @@
+#ifndef I2PCONTROL_H__
+#define I2PCONTROL_H__
+
+#include <boost/property_tree/ptree.hpp>
+#include <string>
+#include <map>
+#include <functional>
+#include <mutex>
+#include <boost/asio.hpp>
+
+namespace i2p {
+
+// Forward declaration
+namespace tunnel { class Tunnel; }
+
+namespace client {
+namespace i2pcontrol {
+
+namespace constants {
+
+const char DEFAULT_PASSWORD[] = "itoopie";  
+const uint64_t TOKEN_LIFETIME = 600; // Token lifetime in seconds
+const std::size_t TOKEN_SIZE = 8; // Token size in bytes
+
+const char PROPERTY_ID[] = "id";
+const char PROPERTY_METHOD[] = "method";
+const char PROPERTY_PARAMS[] = "params";
+const char PROPERTY_RESULT[] = "result";
+
+// methods  
+const char METHOD_AUTHENTICATE[] = "Authenticate";
+const char METHOD_ECHO[] = "Echo";
+const char METHOD_I2PCONTROL[] = "I2PControl";      
+const char METHOD_ROUTER_INFO[] = "RouterInfo"; 
+const char METHOD_ROUTER_MANAGER[] = "RouterManager";   
+const char METHOD_NETWORK_SETTING[] = "NetworkSetting"; 
+
+// params
+const char PARAM_API[] = "API";         
+const char PARAM_PASSWORD[] = "Password";   
+const char PARAM_TOKEN[] = "Token"; 
+const char PARAM_ECHO[] = "Echo";   
+const char PARAM_RESULT[] = "Result";   
+
+// I2PControl
+const char I2PCONTROL_ADDRESS[] = "i2pcontrol.address";     
+const char I2PCONTROL_PASSWORD[] = "i2pcontrol.password";
+const char I2PCONTROL_PORT[] = "i2pcontrol.port";       
+
+// RouterInfo requests
+const char ROUTER_INFO_UPTIME[] = "i2p.router.uptime";
+const char ROUTER_INFO_VERSION[] = "i2p.router.version";
+const char ROUTER_INFO_STATUS[] = "i2p.router.status";  
+const char ROUTER_INFO_DATAPATH[] = "i2p.router.datapath";
+const char ROUTER_INFO_NETDB_KNOWNPEERS[] = "i2p.router.netdb.knownpeers";
+const char ROUTER_INFO_NETDB_ACTIVEPEERS[] = "i2p.router.netdb.activepeers";
+const char ROUTER_INFO_NETDB_FLOODFILLS[] = "i2p.router.netdb.floodfills";        
+const char ROUTER_INFO_NETDB_LEASESETS[] = "i2p.router.netdb.leasesets";        
+const char ROUTER_INFO_NET_STATUS[] = "i2p.router.net.status";  
+const char ROUTER_INFO_TUNNELS_PARTICIPATING[] = "i2p.router.net.tunnels.participating";
+// TODO: Probably better to use the standard GetRate instead
+const char ROUTER_INFO_TUNNELS_CREATION_SUCCESS[] = "i2p.router.net.tunnels.creationsuccessrate";
+const char ROUTER_INFO_TUNNELS_IN_LIST[] = "i2p.router.net.tunnels.inbound.list";
+const char ROUTER_INFO_TUNNELS_OUT_LIST[] = "i2p.router.net.tunnels.outbound.list";
+const char ROUTER_INFO_BW_IB_1S[] = "i2p.router.net.bw.inbound.1s";
+const char ROUTER_INFO_BW_OB_1S[] = "i2p.router.net.bw.outbound.1s";
+
+// RouterManager requests
+const char ROUTER_MANAGER_SHUTDOWN[] = "Shutdown";
+const char ROUTER_MANAGER_SHUTDOWN_GRACEFUL[] = "ShutdownGraceful";
+const char ROUTER_MANAGER_RESEED[] = "Reseed";      
+
+} // constants
+
+/**
+ * Represents a Json object, provides functionality to convert to string.
+ */
+class JsonObject {
+
+public:
+    JsonObject() = default;
+
+    JsonObject(const std::string& value);
+
+    JsonObject(int value);
+
+    JsonObject(double value);
+
+    JsonObject& operator[](const std::string& key); 
+
+    std::string toString() const;
+
+private:
+    std::map<std::string, JsonObject> children;
+    std::string value;
+};
+
+
+JsonObject tunnelToJsonObject(i2p::tunnel::Tunnel* tunnel);
+
+/**
+ * "Null" I2P control implementation, does not do actual networking.
+ * @note authentication tokens are per-session
+ * @note I2PControlSession must always be used as a std::shared_ptr
+ * @warning an I2PControlSession must be destroyed before its io_service
+ */
+class I2PControlSession : public std::enable_shared_from_this<I2PControlSession> {
+    
+public:
+    enum class ErrorCode {
+        None = 0,
+        // JSON-RPC2
+        MethodNotFound = 32601,
+        InvalidParameters = 32602,
+        InvalidRequest = 32600,
+        InternalError = 32603,
+        ParseError = 32700,
+        // I2PControl specific
+        InvalidPassword = 32001,
+        NoToken = 32002,
+        NonexistentToken = 32003,
+        ExpiredToken = 32004,
+        UnspecifiedVersion = 32005,
+        UnsupportedVersion = 32006
+    };
+
+    class Response {
+        std::string id;
+        std::string version;
+        ErrorCode error;
+        std::map<std::string, std::string> parameters;
+
+    public:
+        Response(const std::string& version = "2.0");
+        std::string toJsonString() const;
+
+        /**
+         * Set an output parameter to a specified string.
+         * @todo escape quotes 
+         */
+        void setParam(const std::string& param, const std::string& value);
+
+        /**
+         * Set an output parameter to a specified integer.
+         */
+        void setParam(const std::string& param, int value);
+
+        /**
+         * Set an output parameter to a specified double.
+         */
+        void setParam(const std::string& param, double value);
+
+        /**
+         * Set an output parameter to a specified Json object.
+         */
+        void setParam(const std::string& param, const JsonObject& value);
+
+        void setError(ErrorCode code);
+        void setId(const std::string& identifier);
+
+        std::string getErrorMsg() const;
+    };
+
+    /**
+     * Sets up the appropriate handlers.
+     * @param pass the password required to authenticate (i.e. obtains a token)
+     * @param ios the parent io_service object, must remain valid throughout
+     *  the lifetime of this I2PControlSession.
+     */
+    I2PControlSession(boost::asio::io_service& ios,
+        const std::string& pass = constants::DEFAULT_PASSWORD);
+
+    /**
+     * Starts the I2PControlSession.
+     * In essence, this starts the expireTokensTimer.
+     * @note should always be called after construction
+     */
+    void start();
+
+    /**
+     * Cancels all operations that are waiting.
+     * @note it's a good idea to call this before destruction (shared_ptr reset)
+     */
+    void stop();
+
+    /**
+     * Handle a json string with I2PControl instructions.
+     */
+    Response handleRequest(std::stringstream& request);
+private:
+    // For convenience
+    typedef boost::property_tree::ptree PropertyTree;
+    // Handler types
+    typedef void (I2PControlSession::*MethodHandler)(
+        const PropertyTree& pt, Response& results
+    );
+    typedef void (I2PControlSession::*RequestHandler)(Response& results);
+    
+    /**
+     * Tries to authenticate by checking whether the given token is valid. 
+     * Sets the appropriate error code in the given response.
+     */
+    bool authenticate(const PropertyTree& pt, Response& response);
+
+    /**
+     * Generate a random authentication token.
+     * @return 8 random bytes as a hexadecimal string
+     */
+    std::string generateToken() const;
+
+    void startExpireTokensJob();
+
+    /**
+     * Expire tokens that are too old.
+     */
+    void expireTokens(const boost::system::error_code& error);
+
+    // Method handlers
+    void handleAuthenticate(const PropertyTree& pt, Response& response);
+    void handleEcho(const PropertyTree& pt, Response& response);
+    void handleI2PControl(const PropertyTree& pt, Response& response);
+    void handleRouterInfo(const PropertyTree& pt, Response& response);
+    void handleRouterManager(const PropertyTree& pt, Response& response);
+    void handleNetworkSetting(const PropertyTree& pt, Response& response);
+
+    // RouterInfo handlers
+    void handleUptime(Response& response);
+    void handleVersion(Response& response);
+    void handleStatus(Response& response);
+    void handleDatapath(Response& response);
+    void handleNetDbKnownPeers(Response& response);
+    void handleNetDbActivePeers(Response& response);
+    void handleNetDbFloodfills(Response& response);
+    void handleNetDbLeaseSets(Response& response);
+    void handleNetStatus(Response& response);
+
+    void handleTunnelsParticipating(Response& response);
+    void handleTunnelsCreationSuccess(Response& response);
+    void handleTunnelsInList(Response& response);
+    void handleTunnelsOutList(Response& response);
+
+    void handleInBandwidth1S(Response& response);
+    void handleOutBandwidth1S(Response& response);
+
+    // RouterManager handlers
+    void handleShutdown(Response& response);
+    void handleShutdownGraceful(Response& response);
+    void handleReseed(Response& response);
+
+    std::string password;
+    std::map<std::string, uint64_t> tokens;
+    std::mutex tokensMutex;
+
+    std::map<std::string, MethodHandler> methodHandlers;
+    std::map<std::string, RequestHandler> routerInfoHandlers;
+    std::map<std::string, RequestHandler> routerManagerHandlers;
+    std::map<std::string, RequestHandler> networkSettingHandlers;
+
+    boost::asio::io_service& service;
+    boost::asio::deadline_timer shutdownTimer;
+    boost::asio::deadline_timer expireTokensTimer;
+};
+
+}
+}
+}
+
+#endif // I2PCONTROL_H__

client/i2pcontrol/I2PControlServer.cpp

@@ -0,0 +1,172 @@
+#include "I2PControlServer.h"
+#include <sstream>
+#include <boost/date_time/local_time/local_time.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include "util/Log.h"
+#include "util/Timestamp.h"
+#include "version.h"
+
+namespace i2p {
+namespace client {
+namespace i2pcontrol {
+
+I2PControlService::I2PControlService(const std::string& address, int port, const std::string& pass)
+    : m_Session(std::make_shared<I2PControlSession>(m_Service, pass)),
+      m_IsRunning(false), m_Thread(nullptr),
+      m_Acceptor(m_Service, boost::asio::ip::tcp::endpoint(
+        boost::asio::ip::address::from_string(address), port)
+      )
+{
+
+}
+
+I2PControlService::~I2PControlService()
+{
+    Stop();
+}
+
+void I2PControlService::Start()
+{
+    if(!m_IsRunning) {
+        Accept();
+        m_Session->start();
+        m_IsRunning = true;
+        m_Thread = new std::thread(std::bind(&I2PControlService::Run, this));
+    }
+}
+
+void I2PControlService::Stop()
+{
+    if(m_IsRunning) {
+        m_IsRunning = false;
+        m_Acceptor.cancel();   
+        m_Session->stop();
+        // Release ownership before the io_service is stopped and destroyed
+        m_Session.reset();
+        m_Service.stop();
+        if(m_Thread)
+        {   
+            m_Thread->join(); 
+            delete m_Thread;
+            m_Thread = nullptr;
+        }   
+    }
+}
+
+void I2PControlService::Run() 
+{ 
+    while(m_IsRunning) {
+        try {   
+            m_Service.run();
+        } catch(const std::exception& ex) {
+            LogPrint(eLogError, "I2PControl: ", ex.what());
+        }   
+    }   
+}
+
+void I2PControlService::Accept()
+{
+    auto newSocket = std::make_shared<boost::asio::ip::tcp::socket>(m_Service);
+    m_Acceptor.async_accept(*newSocket, std::bind(&I2PControlService::HandleAccept, this,
+        std::placeholders::_1, newSocket));
+}
+
+void I2PControlService::HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+{
+    if(ecode != boost::asio::error::operation_aborted)
+        Accept();
+
+    if(!ecode)
+    {
+        LogPrint(eLogInfo, "New I2PControl request from ", socket->remote_endpoint());
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+        ReadRequest(socket);   
+    }
+    else
+        LogPrint(eLogError, "I2PControl accept error: ",  ecode.message());
+}
+
+void I2PControlService::ReadRequest(std::shared_ptr<boost::asio::ip::tcp::socket> socket)
+{
+    auto request = std::make_shared<I2PControlBuffer>();
+    socket->async_read_some(
+#if BOOST_VERSION >= 104900
+        boost::asio::buffer(*request),  
+#else
+        boost::asio::buffer(request->data(), request->size()), 
+#endif              
+        std::bind(&I2PControlService::HandleRequestReceived, this, 
+        std::placeholders::_1, std::placeholders::_2, socket, request));
+}
+
+void I2PControlService::HandleRequestReceived(const boost::system::error_code& ecode,
+    size_t bytes_transferred, std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+    std::shared_ptr<I2PControlBuffer> buf)
+{
+    if(ecode) {
+        LogPrint(eLogError, "I2PControl read error: ", ecode.message());
+        return;
+    }
+
+    try {
+        bool isHtml = !memcmp(buf->data(), "POST", 4);
+        std::stringstream ss;
+        ss.write(buf->data(), bytes_transferred);
+        if(isHtml) {
+            std::string header;
+            while(!ss.eof() && header != "\r")
+                std::getline(ss, header);
+            if(ss.eof()) {
+                LogPrint(eLogError, "Malformed I2PControl request. HTTP header expected");
+                return; // TODO:
+            }
+        }
+
+        I2PControlSession::Response response = m_Session->handleRequest(ss);
+        SendResponse(socket, buf, response.toJsonString(), isHtml);
+    } catch(const std::exception& ex) {
+        LogPrint(eLogError, "I2PControl handle request: ", ex.what());
+    } catch(...) {
+        LogPrint(eLogError, "I2PControl handle request unknown exception");
+    }
+}
+
+void I2PControlService::SendResponse(std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+    std::shared_ptr<I2PControlBuffer> buf, const std::string& response, bool isHtml)
+{
+    size_t len = response.length(), offset = 0;
+    if(isHtml) {
+        std::ostringstream header;
+        header << "HTTP/1.1 200 OK\r\n";
+        header << "Connection: close\r\n";
+        header << "Content-Length: " << boost::lexical_cast<std::string>(len) << "\r\n";
+        header << "Content-Type: application/json\r\n";
+        header << "Date: ";
+        auto facet = new boost::local_time::local_time_facet("%a, %d %b %Y %H:%M:%S GMT");
+        header.imbue(std::locale(header.getloc(), facet));
+        header << boost::posix_time::second_clock::local_time() << "\r\n"; 
+        header << "\r\n";
+        offset = header.str().size();
+        memcpy(buf->data(), header.str().c_str(), offset);
+    }   
+    memcpy(buf->data() + offset, response.c_str(), len);
+    boost::asio::async_write(
+        *socket, boost::asio::buffer(buf->data(), offset + len), 
+        boost::asio::transfer_all(), std::bind(
+            &I2PControlService::HandleResponseSent, this, 
+            std::placeholders::_1, std::placeholders::_2, socket, buf
+        )
+    );
+}
+
+void I2PControlService::HandleResponseSent(const boost::system::error_code& ecode, std::size_t,
+    std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<I2PControlBuffer>)
+{
+    if(ecode)
+        LogPrint(eLogError, "I2PControl write error: ", ecode.message());
+    socket->close();
+}
+
+}
+}
+}

client/i2pcontrol/I2PControlServer.h

@@ -0,0 +1,58 @@
+#ifndef I2P_CONTROL_SERVER_H__
+#define I2P_CONTROL_SERVER_H__
+
+#include "I2PControl.h"
+#include <inttypes.h>
+#include <thread>
+#include <memory>
+#include <array>
+#include <string>
+#include <sstream>
+#include <boost/asio.hpp>
+
+namespace i2p {
+namespace client {
+namespace i2pcontrol {
+
+const size_t I2P_CONTROL_MAX_REQUEST_SIZE = 1024;
+typedef std::array<char, I2P_CONTROL_MAX_REQUEST_SIZE> I2PControlBuffer;        
+
+class I2PControlService {
+public:
+
+    I2PControlService(const std::string& address, int port, const std::string& pass);
+    ~I2PControlService();
+
+    void Start();
+    void Stop();
+
+private:
+
+    void Run();
+    void Accept();
+    void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket);    
+    void ReadRequest(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+    void HandleRequestReceived(const boost::system::error_code& ecode, size_t bytes_transferred, 
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<I2PControlBuffer> buf);
+    void SendResponse(std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+        std::shared_ptr<I2PControlBuffer> buf, const std::string& response, bool isHtml);
+    void HandleResponseSent(const boost::system::error_code& ecode, std::size_t bytes_transferred,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<I2PControlBuffer> buf);
+
+private:
+
+    std::shared_ptr<I2PControlSession> m_Session;
+
+    bool m_IsRunning;
+    std::thread * m_Thread; 
+
+    boost::asio::io_service m_Service;
+    boost::asio::ip::tcp::acceptor m_Acceptor;
+    
+};
+}
+}
+}
+
+#endif
+

contrib/apparmor/usr.sbin.i2pd

@@ -1,34 +0,0 @@
-# Basic profile for i2pd
-# Should work without modifications with Ubuntu/Debian packages
-# Author: Darknet Villain <supervillain@riseup.net>
-#
-#include <tunables/global>
-
-/usr/sbin/i2pd {
-  #include <abstractions/base>
-
-  network inet dgram,
-  network inet stream,
-  network inet6 dgram,
-  network inet6 stream,
-  network netlink raw,
-
-  /etc/gai.conf r,
-  /etc/host.conf r,
-  /etc/hosts r,
-  /etc/nsswitch.conf r,
-  /run/resolvconf/resolv.conf r,
-
-  # path specific (feel free to modify if you have another paths)
-  /etc/i2pd/** r,
-  /run/i2pd/i2pd.pid rw,
-  /var/lib/i2pd/** rw,
-  /var/log/i2pd/i2pd.log w,
-  /var/run/i2pd/i2pd.pid rw,
-  /usr/sbin/i2pd mr,
-  /usr/share/i2pd/** r,
-
-  # user homedir (if started not by init.d or systemd)
-  owner @{HOME}/.i2pd/   rw,
-  owner @{HOME}/.i2pd/** rwk,
-}

contrib/certificates/family/gostcoin.crt

@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB6jCCAY+gAwIBAgIJAPeWi4iUKLBJMAoGCCqGSM49BAMCMHoxCzAJBgNVBAYT
-AlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNVBAoMFUkyUCBBbm9u
-eW1vdXMgTmV0d29yazEPMA0GA1UECwwGZmFtaWx5MSAwHgYDVQQDDBdnb3N0Y29p
-bi5mYW1pbHkuaTJwLm5ldDAeFw0xNzA4MDExMzQ4MzdaFw0yNzA3MzAxMzQ4Mzda
-MHoxCzAJBgNVBAYTAlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNV
-BAoMFUkyUCBBbm9ueW1vdXMgTmV0d29yazEPMA0GA1UECwwGZmFtaWx5MSAwHgYD
-VQQDDBdnb3N0Y29pbi5mYW1pbHkuaTJwLm5ldDBZMBMGByqGSM49AgEGCCqGSM49
-AwEHA0IABC+9iIYumUNnsqKbnTluHimV8OdGvo7yeGxuqhfNNB2b3jvbFJ81scgH
-dsZtMQmUxgKM5nH+NQJMoCxHhSlRy2QwCgYIKoZIzj0EAwIDSQAwRgIhANNh7mOp
-nBBPRh2a/ipG1VYS0d+mNjSrpz8xWcG3CXPLAiEAjM5MTfv9sOJ74PeZVhFZ02w4
-vhgyZCeLJ57f123Lm1A=
------END CERTIFICATE-----

contrib/certificates/family/i2p-dev.crt

@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICCjCCAa2gAwIBAgIEfT9YJTAMBggqhkjOPQQDAgUAMHkxCzAJBgNVBAYTAlhY
-MQswCQYDVQQIEwJYWDELMAkGA1UEBxMCWFgxHjAcBgNVBAoTFUkyUCBBbm9ueW1v
-dXMgTmV0d29yazEPMA0GA1UECxMGZmFtaWx5MR8wHQYDVQQDExZpMnAtZGV2LmZh
-bWlseS5pMnAubmV0MB4XDTE1MTIwOTIxNDIzM1oXDTI1MTIwODIxNDIzM1oweTEL
-MAkGA1UEBhMCWFgxCzAJBgNVBAgTAlhYMQswCQYDVQQHEwJYWDEeMBwGA1UEChMV
-STJQIEFub255bW91cyBOZXR3b3JrMQ8wDQYDVQQLEwZmYW1pbHkxHzAdBgNVBAMT
-FmkycC1kZXYuZmFtaWx5LmkycC5uZXQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC
-AAR7FPSglYrxeSPzv74A1fTwjajZWV0TljqEMBS/56juZQB/7xOwrsHFHA0eEEF9
-dTH64wx3lhV/9sh/stwPU2MToyEwHzAdBgNVHQ4EFgQUQh4uRP1aaX8TJX5dljrS
-CeFNjcAwDAYIKoZIzj0EAwIFAANJADBGAiEAhXlEKGCjJ4urpi2db3OIMl9pB+9t
-M+oVtAqBamWvVBICIQDBaIqfwLzFameO5ULgGRMysKQkL0O5mH6xo910YQV8jQ==
------END CERTIFICATE-----

contrib/certificates/family/i2pd-dev.crt

@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB6TCCAY+gAwIBAgIJAI7G9MXxh7OjMAoGCCqGSM49BAMCMHoxCzAJBgNVBAYT
-AlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNVBAoMFUkyUCBBbm9u
-eW1vdXMgTmV0d29yazEPMA0GA1UECwwGZmFtaWx5MSAwHgYDVQQDDBdpMnBkLWRl
-di5mYW1pbHkuaTJwLm5ldDAeFw0xNjAyMjAxNDE2MzhaFw0yNjAyMTcxNDE2Mzha
-MHoxCzAJBgNVBAYTAlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNV
-BAoMFUkyUCBBbm9ueW1vdXMgTmV0d29yazEPMA0GA1UECwwGZmFtaWx5MSAwHgYD
-VQQDDBdpMnBkLWRldi5mYW1pbHkuaTJwLm5ldDBZMBMGByqGSM49AgEGCCqGSM49
-AwEHA0IABMlWL3loKVOfsA8Rm91QR53Il69mQiaB7n3rUhfPkJb9MYc1S4198azE
-iSnNZSXicKDPIifaCgvONmbACzElHc8wCgYIKoZIzj0EAwIDSAAwRQIgYWmSFuai
-TJvVrlB5RlbiiNFCEootjWP8BFM3t/yFeaQCIQDkg4xcQIRGTHhjrCsxmlz9KcRF
-G+eIF+ATfI93nPseLw==
------END CERTIFICATE-----

contrib/certificates/family/mca2-i2p.crt

@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIBwTCCAWigAwIBAgIJAOZBC10+/38EMAkGByqGSM49BAEwZzELMAkGA1UEBhMC
-QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
-dHMgUHR5IEx0ZDEgMB4GA1UEAwwXbWNhMi1pMnAuZmFtaWx5LmkycC5uZXQwHhcN
-MTYwMzI4MjIwMjMxWhcNMjYwMzI2MjIwMjMxWjBnMQswCQYDVQQGEwJBVTETMBEG
-A1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkg
-THRkMSAwHgYDVQQDDBdtY2EyLWkycC5mYW1pbHkuaTJwLm5ldDBZMBMGByqGSM49
-AgEGCCqGSM49AwEHA0IABNNyfzJr/rMSUeWliVBbJHRF2+qMypOlHEZ9m1nNATVX
-64OhuyuVCmbF9R3oDkcZZJQQK1ovXd/EsbAIWDI8K/gwCQYHKoZIzj0EAQNIADBF
-AiEApmv2tvMwzlvPjHJG1/5aXOSjYWw2s4ETeGt4abWPQkACIBbF3RuCHuzg+KN8
-N0n9hAJztAqhRCdG3hilxF4fbVLp
------END CERTIFICATE-----

contrib/certificates/family/volatile.crt

@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIBxDCCAWmgAwIBAgIJAJnJIdKHYwWcMAoGCCqGSM49BAMCMGcxCzAJBgNVBAYT
-AkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRn
-aXRzIFB0eSBMdGQxIDAeBgNVBAMMF3ZvbGF0aWxlLmZhbWlseS5pMnAubmV0MB4X
-DTE2MDQyNjE1MjAyNloXDTI2MDQyNDE1MjAyNlowZzELMAkGA1UEBhMCQVUxEzAR
-BgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5
-IEx0ZDEgMB4GA1UEAwwXdm9sYXRpbGUuZmFtaWx5LmkycC5uZXQwWTATBgcqhkjO
-PQIBBggqhkjOPQMBBwNCAARf6LBfbbfL6HInvC/4wAGaN3rj0eeLE/OdBpA93R3L
-s8EUp0YTEJHWPo9APiKMmAwQSsMJfjhNrbp+UWEnnx2LMAoGCCqGSM49BAMCA0kA
-MEYCIQDpQu2KPV5G1JOFLoZvdj+rcvEnjxM/FxkaqikwkVx8FAIhANP7DkUal+GT
-SuiCtcqM4QyIBsfsCJBWEMzovft164Bo
------END CERTIFICATE-----

contrib/certificates/reseed/atomike_at_mail.i2p.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIF5TCCA82gAwIBAgIRANFIiHpTaRY2Z30TQOiuqFcwDQYJKoZIhvcNAQELBQAw
-cDELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwGA1UE
-ChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGTAXBgNVBAMM
-EGF0b21pa2VAbWFpbC5pMnAwHhcNMTYwODAyMTQyNDEyWhcNMjYwODAyMTQyNDEy
-WjBwMQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYD
-VQQKExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEZMBcGA1UE
-AwwQYXRvbWlrZUBtYWlsLmkycDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoC
-ggIBAMLRmxclaAvm405JLHNNiniUi0aZaBoLJ+afwn2LGfTDUhTD5Y8lW6V9o90n
-eTNOCaiid7bWpVBkA1M4gZ9TdUnP0POa99jXZbj4PHFRl1l8k4Ap12PUO3hgwtH7
-7j7j+UPaIuE2y+U7hJbmyQ0v7r8yjGWSTtSqs+exNhyr4Mh7DvacZySZ+oqQdXYA
-vnfDpBX1dKlN1Nb4XloG0uE1OK1YfJoC+p+v8qXjKagIdZgThdmsWcQ82EGI+Q9u
-VfrE4m3CNwJy0X86wMNYqHej88wBHnJMmTm+cZtFLVmZsRqnuLAQL1wrfCbGSltR
-zhVQHTysLwMz9+llTXtzMf+R2kcEAYWiPc5IRVU+LvkN/610r5fuHW+OcQ9ZgRVn
-PMqlv5PDG2ZxdIOAQQsOd7fH0r5q3MhqlVstVE45Rl33uA+M7wjJK2cvnOoSioxp
-szn2GIZliXQXo4dJczgfN2U4PLBGRBGmrB1R2S1YsG6CrSJuMCX14VKJP69Nfm8a
-EDA5GKNke+ZpXCszPLaNMB70LVFQc9FmMhsOgLIIoJBgd61uMgokMJJMLaWN0RaK
-w1ZduxYGUmg2T2pi/clIkVzZmlcHKViUn0sMcKD+ibEPOvQIB/3HPEEt6iIkanc/
-da5IFzikkaykt/Tu6o8rreeEu65HkIxFaCHegSXLHSyxj00BAgMBAAGjejB4MA4G
-A1UdDwEB/wQEAwIChDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwDwYD
-VR0TAQH/BAUwAwEB/zAZBgNVHQ4EEgQQYXRvbWlrZUBtYWlsLmkycDAbBgNVHSME
-FDASgBBhdG9taWtlQG1haWwuaTJwMA0GCSqGSIb3DQEBCwUAA4ICAQAA0MdWfN/N
-1q5CdJqDyw4JQwzdYkA27Wr02qIcmwnqjcCEDPl4uDTyqN9gbEpJ48AcsdXRa6GE
-lLh/qJ67I6YDe63LuhndzRULNgxGHVMGS8kBJIssQehb2rOFnbUTp0gMR+0QpXXe
-omase4kL90c9uuYX1vXaO/ADssY2/QX49prwJO+UY/jGhcX4YheFI/teA85u6Qko
-ero437Shqhl0kbdK+eBkOFf9a7mGxpMT73KE1jFS6433W4fFOkybQ1dcS0qStaUM
-3qKC0EQCbAl1seAp3AGuG46swHZB0rZ1WCKVAr5yqCWSWMYO+fL6FosNg9z/VDVh
-g6FFfoGrv19yaVFa9AvQsk1ATZ+bwtHProNx2Xet9pnAI30dT16+C5wCctoR6RVf
-iOHl6CGqadjOycbMDVvOfJhypNDgWW3gBaCfXiAocJTLpR7hKNZ2bnvcP2xyXH1j
-Qz/kiMJoZ3+TV1yC/x/maAHsUIQHqqd6ZRj7x5MgJq0UBdITo2ZQVfXYI0ZGIeNm
-fMu+P5448+NdpASa9QoqS8kPFeUaHJMzMFHBKhrr8lTJeZ82hKBXt5jD3Tbef5Ck
-n5auKu2D0IjvrzsdIpNMQAhuBPT06TW/LzN/MvardZcaLcBmcutefw6Z7RsedHvj
-cGpnw4a2u9sHZIUNHzoGq32+7UWXsBI5Ow==
------END CERTIFICATE-----

contrib/certificates/reseed/cheezybudz_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFhTCCA22gAwIBAgIEeCJXkjANBgkqhkiG9w0BAQ0FADBzMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEcMBoGA1UEAwwTY2hlZXp5YnVkekBt
+YWlsLmkycDAeFw0xNDEyMTYyMTU3MTZaFw0yNDEyMTUyMTU3MTZaMHMxCzAJBgNV
+BAYTAlhYMQswCQYDVQQIEwJYWDELMAkGA1UEBxMCWFgxHjAcBgNVBAoTFUkyUCBB
+bm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRwwGgYDVQQDDBNjaGVlenli
+dWR6QG1haWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAgLkj
+Jsp8pjRi5N/JHHz+MXisgbI9G0vpd3yDhHvae3oF87iiQbxflcdcoH0l5RZL0cAn
+w4amhqoOk2qhf+NSAEkiPWhk7CzPBRwDExEM/gmHYLWXbfnoHGaEls9ORGuDlDmN
+hCFJVrxaZocIOi/7gZ4A+tC8wq+1aoe0Yhr381OW59w9AdUAWjBWibO3V59dEklL
+7HqfOc2v7AMKDLJWgPekj8ZbqA9lRxHM6Djtjz4d9QXeQa8j3xLXTX1QbkvJBBX1
+9Rzi/Nzv622lzoZ/Z/61jW7Bz+h9aJ6qp4on9K4ygUw/VduTOH/1ryQmw87x4MFQ
+Z/Y86lOl7XZxBjtpYpGQW/5LmBe2BCfWgIYe9N5ionNgAe5TNEIDngP9AvJmcTyF
+KcGgOgXQO9EeHEdgf4nC6RbGrb2sBtRjWJv5nOhHRG9tpwYkw/Zc5ZNHOymYpPMg
+wce3me+1psJFt+gXhDcvxpRgTZpXfz91K/nKt3+szcYFluqhJLi6nL1TmXQVn51X
+lGD1bcy1VUof+uKyb223JX5rm9WQ48GzUfy5cK4o+khEo0RLb21FwG5iJwVzhtoN
+xQS1TO6pwLn8Si1ePRwntzlOm8DPIwdUkPBQNJ9DDkcdVia2GgbVM6LH8lrukekq
+soYfwmOTsFRkGo04ujDI/IeMrl3zmJphyQkGx18CAwEAAaMhMB8wHQYDVR0OBBYE
+FJ2MHeHnfCpEuYvC/9eK2ML9ne2eMA0GCSqGSIb3DQEBDQUAA4ICAQA3XUS7Zw1i
+RJWPSu2oLzV7oTtIW5po2Gd5BL3oU6BvlK1zLw/z/soF/LopeHQudBYxYckyv4MG
+gTNS9fcKkVdhNyLI/R2S0nQ/VFhTzuvq8HnnTOpvopA/cXTQlgrhGB2ajIZMYsXe
+lei0V5H23etXTbYZWK6/IgoALk5vowde9lpJEIBhupIafqFg0tAo4LX07/eNxDOp
+nXrShsYhHNaRhglS+0Gqj1UK0WvgMJxQKJm/VLi7jx8vfRkqXs/b76XT+VMQuUJd
+l5llQwpOicQhX/ZTAO+iWrDaO7mz/ZDweLxnfWd3m2JwDJlE9K5l98zdcve96NRZ
+ePnK8vBoAPQ9iHhwFSC5GpirK1KmT/BDLjqEF3H/HgPdPWSh97AUFpBryEIdZk1q
+Czi9DCvwHNpbpI20Fo48+2N7sbvq4onZZqx5V0SjTj/9bHSSDwG9ok1JqWoZmRvo
+p4MIywAJowlvPNc++jSHT3R7segeNUi/UdYCmm70j1av+0aEknmvPtF6atsHJ22X
+5OMBhiPi1pudFWFJFWk4WOjrK/juwHHfHNgFVyziva4q6wPKrPno0gO5pCpfRUld
+QAoSPgo8LAB3dugt5Xfsuone2GhLi1SLQlWFJWHswd/ypWa0FB+xn6Edkc1noOWY
+06dwfEP/gTCAnSplLyrFWxnyHManBxq/bQ==
+-----END CERTIFICATE-----

contrib/certificates/reseed/creativecowpat_at_mail.i2p.crt

@@ -1,35 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIGAzCCA+ugAwIBAgIRAJNGLpTSm2U3GjXmFkjT/0cwDQYJKoZIhvcNAQELBQAw
-dzELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwGA1UE
-ChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxIDAeBgNVBAMM
-F2NyZWF0aXZlY293cGF0QG1haWwuaTJwMB4XDTE3MDUyNjE5NDQzOVoXDTI3MDUy
-NjE5NDQzOVowdzELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJY
-WDEeMBwGA1UEChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAx
-IDAeBgNVBAMMF2NyZWF0aXZlY293cGF0QG1haWwuaTJwMIICIjANBgkqhkiG9w0B
-AQEFAAOCAg8AMIICCgKCAgEAo3XP4JToVbfM5e4GxyAqzu2DJV7ohpzlLqMLyz/9
-XgZ7ipctNoxVZytoaNgMeAHInJn5OhUC4D+emsgsLJqFjnb2pxf6v45sRZLBMieb
-wJlxUmskucpTXwDwuHBk/s3xmH4IluadmzwiCMyycQFH/CNXmu5bonAuZ075rT1Q
-a8W0vb8eSfNYXn+FKQBROqsL5Ep+iJM6FX+oWMxJPk/zNluIu9qTdZL7Fts2+ObP
-X5WLE4Dtot57vMI2Tg3fjnpgvk3ynQjacS8+CBEbvA/j32PBS1mQB+ebl56CQTBv
-glHrXiNdp24TAwy8mwWHknhpt4cvRXOJGZphSVNRYFVk0vv7CTjmQg6WOBGD+d/P
-cosvyKxQz4WUSmtaKUftgCBdnemeM7BppZv2URflEOY6Uv3f9xlEC6yVEzSaa2Md
-tG6XRkDyupWCBFwmSm1uS+SXXhxAQGn3eMXPFA1XkwNnZtmM9kvSVt34FBE231oN
-4oM7rE3ZDyTocZw7cv7bl8idmqsLXDTSFn5Q2iLwvw6ZeTenk8qHrq9kVH1UVE2l
-31iKDNdGQkkVcnTWYfiqriwGLpTqbeD/8n9OBgCke1TiKQzP1o66nhkGJTiiRLFK
-A8rlSpqBcjGbXDs/X+Ote9MrCxE089eCqN51kzDeQ4Yvy8gDOTBPGEhBLirx+3pp
-yWkCAwEAAaOBiTCBhjAOBgNVHQ8BAf8EBAMCAoQwHQYDVR0lBBYwFAYIKwYBBQUH
-AwIGCCsGAQUFBwMBMA8GA1UdEwEB/wQFMAMBAf8wIAYDVR0OBBkEF2NyZWF0aXZl
-Y293cGF0QG1haWwuaTJwMCIGA1UdIwQbMBmAF2NyZWF0aXZlY293cGF0QG1haWwu
-aTJwMA0GCSqGSIb3DQEBCwUAA4ICAQCYzeYyPYhW+/SZSfpDl6JTzXy8S6NG+yjq
-pcinxaIF4XFoXLwWD3uHR4jgpU750mhHJjpGIaltZjFaqLbqtysbqb0vdShyaK/n
-Td4CXrNBvEHvLI6DZyDX4BcDlhCI7/dMCSHXwFIhRHhYSnTsJO32BdP5DsUUAlSW
-G0FlEEWjlxcdRwIITv70cFNlNOqJeyvtk9DPT+nEzssKWxVZcqN4GK8dvQVWgL91
-8uzrcAYpAEQfmkKzsGmV4v5gWumLZmnzc24hUhVsHhIph4HAmjPMFCppI1tgiwg7
-fH71MYB8b9KBJKipkLdAL292mDLS4G3MGQwMbcjnTyIqOktmyyj/1CorZAKqBtzu
-Qyo7z8FM2pd5nzk7QDx/vsJ4bNAYvVu7titDW5mv5JDoQcp2uDVGePlonX3I8iFx
-CqKFzGHiR0EU8oWw0Pqf+y2rEV4L74agmUR7VbA+/ovz0UnDUoXIynSwpK7Kfo8D
-B7ky9RnmsxJX6TXaMVW06IlYuwIUsAWbMhKvdXbGZur5VVi1ZY1/HgZZnoXejzCe
-w3mMl6movkcA0noDXQ+eauUDHjktrVUJdZKYvZNjfnz2rB+MI5wB/hzeBv4KuYFE
-oTFt8SwTzs0joM4c7RomTxc+QFe832SvjPAnxQn17qSjD8z4c7Ako6sCKvpdBSDm
-Hz8KWVkHZg==
------END CERTIFICATE-----

contrib/certificates/reseed/igor_at_novg.net.crt

@@ -1,33 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFvjCCA6agAwIBAgIQIDtv8tGMh0FyB2w5XjfZxTANBgkqhkiG9w0BAQsFADBt
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEWMBQGA1UEAwwN
-aWdvckBub3ZnLm5ldDAeFw0xNzA3MjQxODI4NThaFw0yNzA3MjQxODI4NThaMG0x
-CzAJBgNVBAYTAlhYMQswCQYDVQQHEwJYWDELMAkGA1UECRMCWFgxHjAcBgNVBAoT
-FUkyUCBBbm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRYwFAYDVQQDDA1p
-Z29yQG5vdmcubmV0MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxst4
-cam3YibBtQHGPCPX13uRQti56U3XZytSZntaKrUFmJxjt41Q/mOy3KYo+lBvhfDF
-x3tWKjgP9LJOJ28zvddFhZVNxqZRjcnAoPuSOVCw88g01D9OAasKF11hCfdxZP6h
-vGm8WCnjD8KPcYFxJC4HJUiFeProAwuTzEAESTRk4CAQe3Ie91JspuqoLUc5Qxlm
-w5QpjnjfZY4kaVHmZDKGIZDgNIt5v85bu4pWwZ6O+o90xQqjxvjyz/xccIec3sHw
-MHJ8h8ZKMokCKEJTaRWBvdeNXki7nf3gUy/3GjYQlzo0Nxk/Hw4svPcA+eL0AYiy
-Jn83bIB5VToW2zYUdV4u3qHeAhEg8Y7HI0kKcSUGm9AQXzbzP8YCHxi0sbb0GAJy
-f1Xf3XzoPfT64giD8ReUHhwKpyMB6uvG/NfWSZAzeAO/NT7DAwXpKIVQdkVdqy8b
-mvHvjf9/kWKOirA2Nygf3r79Vbg2mqbYC/b63XI9hheU689+O7qyhTEhNz+11X0d
-Zax7UPrLrwOeB9TNfEnztsmrHNdv2n+KcOO2o11Wvz2nHP9g+dgwoZSD1ZEpFzWP
-0sD5knKLwAL/64qLlAQ1feqW7hMr80IADcKjLSODkIDIIGm0ksXqEzTjz1JzbRDq
-jUjq7EAlkw3G69rv1gHxIntllJRQidAqecyWHOMCAwEAAaNaMFgwDgYDVR0PAQH/
-BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAPBgNVHRMBAf8E
-BTADAQH/MBYGA1UdDgQPBA1pZ29yQG5vdmcubmV0MA0GCSqGSIb3DQEBCwUAA4IC
-AQADyPaec28qc1HQtAV5dscJr47k92RTfvan+GEgIwyQDHZQm38eyTb05xipQCdk
-5ruUDFXLB5qXXFJKUbQM6IpaktmWDJqk4Zn+1nGbtFEbKgrF55pd63+NQer5QW9o
-3+dGj0eZJa3HX5EBkd2r7j2LFuB6uxv3r/xiTeHaaflCnsmyDLfb7axvYhyEzHQS
-AUi1bR+ln+dXewdtuojqc1+YmVGDgzWZK2T0oOz2E21CpZUDiP3wv9QfMaotLEal
-zECnbhS++q889inN3GB4kIoN6WpPpeYtTV+/r7FLv9+KUOV1s2z6mxIqC5wBFhZs
-0Sr1kVo8hB/EW/YYhDp99LoAOjIO6nn1h+qttfzBYr6C16j+8lGK2A12REJ4LiUQ
-cQI/0zTjt2C8Ns6ueNzMLQN1Mvmlg1Z8wIB7Az7jsIbY2zFJ0M5qR5VJveTj33K4
-4WSbC/zMWOBYHTVBvGmc6JGhu5ZUTZ+mWP7QfimGu+tdhvtrybFjE9ROIE/4yFr6
-GkxEyt0UY87TeKXJ/3KygvkMwdvqGWiZhItb807iy99+cySujtbGfF2ZXYGjBXVW
-dJOVRbyGQkHh6lrWHQM4ntBv4x+5QA+OAan5PBF3tcDx1vefPx+asYslbOXpzII5
-qhvoQxuRs6j5jsVFG6RdsKNeQAt87Mb2u2zK2ZakMdyD1w==
------END CERTIFICATE-----

contrib/certificates/reseed/lazygravy_at_mail.i2p.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFzTCCA7WgAwIBAgIQCnVoosrOolXsY+bR5kByeTANBgkqhkiG9w0BAQsFADBy
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEbMBkGA1UEAwwS
-bGF6eWdyYXZ5QG1haWwuaTJwMB4XDTE2MTIyNzE1NDEzNloXDTI2MTIyNzE1NDEz
-NlowcjELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwG
-A1UEChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGzAZBgNV
-BAMMEmxhenlncmF2eUBtYWlsLmkycDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC
-AgoCggIBAN3q+0nUzz9+CBSoXUNf8K6kIc9zF+OP1NVBmOu3zTtkcEnhTtoDNXeU
-EV8DhlBhEACbPomA+szQ5zp3O3OYQc2NV50S7KKqlfn5LBBE3BL2grTeBxUMysDd
-0TlpxcHKwaog4TZtkHxeNO94F1vgeOkOnlpCQ6H3cMkPEGG3zu1A1ccgPiYO838/
-HNMkSF//VZJLOfPe1vmn9xTB7wZ0DLpEh12QZGg3irA+QDX5zy6Ffl+/Lp+L4tXT
-uPZUaC6CL6EABX4DvQcFrOtiWfkbi/ROgYCeTrYw1XbDHfPc+MBxGo1bX7JjnD0o
-mFFvo+PjxvWDmCad2TaITh6DwGEeWKu8NtJAyaO5p1ntauuWGB5Xzua4aMmIy7GT
-esHQkhW+5IooM0R5bZI8/KXo4Bj52bX5qv+oBiExc6PUUTLWyjoWHb7fKdddwGfc
-lUfniV/fw7/9ysIkQZcXLDCXR6O/nH9aGDZ7bxHedw4/LxAXYPfNojb5j7ZVa65o
-PWD5xuQfbE+95DdbnKjcjYiam4kjApe7YPwOhtoRJYSGAkrpIMfzFxCXgjTsi3Kw
-Ov+sYmBvWBK4ROWQZTgHei3x4FpAGWHCAeTeeQGKmWQ8tT7ZklWD9fBm3J/KXo7I
-WCxRW9oedItyqbRuAGxqaoaGSk6TtPVjyPIUExDp1dr4p1nM1TOLAgMBAAGjXzBd
-MA4GA1UdDwEB/wQEAwIChDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEw
-DwYDVR0TAQH/BAUwAwEB/zAbBgNVHQ4EFAQSbGF6eWdyYXZ5QG1haWwuaTJwMA0G
-CSqGSIb3DQEBCwUAA4ICAQA2fei/JajeQ7Rn0Hu3IhgF9FDXyxDfcS9Kp+gHE56A
-50VOtOcvAQabi/+lt5DqkiBwanj0Ti/ydFRyEmPo45+fUfFuCgXcofro8PGGqFEz
-rZGtknH/0hiGfhLR9yQXY8xFS4yvLZvuIcTHa9QPJg3tB9KeYQzF91NQVb5XAyE7
-O3RvollADTV31Xbhxjb7lgra6ff9dZQJE6xtlSk/mnhILjlW80+iPKuj3exBgbJv
-ktiR4ZT4xjh1ZgNJX5br86MZrhyyyGWwHWHS0e443eSrrmAPD69zxsfvhoikRX1z
-tDz0zB70DwS4pSbVrFuWaIAcbg36vWO8tYPBzV8iBB/tBTURGJjv6Q0EoI5GHmJi
-LOhU3B6xublv8Tcoc3tgMqI9STnWROtTiCS6LsWNSXhVpIZqvaiOEtPN4HyL33sf
-j5rfPq76gKrTloeLnwLGq0Rs94ScffYkBap3fQ/ALb87LQcwSN4EkObur5pcd7TS
-qNdanvCGK8v1UYVzH4l9jekPGsM5euohwAkIl1kZ6+tqGY/MTa7HwTTQyLDTco1t
-sPy6neN46+H5DYHADyU5H2G39Kk3WcLmPtfxlPDM6e73+47fJkXnmiaWM0Lrt80y
-Enng6bFGMZH01ZsqBk09H+Uswv8h7k69q9uWAS95KE0omCMVtIpoPZXTnRhe6mBC
-+g==
------END CERTIFICATE-----

contrib/certificates/reseed/matt_at_drollette.com.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIEB52rdjANBgkqhkiG9w0BAQ0FADByMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEbMBkGA1UEAwwSbWF0dEBkcm9sbGV0
+dGUuY29tMB4XDTE0MDcyMTEzMjYxM1oXDTI0MDcyMDEzMjYxM1owcjELMAkGA1UE
+BhMCWFgxCzAJBgNVBAgTAlhYMQswCQYDVQQHEwJYWDEeMBwGA1UEChMVSTJQIEFu
+b255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGzAZBgNVBAMMEm1hdHRAZHJv
+bGxldHRlLmNvbTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL5M9wKT
+csNLg4EA3fW7LleTQdrm3stPnoUvFmsNZHGgsKt1Nc1qCNis3kr2QEY+4Z398U7r
+7xGEQFa7D/9SPHf6n1uVXc9DIcmwBtEB0FPB1XPFp2h00ZXIv24yiLN3GQT1woAM
+yEbBWsUgn8K/iMBeA5dU2vPwAbGO/0ibD62frgGdYqU2EeiJ/U6vBmKxvC+q2noL
+gnyfQJEJANXgf+Cw/gBaS6yn5ZsYcenLNenID2TQKQ6Q/NxYrDYRdWdId29iwldt
+dmNSmASv8C7g9d/isZkpmtYNkE4J4m0W9wKziOoyvLSMo8ec67QmCKaPaYKTHTjx
+aUuja02+mnlV4DSdZo6nPkSdokRY0+5e6q7+dIPefu8ealGEAE5oedEfl5iM5Fnz
+phTR+ePodBK3sB+bMi1NMppbWugpFpdqs1hg2KNKSSG8C4/eTqf2nnlDiVvvFANc
+imt6tk0pZcKqveRiDSgI8mTzTcrNgVClsCLoInY5Vab7onZjY9bGijPQ2i1P6+qu
+5G6LiLFW7xFq2BcX1DnTztcJ8Yu9NYHhR21J6u7Dr8YHntes3mnth1F0BX3FVA1s
+9SaE9/pNhdqap9owpEhNoE1Ke3LorVLL8jyQsqgRHx8VdhWdi9Ao0mzzeI9HYX0j
+nZ7uXK5DqGG74K6eWoS9jZSDJLj3IBkIr3B/AgMBAAGjITAfMB0GA1UdDgQWBBTK
+YjH+9Jv82Zqi86r95/1sXUCOnDANBgkqhkiG9w0BAQ0FAAOCAgEAsDyl3dS/5pR1
+iDN0zE70HN1Sjv55c5um6N39rgz8JSObbAMihhpjRXPR6yl0PdfVcswdCuEaaykp
+ppPNY5ObqZIdqI92XOaOhSA3AkZwZffbwaoXFYiawq1aQG1HP7oxXzWwbnbPOxgz
+6ThNP5DJan53Mk8TAhxoJkEJxVlMwIiC+QEgqDNYrP8oNOR2J1EXgzsHheEKObyP
+xTwRYFqZU/7BQlFeB0LG1LIy9zXAHlb/XIor10w6ChPDW7DiDwGq3zDJw1d8eiUn
+RoPRmFjTqn+3rGaEkk+vUFHoWo7cLCEIC3+P9wlY4Kel+ldXMmuJ+BZ1glFXeO3L
+VO85n7iVIyBbwo7RLtNaBvrRQIEG3ld5UOKklLlWwhrX/FXksEhdFvmuF9sbiYNr
+cg81sbwZlX7Gi7VicXkykFFXwRRr3UblDtfeevouxk4nMVzcDsmzGeAZKQBvcxHa
+Pzc70YwnVRqTc87c0bEwPoxK1Vb26+DILyDjKb/AkTw/rwj6vcJZP2ad+hpiz5Ka
+nlbY2cI3JJb0TQiDiOIk+xFqC5oHUTSEmfqA6sA5o/RqdwDpkfpgI5mCwhYzDSLD
+jfS+263ylhanl7oz0sM+GtH63owVbYJAFT2EozT9siTIErvJESL4Z80yUQG63d/7
+fss8T6gOo19esb/KEMZGZE4pAApakWM=
+-----END CERTIFICATE-----