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++))))

.github/workflows/build-freebsd.yml

@@ -1,20 +0,0 @@
-name: Build on FreeBSD
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: macos-latest
-    name: with UPnP
-    steps:
-    - uses: actions/checkout@v2
-    - name: Test in FreeBSD
-      id: test
-      uses: vmactions/freebsd-vm@v0.1.4
-      with:
-        usesh: true
-        prepare: pkg install -y devel/cmake devel/gmake devel/boost-libs security/openssl net/miniupnpc 
-        run: |
-          cd build
-          cmake -DWITH_UPNP=ON -DCMAKE_BUILD_TYPE=Release .
-          gmake -j2

.github/workflows/build-osx.yml

@@ -1,20 +0,0 @@
-name: Build on OSX
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    name: With USE_UPNP=${{ matrix.with_upnp }}
-    runs-on: macOS-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['yes', 'no']
-    steps:
-    - uses: actions/checkout@v2
-    - name: install packages
-      run: |
-        brew update
-        brew install boost miniupnpc openssl@1.1
-    - name: build application
-      run: make HOMEBREW=1 USE_UPNP=${{ matrix.with_upnp }} PREFIX=$GITHUB_WORKSPACE/output -j3

.github/workflows/build-windows.yml

@@ -1,35 +0,0 @@
-name: Build on Windows
-
-on: [push, pull_request]
-
-defaults:
-  run:
-    shell: msys2 {0}
-
-jobs:
-  build:
-    name: Building for ${{ matrix.arch }}
-    runs-on: windows-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        include: [
-          { msystem: MINGW64, arch: x86_64 },
-          { msystem: MINGW32, arch: i686   }
-        ]
-    steps:
-    - uses: actions/checkout@v2
-    - name: Setup MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.msystem }}
-        install: base-devel mingw-w64-${{ matrix.arch }}-gcc mingw-w64-${{ matrix.arch }}-boost mingw-w64-${{ matrix.arch }}-openssl mingw-w64-${{ matrix.arch }}-miniupnpc
-        update: true
-    - name: build application
-      run: |
-        mkdir -p obj/Win32 obj/libi2pd obj/libi2pd_client obj/daemon
-        make USE_UPNP=yes DEBUG=no -j3
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        path: i2pd.exe

.github/workflows/build.yml

@@ -1,88 +0,0 @@
-name: Build on Ubuntu
-
-on: [push, pull_request]
-
-jobs:
-  build-make:
-    name: Make with USE_UPNP=${{ matrix.with_upnp }}
-    runs-on: ubuntu-18.04
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['yes', 'no']
-    steps:
-    - uses: actions/checkout@v2
-    - name: install packages
-      run: |
-        sudo add-apt-repository ppa:mhier/libboost-latest
-        sudo apt-get update
-        sudo apt-get install build-essential libboost1.74-dev libminiupnpc-dev libssl-dev zlib1g-dev
-    - name: build application
-      run: make USE_UPNP=${{ matrix.with_upnp }} -j3
-  build-cmake:
-    name: CMake with -DWITH_UPNP=${{ matrix.with_upnp }}
-    runs-on: ubuntu-18.04
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['ON', 'OFF']
-    steps:
-    - uses: actions/checkout@v2
-    - name: install packages
-      run: |
-        sudo add-apt-repository ppa:mhier/libboost-latest
-        sudo apt-get update
-        sudo apt-get install build-essential cmake libboost1.74-dev libminiupnpc-dev libssl-dev zlib1g-dev
-    - name: build application
-      run: |
-        cd build
-        cmake -DWITH_UPNP=${{ matrix.with_upnp }} .
-        make -j3
-  build-deb-stretch:
-    name: Build package for stretch
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: change debian changelog
-      run: |
-        sudo apt-get update
-        sudo apt-get install devscripts
-        debchange -v "`git describe --tags`-stretch" -M --distribution stretch "trunk build"
-    - uses: singingwolfboy/build-dpkg-stretch@v1
-      id: build
-      with:
-        args: --unsigned-source --unsigned-changes -b
-    - uses: actions/upload-artifact@v1
-      with:
-        name: ${{ steps.build.outputs.filename }}
-        path: ${{ steps.build.outputs.filename }}
-    - uses: actions/upload-artifact@v1
-      with:
-        name: ${{ steps.build.outputs.filename-dbgsym }}
-        path: ${{ steps.build.outputs.filename-dbgsym }}
-  build-deb-buster:
-    name: Build package for buster
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: change debian changelog
-      run: |
-        sudo apt-get update
-        sudo apt-get install devscripts
-        debchange -v "`git describe --tags`-buster" -M --distribution buster "trunk build"
-    - uses: singingwolfboy/build-dpkg-buster@v1
-      id: build
-      with:
-        args: --unsigned-source --unsigned-changes -b
-    - uses: actions/upload-artifact@v1
-      with:
-        name: ${{ steps.build.outputs.filename }}
-        path: ${{ steps.build.outputs.filename }}
-    - uses: actions/upload-artifact@v1
-      with:
-        name: ${{ steps.build.outputs.filename-dbgsym }}
-        path: ${{ steps.build.outputs.filename-dbgsym }}

.github/workflows/docker.yml

@@ -1,63 +0,0 @@
-name: Build containers
-
-on: [push]
-
-jobs:
-  docker:
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1 
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to GitHub Container registry
-        uses: docker/login-action@v1 
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push trunk container
-        if: ${{ !startsWith(github.ref, 'refs/tags/') }}
-        uses: docker/build-push-action@v2
-        with:
-          context: ./contrib/docker
-          file: ./contrib/docker/Dockerfile
-          platforms: linux/amd64,linux/386,linux/arm64,linux/arm/v7
-          push: true
-          tags: |
-            purplei2p/i2pd:latest
-            ghcr.io/purplei2p/i2pd:latest
-
-      - name: Set env
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        run: echo "RELEASE_VERSION=${GITHUB_REF:10}" >> $GITHUB_ENV
-
-      - name: Build and push release container
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        uses: docker/build-push-action@v2
-        with:
-          context: ./contrib/docker
-          file: ./contrib/docker/Dockerfile
-          platforms: linux/amd64,linux/386,linux/arm64,linux/arm/v7
-          push: true
-          tags: |
-            purplei2p/i2pd:latest
-            purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}
-            ghcr.io/purplei2p/i2pd:latest
-            ghcr.io/purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}

.gitignore

@@ -1,27 +1,32 @@
 # i2pd
-*.o
 router.info
 router.keys
 i2p
+libi2pd.so
 netDb
-/i2pd
-/libi2pd.a
-/libi2pdclient.a
-/libi2pdlang.a
-/libi2pd.so
-/libi2pdclient.so
-/libi2pdlang.so
-/libi2pd.dll
-/libi2pdclient.dll
-/libi2pdlang.dll
-*.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
@@ -58,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
@@ -241,38 +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/*.autosave
-qt/i2pd_qt/*.ui.bk*
-qt/i2pd_qt/*.ui_*
-
-#unknown android stuff
-android/libs/
-
-#various logs
-*LOGS/
-
-qt/build-*.sh*
-

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,707 +0,0 @@
-# for this file format description,
-# see https://github.com/olivierlacan/keep-a-changelog
-
-## [2.39.0] - 2021-08-23
-### Added
-- Short tunnel build messages
-- Localization. To: Russian, Ukrainian, Turkmen, Uzbek and Afrikaans
-- Custom CSS styles for webconsole
-- Avoid slow tunnels with more than 250 ms per hop
-- Process DELAY_REQUESTED streaming option
-- "certsdir" options for certificates location
-- Keep own RouterInfo in NetBb
-- Pick ECIES routers only for tunnels on non-x64
-- NTP sync through ipv6
-- Allow ipv6 addresses for UDP server tunnels
-### Changed
-- Rekey of all routers to ECIES
-- Better distribution for random tunnel's peer selection
-- Yggdrasil reseed for v0.4, added two more
-- Encryption type 0,4 by default for server tunnels
-- Handle i2cp.dontPublishLeaseSet param for all destinations 
-- reg.i2p for subscriptions
-- LeaseSet type 3 by default
-- Don't allocate payload buffer for every single ECIESx25519 message
-- Prefer public ipv6 instead rfc4941 
-- Optimal padding for one-time ECIESx25519 message
-- Don't send datetime block for one-time ECIESx25519 message with one-time key
-- Router with expired introducer is still valid
-- Don't disable floodfill if still reachable by ipv6
-- Set minimal version for floodfill to 0.9.38
-- Eliminate extra lookups for sequential fragments on tunnel endpoint
-- Consistent path for explicit peers
-- Always create new tunnel from exploratory pool
-- Don't try to connect to a router not reachable from us
-- Mark additional ipv6 addresses/nets as reserved (#1679)
-### Fixed
-- Zero-hop tunnels
-- Crash upon SAM session termination
-- Build with boost < 1.55.0
-- Address type for NTCP2 acceptors
-- Check of ipv4/ipv6 address
-- Request router to send to if not in NetDb
-- Count outbound traffic for zero-hop tunnels
-- URLdecode domain for registration string generator in webconsole
-
-## [2.38.0] - 2021-05-17
-### Added
-- Publish ipv6 introducers
-- Bind ipv6 or yggdrasil NTCP2 acceptor to specified address 
-- Support .b32.i2p addresses and hostnames for SAM STREAM CREATE
-- ipv6 peer tests
-- Publish iexp param for introducers
-- Show ipv6 network status on the webconsole
-- EdDSA signing keys can also be blinded
-- Show router version on the webconsole
-### Changed
-- Rekey of all routers but floodfills to ECIES
-- Increased number of precalculated x25519 keys to 15
-- Don't publish LeaseSet without inbound tunnels
-- Reseed from compatible address(ipv4 or ipv6)
-- Recongnize v4 and v6 SSU addresses without host
-- Inbound tunnel gateway must be ipv4 compatible
-- Don't select next introducers from existing sessions
-- Set X bandwidth for floodfill by default
-### Fixed
-- Incoming ECIES-x25519 session doesn't send updated LeaseSet
-- Unique local address for server tunnels
-- Race condition for LeaseSet creation in I2CP
-- Relay tag for ipv6 introducer
-- Already expired introducers
-- Find connected router for first peer in tunnel
-- Failed outgoing ECIES-x25519 session's tagset stays forever
-- Yggdrasil address disappears if router becomes unreachable through ipv6
-- Ignore SSU address/introducers if port is not specified
-- Check identity and signature length for SSU SessionConfirmed
-
-## [2.37.0] - 2021-03-15
-### Added
-- Address registration line for reg.i2p and stats.i2p through the web console
-- "4" and "6" caps for addresses without published IP address
-- Mesh and Proxy network statuses
-- Symmetric NAT network status error
-- Bind server tunnel connection to specified address
-- lookuplocal BOB extended command
-- address4 and address6 parameters to bind outgoing connections to 
-- Rekey of low-bandwidth routers to ECIES
-- Popup notification windows when unable to parse config for Windows
-### Changed
-- Floodfills with "U" cap are not ignored anymore
-- Check transports reachability between tunnel peers and between router and floodfill 
-- NTCP2 and reseed HTTP proxy support authorization now
-- Show actual IP addresses for proxy connections
-- Publish and handle SSU addreses without host
-- Outbound tunnel endpoint must be ipv4 compatible
-- Logging optimization
-- Removed Windows service
-### Fixed
-- Incoming SSU session terminates after 5 seconds
-- Outgoing NTCP2 ipv4 session even if ipv4 is disabled
-- No incoming Yggdrasil connection if connected through NTCP2 proxy
-- Race condition between tunnel build and floodfill requests decryption for ECIES routers
-- Numeric bandwidth limitation
-- Yggdrasil for Android
-
-## [2.36.0] - 2021-02-15
-### Added
-- Encrypted lookup and publications to ECIES-x25519 floodfiils
-- Yggdrasil transports and reseeds
-- Dump addressbook in hosts.txt format
-- Request RouterInfo through exploratory tunnels if direct connection to fllodfill is not possible
-- Threads naming
-- Check if public x25519 key is valid 
-- ECIES-X25519-AEAD-Ratchet for shared local destination
-- LeaseSet creation timeout for I2CP session
-- Resend RouterInfo after some interval for longer NTCP2 sessions
-- Select reachable router of inbound tunnel gateway
-- Reseed if no compatible routers in netdb 
-- Refresh on swipe in Android webconsole
-### Changed
-- reg.i2p for default addressbook instead inr.i2p
-- ECIES-x25519 (crypto type 4) for new routers
-- Try to connect to all compatible addresses from peer's RouterInfo
-- Replace LeaseSet completely if store type changes 
-- Try ECIES-X25519-AEAD-Ratchet tag before ElGamal
-- Don't detach ECIES-X25519-AEAD-Ratchet session from destination immediately
-- Viewport and styles on error in HTTP proxy
-- Don't create notification when Windows taskbar restarted 
-- Cumulative SSU ACK bitfields
-- limit tunnel length to 8 hops
-- Limit tunnels quantity to 16
-### Fixed
-- Handling chunked HTTP response in addressbook
-- Missing ECIES-X25519-AEAD-Ratchet tags for multiple streams with the same destination
-- Correct NAME for NAMING REPLY in SAM
-- SSU crash on termination
-- Offline signature length for stream close packet
-- Don't send updated LeaseSet through a terminated session
-- Decryption of follow-on ECIES-X25519-AEAD-Ratchet NSR messages
-- Non-confirmed LeaseSet is resent too late for ECIES-X25519-AEAD-Ratchet session
-
-## [2.35.0] - 2020-11-30
-### Added
-- ECIES-x25519 routers
-- Random intro keys for SSU
-- Graceful shutdown timer for windows
-- Send queue for I2CP messages
-- Update DSA router keys to EdDSA
-- TCP_QUICKACK for NTCP2 sockets on Linux
-### Changed
-- Exclude floodfills with DSA signatures and < 0.9.28
-- Random intervals between tunnel tests and manage for tunnel pools
-- Don't replace an addressbook record by one with DSA signature
-- Publish RouterInfo after update
-- Create paired inbound tunnels if no inbound tunnels yet
-- Reseed servers list
-### Fixed
-- Transient signature length, if different from identity
-- Terminate I2CP session if destroyed
-- RouterInfo publishing confirmation
-- Check if ECIES-X25519-AEAD-Ratchet session expired before generating more tags 
-- Correct block size for delivery type local for ECIES-X25519-AEAD-Ratchet
-
-## [2.34.0] - 2020-10-27
-### Added
-- Ping responses for streaming
-- STREAM FORWARD for SAM
-- Tunnels through ECIES-x25519 routers
-- Single thread for I2CP
-- Shared transient destination between proxies
-- Database lookups from ECIES destinations with ratchets response
-- Handle WebDAV HTTP methods 
-- Don't try to connect or build tunnels if offline
-- Validate IP when trying connect to remote peer
-- Handle ICMP responses and WinAPI errors for SSU
-### Changed
-- Removed NTCP
-- Dropped gcc 4.7 support
-- Encyption type 0,4 by default for client tunnels
-- Stripped out some HTTP header for HTTP server response
-- HTTP 1.1 addressbook requests
-- Set LeaseSet type to 3 for ratchets if not specified
-- Handle SSU v4 and v6 messages in one thread
-- Eliminate DH keys thread
-### Fixed
-- Random crashes on I2CP session disconnect
-- Stream through racthets hangs if first SYN was not acked
-- Check "Last-Modified" instead "If-Modified-Since" for addressbook reponse
-- Trim behind ECIESx25519 tags 
-- Few bugs with Android main activity
-- QT visual and layout issues
-
-## [2.33.0] - 2020-08-24
-### Added
-- Shared transient addresses
-- crypto.ratchet.inboundTags paramater
-- Multiple encryption keys through I2CP
-- Pre-calculated x25519 ephemeral keys
-- Change datagram routing path if nothing comes back in 10 seconds
-- Shared routing path for datagram session 
-### Changed
-- UDP tunnels send mix of repliable and raw datagrams in bulk
-- Encrypt SSU packet again upon resend
-- Start new tunnel message if remaining buffer is too small 
-- Use LeaseSet2 for ECIES-X25519-AEAD-Ratchet automatically
-- Save new ECIES-X25519-AEAD-Ratchet session with NSR tagset
-- Generate random padding lengths for ECIES-X25519-AEAD-Ratchet in bulk
-- Webconsole layout
-- Reseed servers list
-### Fixed
-- Don't connect through terminated SAM destination
-- Differentiate UDP server sessions by port 
-- ECIES-X25519-AEAD-Ratchet through I2CP
-- Don't save invalid address to AddressBook
-- ECDSA signatures names in SAM
-- AppArmor profile 
-
-## [2.32.1] - 2020-06-02
-### Added
-- Read explicit peers in tunnels config
-### Fixed
-- Generation of tags for detached sessions
-- Non-updating LeaseSet1
-- Start when deprecated websocket options present in i2pd.conf
-
-## [2.32.0] - 2020-05-25
-### Added
-- Multiple encryption types for local destinations
-- Next key and tagset for ECIES-X25519-AEAD-Ratchet
-- NTCP2 through SOCKS proxy
-- Throw error message if any port to bind is occupied
-- gzip parameter for UDP tunnels
-- Show ECIES-X25519-AEAD-Ratchet sessions and tags on the web console
-- Simplified implementation of gzip for no compression mode
-- Allow ECIES-X25519-AEAD-Ratchet session restart after 2 minutes
-- Added logrotate config for rpm package
-### Changed
-- Select peers for client tunnels among routers >= 0.9.36
-- Check ECIES flag for encrypted lookup reply
-- Streaming MTU size 1812 for ECIES-X25519-AEAD-Ratchet
-- Don't calculate checksum for Data message send through ECIES-X25519-AEAD-Ratchet
-- Catch network connectivity status for Windows
-- Stop as soon as no more transit tunnels during graceful shutdown for Android
-- RouterInfo gzip compression level depends on size
-- Send response to received datagram from ECIES-X25519-AEAD-Ratchet session
-- Update webconsole functional
-- Increased max transit tunnels limit
-- Reseeds list
-- Dropped windows support in cmake
-### Fixed
-- Correct timestamp check for LeaseSet2
-- Encrypted leaseset without authentication
-- Change SOCKS proxy connection response for clients without socks5h support (#1336)
-
-## [2.31.0] - 2020-04-10
-### Added
-- NTCP2 through HTTP proxy
-- Publish LeaseSet2 for I2CP destinations
-- Show status page on main activity for android
-- Handle ECIESFlag in DatabaseLookup at floodfill
-- C++17 features for eligible compilers
-### Changed
-- Droped Websockets and Lua support
-- Send DeliveryStatusMsg for LeaseSet for ECIES-X25519-AEAD-Ratchet
-- Keep sending new session reply until established for ECIES-X25519-AEAD-Ratchet
-- Updated SSU log messages
-- Reopen SSU socket on exception
-- Security hardening headers in web console
-- Various web console changes
-- Various QT changes
-### Fixed
-- NTCP2 socket descriptors leak
-- Race condition with router's identity in transport sessions
-- Not terminated streams remain forever
-
-## [2.30.0] - 2020-02-25
-### Added
-- Single threaded SAM
-- Experimental support of ECIES-X25519-AEAD-Ratchet crypto type
-### Changed
-- Minimal MTU size is 1280 for ipv6
-- Use unordered_map instead map for destination's sessions and tags list
-- Use std::shuffle instead std::random_shuffle
-- SAM is single threaded by default
-- Reseeds list
-### Fixed
-- Correct termination of streaming destination
-- Extra ',' in RouterInfo response in I2PControl
-- SAM crash on session termination
-- Storage for Android 10
-
-## [2.29.0] - 2019-10-21
-### Added
-- Client auth flag for b33 address
-### Changed
-- Remove incoming  NTCP2 session from pending list when established
-- Handle errors for NTCP2 SessionConfrimed send
-### Fixed
-- Failure to start on Windows XP
-- SAM crash if invalid lookup address
-- Possible crash when UPnP enabled on shutdown
-
-## [2.28.0] - 2019-08-27
-### Added
-- RAW datagrams in SAM
-- Publishing encrypted LeaseSet2 with DH or PSH authentication
-- Ability to disable battery optimization for Android
-- Transport Network ID Check
-### Changed
-- Set and handle published encrypted flag for LeaseSet2
-### Fixed
-- ReceiveID changes in the same stream
-- "\r\n" command terminator in SAM
-- Addressbook lines with signatures
-
-## [2.27.0] - 2019-07-03
-### Added
-- Support of PSK and DH authentication for encrypted LeaseSet2
-### Changed
-- Uptime is based on monotonic timer
-### Fixed
-- BOB status command response
-- Correct NTCP2 port if NTCP is disabled
-- Flood encrypted LeaseSet2 with store hash
-
-## [2.26.0] - 2019-06-07
-### Added
-- HTTP method "PROPFIND"
-- Detection of external ipv6 address through the SSU
-- NTCP2 publishing depends on network status
-### Changed
-- ntcp is disabled by default, ntcp2 is published by default
-- Response to BOB's "list" command
-- ipv6 address is not longer NTCP's local endpoint's address
-- Reseeds list
-- HTTP_REFERER stripping in httpproxy (#823)
-### Fixed
-- Check and handle incorrect BOB input
-- Ignore introducers for NTCP or NTCP2 addresses
-- RouterInfo check from NTCP2
-
-## [2.25.0] - 2019-05-09
-### Added
-- Create, publish and handle encrypted LeaseSet2
-- Support of b33 addresses
-- RedDSA key blinding
-- .b32.i2p addresses in jump links
-- ntcp2.addressv6 parameter
-### Changed
-- Allow HTTP headers without value
-- Set data directory from external storage path for Android
-- addresshelper support is configurable per tunnel
-- gradlew script for android build
-### Fixed
-- Deletion of expired encrypted LeaseSet2 on floodfills
-- ipv6 fallback address
-- SSU incoming packets routing
-
-## [2.24.0] - 2019-03-21
-### Added
-- Support of transient keys for LeaseSet2
-- Support of encrypted LeaseSet2
-- Recognize signature type 11 (RedDSA)
-- Support websocket connections over HTTP proxy
-- Ability to disable full addressbook persist
-### Changed
-- Don't load peer profiles if non-persistant
-- REUSE_ADDR for ipv6 acceptors
-- Reset eTags if addressbook can't be loaded
-### Fixed
-- Build with boost 1.70
-- Filter out unspecified addresses from RouterInfo
-- Check floodfill status change
-- Correct SAM response for invalid key
-- SAM crash on termination for Windows
-- Race condition for publishing
-
-## [2.23.0] - 2019-01-21
-### Added
-- Standard LeaseSet2 support
-- Ability to adjust timestamps through the NTP
-- Ability to disable peer profile persist
-- Request permission for android >= 6
-- Initial addressbook to android assets
-- Cancel graceful shutdown for android
-- Russian translation for android
-### Changed
-- Chacha20 and Poly1305 implementation
-- Eliminate extra copy of NTCP2 send buffers
-- Extract content of tunnel.d from assets on android
-- Removed name resolvers from transports
-- Update reseed certificates
-### Fixed
-- LeaseSet published content verification
-- Exclude invalid LeaseSets from the list on a floodfill
-- Build for OpenWrt with openssl 1.1.1
-
-## [2.22.0] - 2018-11-09
-### Added
-- Multiple tunnel config files from tunnels.d folder
-### Changed
-- Fetch own RouterInfo upon SessionRequest for NTCP2
-- Faster XOR between AES blocks for non AVX capable CPUs
-### Fixed
-- Fixed NTCP2 termination send
-
-## [2.21.1] - 2018-10-22
-### Changed
-- cost=13 for unpublished NTCP2 address
-### Fixed
-- Handle I2NP messages longer than 32K
-
-## [2.21.0] - 2018-10-04
-### Added
-- EdDSA, x25519 and SipHash from openssl 1.1.1
-- NTCP2 ipv6 incoming connections
-- Show total number of destination's outgoing tags in the web console
-### Changed
-- Android build with openssl 1.1.1/boost 1.64
-- Bandwidth classes 'P' and 'X' don't add 'O' anymore
-### Fixed
-- Update own RouterInfo if no SSU
-- Recognize 'P' and 'X' routers as high bandwidth without 'O'
-- NTCP address doesn't disappear if NTCP2 enabled
-- Android with api 26+
-
-## [2.20.0] - 2018-08-23
-### Added
-- Full implementation of NTCP2
-- Assets for android
-### Changed
-- armeabi-v7a and x86 in one apk for android
-- NTCP2 is enabled by default
-- Show lease's expiration time in readable format in the web console
-### Fixed
-- Correct names for transports in the web console
-
-## [2.19.0] - 2018-06-26
-### Added
-- ECIES support for RouterInfo
-- HTTP outproxy authorization
-- AVX/AESNI runtime detection
-- Initial implementation of NTCP2
-- I2CP session reconfigure
-- I2CP method ClientServicesInfo
-- Datagrams to websocks
-### Changed
-- RouterInfo uses EdDSA signature by default
-- Remove stream bans
-- Android build system changed to gradle
-- Multiple changes in QT GUI
-- Dockerfile
-### Fixed
-- zero tunnelID issue
-- tunnels reload
-- headers in webconsole
-- XSS in webconsole from SAM session name
-- build for gcc 8
-- cmake build scripts
-- systemd service files
-- some netbsd issues
-
-## [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 implementation 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 descriptors 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

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2020, The PurpleI2P Project
+Copyright (c) 2013-2015, The PurpleI2P Project
 
 All rights reserved.
 

Makefile

@@ -1,173 +0,0 @@
-SYS := $(shell $(CXX) -dumpmachine)
-
-ifneq (, $(findstring darwin, $(SYS)))
-	SHARED_SUFFIX = dylib
-else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
-	SHARED_SUFFIX = dll
-else
-	SHARED_SUFFIX = so
-endif
-
-SHLIB := libi2pd.$(SHARED_SUFFIX)
-ARLIB := libi2pd.a
-SHLIB_LANG := libi2pdlang.$(SHARED_SUFFIX)
-ARLIB_LANG := libi2pdlang.a
-SHLIB_CLIENT := libi2pdclient.$(SHARED_SUFFIX)
-ARLIB_CLIENT := libi2pdclient.a
-SHLIB_WRAP := libi2pdwrapper.$(SHARED_SUFFIX)
-ARLIB_WRAP := libi2pdwrapper.a
-I2PD := i2pd
-
-LIB_SRC_DIR := libi2pd
-LIB_CLIENT_SRC_DIR := libi2pd_client
-WRAP_SRC_DIR := libi2pd_wrapper
-LANG_SRC_DIR := i18n
-DAEMON_SRC_DIR := daemon
-
-# import source files lists
-include filelist.mk
-
-USE_AESNI	:= $(or $(USE_AESNI),yes)
-USE_STATIC	:= $(or $(USE_STATIC),no)
-USE_MESHNET	:= $(or $(USE_MESHNET),no)
-USE_UPNP	:= $(or $(USE_UPNP),no)
-DEBUG		:= $(or $(DEBUG),yes)
-
-ifeq ($(DEBUG),yes)
-	CXX_DEBUG = -g
-else
-	CXX_DEBUG = -Os
-	LD_DEBUG = -s
-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 linux, $(SYS))$(findstring gnu, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	include Makefile.linux
-else ifneq (, $(findstring freebsd, $(SYS))$(findstring openbsd, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	include Makefile.bsd
-else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
-	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32App.cpp Win32/Win32NetState.cpp
-	include Makefile.mingw
-else # not supported
-	$(error Not supported platform)
-endif
-
-ifeq ($(USE_MESHNET),yes)
-	NEEDED_CXXFLAGS += -DMESHNET
-endif
-
-NEEDED_CXXFLAGS += -MMD -MP -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR) -I$(LANG_SRC_DIR)
-
-LIB_OBJS        += $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
-LIB_CLIENT_OBJS += $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
-LANG_OBJS       += $(patsubst %.cpp,obj/%.o,$(LANG_SRC))
-DAEMON_OBJS     += $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
-WRAP_LIB_OBJS   += $(patsubst %.cpp,obj/%.o,$(WRAP_LIB_SRC))
-DEPS            += $(LIB_OBJS:.o=.d) $(LIB_CLIENT_OBJS:.o=.d) $(LANG_OBJS:.o=.d) $(DAEMON_OBJS:.o=.d) $(WRAP_LIB_OBJS:.o=.d)
-
-## Build all code (libi2pd, libi2pdclient, libi2pdlang), link it to .a and build binary
-all: $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG) $(I2PD)
-
-mk_obj_dir:
-	@mkdir -p obj/$(LIB_SRC_DIR)
-	@mkdir -p obj/$(LIB_CLIENT_SRC_DIR)
-	@mkdir -p obj/$(LANG_SRC_DIR)
-	@mkdir -p obj/$(DAEMON_SRC_DIR)
-	@mkdir -p obj/$(WRAP_SRC_DIR)
-	@mkdir -p obj/Win32
-
-api: $(SHLIB) $(ARLIB)
-client: $(SHLIB_CLIENT) $(ARLIB_CLIENT)
-lang:  $(SHLIB_LANG) $(ARLIB_LANG)
-api_client: api client lang
-wrapper: api_client $(SHLIB_WRAP) $(ARLIB_WRAP)
-
-## 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.
-
-obj/%.o: %.cpp | mk_obj_dir
-	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) $(INCFLAGS) -c -o $@ $<
-
-# '-' is 'ignore if missing' on first run
--include $(DEPS)
-
-$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG)
-	$(CXX) -o $@ $(LDFLAGS) $^ $(LDLIBS)
-
-$(SHLIB): $(LIB_OBJS) $(SHLIB_LANG)
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS) $(SHLIB_LANG)
-endif
-
-$(SHLIB_CLIENT): $(LIB_CLIENT_OBJS) $(SHLIB) $(SHLIB_LANG)
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS) $(SHLIB) $(SHLIB_LANG)
-endif
-
-$(SHLIB_WRAP): $(WRAP_LIB_OBJS)
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
-endif
-
-$(SHLIB_LANG): $(LANG_OBJS)
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
-endif
-
-$(ARLIB): $(LIB_OBJS)
-	$(AR) -r $@ $^
-
-$(ARLIB_CLIENT): $(LIB_CLIENT_OBJS)
-	$(AR) -r $@ $^
-
-$(ARLIB_WRAP): $(WRAP_LIB_OBJS)
-	$(AR) -r $@ $^
-
-$(ARLIB_LANG): $(LANG_OBJS)
-	$(AR) -r $@ $^
-
-clean:
-	$(RM) -r obj
-	$(RM) -r docs/generated
-	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT) $(SHLIB_LANG) $(ARLIB_LANG) $(SHLIB_WRAP) $(ARLIB_WRAP)
-
-strip: $(I2PD) $(SHLIB) $(SHLIB_CLIENT) $(SHLIB_LANG)
-	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: doxygen
-.PHONY: dist
-.PHONY: last-dist
-.PHONY: api
-.PHONY: api_client
-.PHONY: client
-.PHONY: lang
-.PHONY: mk_obj_dir
-.PHONY: install
-.PHONY: strip

Makefile.bsd

@@ -1,12 +0,0 @@
-CXX = clang++
-CXXFLAGS ?= ${CXX_DEBUG} -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 = ${LD_DEBUG} -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,51 +0,0 @@
-# root directory holding homebrew
-BREWROOT = /usr/local
-BOOSTROOT = ${BREWROOT}/opt/boost
-SSLROOT = ${BREWROOT}/opt/openssl@1.1
-UPNPROOT = ${BREWROOT}/opt/miniupnpc
-CXXFLAGS = ${CXX_DEBUG} -Wall -std=c++11 -DMAC_OSX -Wno-overloaded-virtual
-INCFLAGS = -I${SSLROOT}/include -I${BOOSTROOT}/include
-LDFLAGS = ${LD_DEBUG}
-
-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
-ifeq ($(USE_AESNI),yes)
-	CXXFLAGS += -D__AES__ -maes
-endif
-
-install: all
-	install -d ${PREFIX}/bin ${PREFIX}/etc/i2pd ${PREFIX}/share/doc/i2pd ${PREFIX}/share/i2pd ${PREFIX}/share/man/man1 ${PREFIX}/var/lib/i2pd
-	install -m 755 ${I2PD} ${PREFIX}/bin/
-	install -m 644 contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/etc/i2pd
-	@cp -R contrib/certificates ${PREFIX}/share/i2pd/
-	install -m 644 ChangeLog LICENSE README.md contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/share/doc/i2pd
-	@gzip debian/i2pd.1 && install debian/i2pd.1.gz ${PREFIX}/share/man/man1
-	@ln -sf ${PREFIX}/share/i2pd/certificates ${PREFIX}/var/lib/i2pd/
-	@ln -sf ${PREFIX}/etc/i2pd/i2pd.conf ${PREFIX}/var/lib/i2pd/i2pd.conf
-	@ln -sf ${PREFIX}/etc/i2pd/subscriptions.txt ${PREFIX}/var/lib/i2pd/subscriptions.txt
-	@ln -sf ${PREFIX}/etc/i2pd/tunnels.conf ${PREFIX}/var/lib/i2pd/tunnels.conf

Makefile.linux

@@ -1,64 +0,0 @@
-# set defaults instead redefine
-CXXFLAGS ?= ${CXX_DEBUG} -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-psabi
-LDFLAGS ?= ${LD_DEBUG}
-
-## 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 FDLAGS 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\.[8-9]"),3) # gcc 4.8 - 4.9
-	NEEDED_CXXFLAGS += -std=c++11 -D_GLIBCXX_USE_NANOSLEEP=1
-else ifeq ($(shell expr match ${CXXVER} "[5-6]"),1) # gcc 5 - 6
-	NEEDED_CXXFLAGS += -std=c++11
-	LDLIBS = -latomic
-else ifeq ($(shell expr match ${CXXVER} "[1,7-9]"),1) # gcc >= 7
-	NEEDED_CXXFLAGS += -std=c++17
-	LDLIBS = -latomic
-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/$(SYS)
-	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
-ifeq ($(USE_UPNP),yes)
-	LDLIBS += $(LIBDIR)/libminiupnpc.a
-endif
-	LDLIBS += -lpthread -ldl
-else
-	LDLIBS += -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
-ifeq ($(USE_UPNP),yes)
-	LDLIBS += -lminiupnpc
-endif
-endif
-
-# UPNP Support (miniupnpc 1.5 and higher)
-ifeq ($(USE_UPNP),yes)
-	NEEDED_CXXFLAGS += -DUSE_UPNP
-endif
-
-ifeq ($(USE_AESNI),yes)
-ifneq (, $(findstring i386, $(SYS))$(findstring i686, $(SYS))$(findstring x86_64, $(SYS))) # only x86-based CPU supports that
-	NEEDED_CXXFLAGS += -D__AES__ -maes
-endif
-endif

Makefile.mingw

@@ -1,65 +0,0 @@
-# Build application with GUI (tray, main window)
-USE_WIN32_APP := yes
-
-WINDRES = windres
-
-CXXFLAGS := $(CXX_DEBUG) -DWIN32_LEAN_AND_MEAN -fPIC -msse
-INCFLAGS = -I$(DAEMON_SRC_DIR) -IWin32
-LDFLAGS := ${LD_DEBUG} -static
-
-# detect proper flag for c++11 support by compilers
-CXXVER := $(shell $(CXX) -dumpversion)
-ifeq ($(shell expr match ${CXXVER} "[4]\.[7-9]\|4\.1[0-9]\|[5-6]"),4) # gcc 4.7 - 6
-	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "[1,7-9]"),1) # gcc >= 7
-	NEEDED_CXXFLAGS += -std=c++17
-else # not supported
-$(error Compiler too old)
-endif
-
-# Boost libraries suffix
-BOOST_SUFFIX = -mt
-
-# 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 \
-	-lole32 \
-	-luuid \
-	-lpthread
-
-ifeq ($(USE_WIN32_APP), yes)
-	NEEDED_CXXFLAGS += -DWIN32_APP
-	LDFLAGS += -mwindows
-	DAEMON_RC += Win32/Resource.rc
-	DAEMON_OBJS += $(patsubst %.rc,obj/%.o,$(DAEMON_RC))
-endif
-
-ifeq ($(USE_WINXP_FLAGS), yes)
-	NEEDED_CXXFLAGS += -DWINVER=0x0501 -D_WIN32_WINNT=0x0501
-endif
-
-ifeq ($(USE_AESNI),yes)
-	NEEDED_CXXFLAGS += -D__AES__ -maes
-endif
-
-ifeq ($(USE_ASLR),yes)
-	LDFLAGS += -Wl,--nxcompat -Wl,--high-entropy-va -Wl,--dynamicbase,--export-all-symbols
-endif
-
-obj/%.o : %.rc | mk_obj_dir
-	$(WINDRES) -i $< -o $@

Makefile.osx

@@ -1,29 +0,0 @@
-CXX = clang++
-CXXFLAGS := ${CXX_DEBUG} -Wall -std=c++11 -DMAC_OSX
-INCFLAGS = -I/usr/local/include
-LDFLAGS := -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-LDFLAGS += -Wl,-dead_strip
-LDFLAGS += -Wl,-dead_strip_dylibs
-LDFLAGS += -Wl,-bind_at_load
-
-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),yes)
-	CXXFLAGS += -D__AES__ -maes
-else
-	CXXFLAGS += -msse
-endif

README.md

@@ -1,114 +1,21 @@
-[![GitHub release](https://img.shields.io/github/release/PurpleI2P/i2pd.svg?label=latest%20release)](https://github.com/PurpleI2P/i2pd/releases/latest)
-[![Snapcraft release](https://snapcraft.io/i2pd/badge.svg)](https://snapcraft.io/i2pd)
-[![License](https://img.shields.io/github/license/PurpleI2P/i2pd.svg)](https://github.com/PurpleI2P/i2pd/blob/openssl/LICENSE)
-[![Packaging status](https://repology.org/badge/tiny-repos/i2pd.svg)](https://repology.org/project/i2pd/versions)
-[![Docker Pulls](https://img.shields.io/docker/pulls/purplei2p/i2pd)](https://hub.docker.com/r/purplei2p/i2pd)
-[![Crowdin](https://badges.crowdin.net/i2pd/localized.svg)](https://crowdin.com/project/i2pd)
-
-*note: i2pd for Android can be found in [i2pd-android](https://github.com/PurpleI2P/i2pd-android) repository and with Qt GUI in [i2pd-qt](https://github.com/PurpleI2P/i2pd-qt) repository*
-
 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.  
-
-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 packages and binaries.
-You can fetch most of them on [release](https://github.com/PurpleI2P/i2pd/releases/latest) page.  
-Please see [documentation](https://i2pd.readthedocs.io/en/latest/user-guide/install/) for more info.
-
-Building
---------
-See [documentation](https://i2pd.readthedocs.io/en/latest/) for how to build
-i2pd from source on your OS.  
-
-note: i2pd with Qt GUI can be found in [i2pd-qt](https://github.com/PurpleI2P/i2pd-qt) repository and for android in [i2pd-android](https://github.com/PurpleI2P/i2pd-android) repository.
-
-
-Build instructions:
-
-* [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 - [![Build on Ubuntu](https://github.com/PurpleI2P/i2pd/actions/workflows/build.yml/badge.svg)](https://github.com/PurpleI2P/i2pd/actions/workflows/build.yml)
-  * CentOS / Fedora / Mageia - [![Build Status](https://copr.fedorainfracloud.org/coprs/supervillain/i2pd/package/i2pd-git/status_image/last_build.png)](https://copr.fedorainfracloud.org/coprs/supervillain/i2pd/package/i2pd-git/)
-  * Alpine, ArchLinux, openSUSE, Gentoo, Debian, Ubuntu, etc.
-* Windows - [![Build on Windows](https://github.com/PurpleI2P/i2pd/actions/workflows/build-windows.yml/badge.svg)](https://github.com/PurpleI2P/i2pd/actions/workflows/build-windows.yml)
-* Mac OS X - [![Build on OSX](https://github.com/PurpleI2P/i2pd/actions/workflows/build-osx.yml/badge.svg)](https://github.com/PurpleI2P/i2pd/actions/workflows/build-osx.yml)
-* Docker image - [![Build Status](https://img.shields.io/docker/cloud/build/purplei2p/i2pd)](https://hub.docker.com/r/purplei2p/i2pd/builds/) [![Build containers](https://github.com/PurpleI2P/i2pd/actions/workflows/docker.yml/badge.svg)](https://github.com/PurpleI2P/i2pd/actions/workflows/docker.yml)
-* Snap - [![i2pd](https://snapcraft.io/i2pd/badge.svg)](https://snapcraft.io/i2pd) [![i2pd](https://snapcraft.io/i2pd/trending.svg?name=0)](https://snapcraft.io/i2pd)
-* FreeBSD - [![Build on FreeBSD](https://github.com/PurpleI2P/i2pd/actions/workflows/build-freebsd.yml/badge.svg)](https://github.com/PurpleI2P/i2pd/actions/workflows/build-freebsd.yml)
-* Android - [![Android CI](https://github.com/PurpleI2P/i2pd-android/actions/workflows/android.yml/badge.svg)](https://github.com/PurpleI2P/i2pd-android/actions/workflows/android.yml)
-* 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).
-
-Localization
+Downloads
 ------------
 
-You can help us with translation i2pd to your language using Crowdin platform!
-Translation project can be found [here](https://crowdin.com/project/i2pd).
+Official binary releases could be found at:
+http://download.i2p.io/purplei2p/i2pd/releases/
 
-New languages can be requested on project's [discussion page](https://crowdin.com/project/i2pd/discussions).
 
-Current status: [![Crowdin](https://badges.crowdin.net/i2pd/localized.svg)](https://crowdin.com/project/i2pd)
+Build Statuses
+---------------
 
-Donations
----------
-
-BTC: 3MDoGJW9TLMTCDGrR9bLgWXfm6sjmgy86f  
-LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59  
-ETH: 0x9e5bac70d20d1079ceaa111127f4fb3bccce379d  
-DASH: Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF  
-ZEC: t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ  
-GST: GbD2JSQHBHCKLa9WTHmigJRpyFgmBj4woG  
-XMR: 497pJc7X4xqKvcLBLpSUtRgWqMMyo24u4btCos3cak6gbMkpobgSU6492ztUcUBghyeHpYeczB55s38NpuHoH5WGNSPDRMH  
-
-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,89 +0,0 @@
-/*
-* Copyright (c) 2013-2020, The PurpleI2P Project
-*
-* This file is part of Purple i2pd project and licensed under BSD3
-*
-* See full license text in LICENSE file at top of project tree
-*/
-
-#include <thread>
-#include <clocale>
-#include "Config.h"
-#include "Daemon.h"
-#include "util.h"
-#include "Log.h"
-
-#ifdef _WIN32
-#ifdef WIN32_APP
-#include <windows.h>
-#include "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");
-		setlocale(LC_TIME, "C");
-
-		i2p::log::SetThrowFunction ([](const std::string& s)
-			{
-				MessageBox(0, TEXT(s.c_str ()), TEXT("i2pd"), MB_ICONERROR | MB_TASKMODAL | MB_OK );
-			}
-		);
-
-		if (!Daemon_Singleton::init(argc, argv))
-			return false;
-		return true;
-	}
-
-	bool DaemonWin32::start()
-	{
-		setlocale(LC_CTYPE, "");
-		SetConsoleCP(1251);
-		SetConsoleOutputCP(1251);
-		setlocale(LC_ALL, "Russian");
-		setlocale(LC_TIME, "C");
-#ifdef WIN32_APP
-		if (!i2p::win32::StartWin32App ()) return false;
-#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-2020, 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,483 +0,0 @@
-/*
-* Copyright (c) 2013-2020, The PurpleI2P Project
-*
-* This file is part of Purple i2pd project and licensed under BSD3
-*
-* See full license text in LICENSE file at top of project tree
-*/
-
-#include <stdio.h>
-#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 "Win32NetState.h"
-
-#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_ACCEPT_TRANSIT 2007
-#define ID_DECLINE_TRANSIT 2008
-
-#define ID_TRAY_ICON 2050
-#define WM_TRAYICON (WM_USER + 1)
-
-#define IDT_GRACEFUL_SHUTDOWN_TIMER 2100
-#define FRAME_UPDATE_TIMER 2101
-#define IDT_GRACEFUL_TUNNELCHECK_TIMER 2102
-
-namespace i2p
-{
-namespace win32
-{
-	DWORD g_GracefulShutdownEndtime = 0;
-
-	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);
-		if(!i2p::context.AcceptsTunnels())
-			InsertMenu (hPopup, -1,
-				i2p::util::DaemonWin32::Instance ().isGraceful ? MF_BYPOSITION | MF_STRING | MF_GRAYED : MF_BYPOSITION | MF_STRING,
-				ID_ACCEPT_TRANSIT, "Accept &transit");
-		else
-			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_DECLINE_TRANSIT, "Decline &transit");
-		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_RELOAD, "&Reload tunnels config");
-		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, bool notify = false)
-	{
-		NOTIFYICONDATA nid;
-		memset(&nid, 0, sizeof(nid));
-		nid.cbSize = sizeof(nid);
-		nid.hWnd = hWnd;
-		nid.uID = ID_TRAY_ICON;
-		nid.uFlags = notify ? NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO : NIF_ICON | NIF_MESSAGE | NIF_TIP;
-		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");
-		if (notify) 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;
-
-		if (gbytes)
-			s << gbytes << " GB, ";
-		if (mbytes)
-			s << mbytes << " MB, ";
-		if (kbytes)
-			s << kbytes << " KB, ";
-		s << bytes << " Bytes\n";
-	}
-
-	static void ShowNetworkStatus (std::stringstream& s, RouterStatus status)
-	{
-		switch (status)
-		{
-			case eRouterStatusOK: s << "OK"; break;
-			case eRouterStatusTesting: s << "Test"; break;
-			case eRouterStatusFirewalled: s << "FW"; break;
-			case eRouterStatusUnknown: s << "Unk"; break;
-			case eRouterStatusProxy: s << "Proxy"; break;
-			case eRouterStatusMesh: s << "Mesh"; break;
-			case eRouterStatusError:
-			{
-				s << "Err";
-				switch (i2p::context.GetError ())
-				{
-					case eRouterErrorClockSkew:
-						s << " - Clock skew";
-					break;
-					case eRouterErrorOffline:
-						s << " - Offline";
-					break;
-					case eRouterErrorSymmetricNAT:
-						s << " - Symmetric NAT";
-					break;
-					default: ;
-				}
-				break;
-			}
-			default: s << "Unk";
-		}
-	}
-
-	static void PrintMainWindowText (std::stringstream& s)
-	{
-		s << "\n";
-		s << "Status: ";
-		ShowNetworkStatus (s, i2p::context.GetStatus ());
-		if (i2p::context.SupportsV6 ())
-		{
-			s << " / ";
-			ShowNetworkStatus (s, i2p::context.GetStatusV6 ());
-		}
-		s << "; ";
-		s << "Success Rate: " << i2p::tunnel::tunnels.GetTunnelCreationSuccessRate() << "%\n";
-		s << "Uptime: "; ShowUptime(s, i2p::context.GetUptime ());
-		if (g_GracefulShutdownEndtime != 0)
-		{
-			DWORD GracefulTimeLeft = (g_GracefulShutdownEndtime - GetTickCount()) / 1000;
-			s << "Graceful shutdown, time left: "; ShowUptime(s, GracefulTimeLeft);
-		}
-		else
-			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)
-	{
-		static UINT s_uTaskbarRestart;
-
-		switch (uMsg)
-		{
-			case WM_CREATE:
-			{
-				s_uTaskbarRestart = RegisterWindowMessage(TEXT("TaskbarCreated"));
-				AddTrayIcon (hWnd, true);
-				break;
-			}
-			case WM_CLOSE:
-			{
-				RemoveTrayIcon (hWnd);
-				KillTimer (hWnd, FRAME_UPDATE_TIMER);
-				KillTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER);
-				KillTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_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_ACCEPT_TRANSIT:
-					{
-						i2p::context.SetAcceptsTunnels (true);
-						std::stringstream text;
-						text << "I2Pd now accept transit tunnels";
-						MessageBox( hWnd, TEXT(text.str ().c_str ()), TEXT("i2pd"), MB_ICONINFORMATION | MB_OK );
-						return 0;
-					}
-					case ID_DECLINE_TRANSIT:
-					{
-						i2p::context.SetAcceptsTunnels (false);
-						std::stringstream text;
-						text << "I2Pd now decline new transit tunnels";
-						MessageBox( hWnd, TEXT(text.str ().c_str ()), TEXT("i2pd"), MB_ICONINFORMATION | MB_OK );
-						return 0;
-					}
-					case ID_GRACEFUL_SHUTDOWN:
-					{
-						i2p::context.SetAcceptsTunnels (false);
-						SetTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER, 10*60*1000, nullptr); // 10 minutes
-						SetTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_TIMER, 1000, nullptr); // check tunnels every second
-						g_GracefulShutdownEndtime = GetTickCount() + 10*60*1000;
-						i2p::util::DaemonWin32::Instance ().isGraceful = true;
-						return 0;
-					}
-					case ID_STOP_GRACEFUL_SHUTDOWN:
-					{
-						i2p::context.SetAcceptsTunnels (true);
-						KillTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER);
-						KillTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_TIMER);
-						g_GracefulShutdownEndtime = 0;
-						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:
-			{
-				switch(wParam)
-				{
-					case IDT_GRACEFUL_SHUTDOWN_TIMER:
-					{
-						g_GracefulShutdownEndtime = 0;
-						PostMessage (hWnd, WM_CLOSE, 0, 0); // exit
-						return 0;
-					}
-					case IDT_GRACEFUL_TUNNELCHECK_TIMER:
-					{
-						if (i2p::tunnel::tunnels.CountTransitTunnels() == 0)
-							PostMessage (hWnd, WM_CLOSE, 0, 0);
-						else
-							SetTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_TIMER, 1000, nullptr);
-						return 0;
-					}
-					case FRAME_UPDATE_TIMER:
-					{
-						InvalidateRect(hWnd, NULL, TRUE);
-						return 0;
-					}
-				}
-				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;
-			}
-			default:
-			{
-				if (uMsg == s_uTaskbarRestart)
-					AddTrayIcon (hWnd, false);
-				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;
-		}
-		SubscribeToEvents();
-		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);
-		// UnSubscribeFromEvents(); // TODO: understand why unsubscribing crashes app
-		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,27 +0,0 @@
-/*
-* Copyright (c) 2013-2020, The PurpleI2P Project
-*
-* This file is part of Purple i2pd project and licensed under BSD3
-*
-* See full license text in LICENSE file at top of project tree
-*/
-
-#ifndef WIN32APP_H__
-#define WIN32APP_H__
-
-#define I2PD_WIN32_CLASSNAME "i2pd main window"
-
-namespace i2p
-{
-namespace win32
-{
-	extern DWORD g_GracefulShutdownEndtime;
-
-	bool StartWin32App ();
-	void StopWin32App ();
-	int RunWin32App ();
-	bool GracefulShutdown ();
-	bool StopGracefulShutdown ();
-}
-}
-#endif // WIN32APP_H__

Win32/Win32NetState.cpp

@@ -1,86 +0,0 @@
-/*
-* Copyright (c) 2013-2020, The PurpleI2P Project
-*
-* This file is part of Purple i2pd project and licensed under BSD3
-*
-* See full license text in LICENSE file at top of project tree
-*/
-
-#if WINVER != 0x0501 // supported since Vista
-#include "Win32NetState.h"
-#include <windows.h>
-#include "Log.h"
-
-IUnknown *pUnknown = nullptr;
-INetworkListManager *pNetworkListManager = nullptr;
-IConnectionPointContainer *pCPContainer = nullptr;
-IConnectionPoint *pConnectPoint = nullptr;
-DWORD Cookie = 0;
-
-void SubscribeToEvents()
-{
-	LogPrint(eLogInfo, "NetState: Trying to subscribe to NetworkListManagerEvents");
-	CoInitialize(NULL);
-
-	HRESULT Result = CoCreateInstance(CLSID_NetworkListManager, NULL, CLSCTX_ALL, IID_IUnknown, (void **)&pUnknown);
-	if (SUCCEEDED(Result))
-	{
-		Result = pUnknown->QueryInterface(IID_INetworkListManager, (void **)&pNetworkListManager);
-		if (SUCCEEDED(Result))
-		{
-			VARIANT_BOOL IsConnect = VARIANT_FALSE;
-			Result = pNetworkListManager->IsConnectedToInternet(&IsConnect);
-			if (SUCCEEDED(Result)) {
-				i2p::transport::transports.SetOnline (true);
-				LogPrint(eLogInfo, "NetState: current state: ", IsConnect == VARIANT_TRUE ? "connected" : "disconnected");
-			}
-
-			Result = pNetworkListManager->QueryInterface(IID_IConnectionPointContainer, (void **)&pCPContainer);
-			if (SUCCEEDED(Result))
-			{
-				Result = pCPContainer->FindConnectionPoint(IID_INetworkListManagerEvents, &pConnectPoint);
-				if(SUCCEEDED(Result))
-				{
-					CNetworkListManagerEvent *NetEvent = new CNetworkListManagerEvent;
-					Result = pConnectPoint->Advise((IUnknown *)NetEvent, &Cookie);
-					if (SUCCEEDED(Result))
-						LogPrint(eLogInfo, "NetState: Successfully subscribed to NetworkListManagerEvent messages");
-					else
-						LogPrint(eLogError, "NetState: Unable to subscribe to NetworkListManagerEvent messages");
-				} else
-					LogPrint(eLogError, "NetState: Unable to find interface connection point");
-			} else
-				LogPrint(eLogError, "NetState: Unable to query NetworkListManager interface");
-		} else
-			LogPrint(eLogError, "NetState: Unable to query global interface");
-	} else
-		LogPrint(eLogError, "NetState: Unable to create INetworkListManager interface");
-}
-
-void UnSubscribeFromEvents()
-{
-	try
-	{
-		if (pConnectPoint) {
-			pConnectPoint->Unadvise(Cookie);
-			pConnectPoint->Release();
-		}
-
-		if (pCPContainer)
-			pCPContainer->Release();
-
-		if (pNetworkListManager)
-			pNetworkListManager->Release();
-
-		if (pUnknown)
-			pUnknown->Release();
-
-		CoUninitialize();
-	}
-	catch (std::exception& ex)
-	{
-		LogPrint (eLogError, "NetState: received exception: ", ex.what ());
-	}
-}
-
-#endif // WINVER

Win32/Win32NetState.h

@@ -1,94 +0,0 @@
-/*
-* Copyright (c) 2013-2020, The PurpleI2P Project
-*
-* This file is part of Purple i2pd project and licensed under BSD3
-*
-* See full license text in LICENSE file at top of project tree
-*/
-
-#ifndef WIN_32_NETSTATE_H__
-#define WIN_32_NETSTATE_H__
-
-#if WINVER != 0x0501 // supported since Vista
-#include <netlistmgr.h>
-#include <ocidl.h>
-#include "Log.h"
-#include "Transports.h"
-
-class CNetworkListManagerEvent : public INetworkListManagerEvents
-{
-public:
-	CNetworkListManagerEvent() : m_ref(1) { }
-	~CNetworkListManagerEvent() { }
-
-	HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
-	{
-		HRESULT Result = S_OK;
-		if (IsEqualIID(riid, IID_IUnknown)) {
-			*ppvObject = (IUnknown *)this;
-		} else if (IsEqualIID(riid ,IID_INetworkListManagerEvents)) {
-			*ppvObject = (INetworkListManagerEvents *)this;
-		} else {
-			Result = E_NOINTERFACE;
-		}
-		AddRef();
-		
-		return Result;
-	}
-
-	ULONG STDMETHODCALLTYPE AddRef()
-	{
-		return (ULONG)InterlockedIncrement(&m_ref);
-	}
-
-	ULONG STDMETHODCALLTYPE Release()
-	{
-		LONG Result = InterlockedDecrement(&m_ref);
-		if (Result == 0)
-			delete this;
-		return (ULONG)Result;
-	}
-
-	virtual HRESULT STDMETHODCALLTYPE ConnectivityChanged(NLM_CONNECTIVITY newConnectivity)
-	{
-		if (newConnectivity == NLM_CONNECTIVITY_DISCONNECTED) {
-			i2p::transport::transports.SetOnline (false);
-			LogPrint(eLogInfo, "NetState: disconnected from network");
-		}
-
-		if (((int)newConnectivity & (int)NLM_CONNECTIVITY_IPV4_INTERNET) != 0) {
-			i2p::transport::transports.SetOnline (true);
-			LogPrint(eLogInfo, "NetState: connected to internet with IPv4 capability");
-		}
-
-		if (((int)newConnectivity & (int)NLM_CONNECTIVITY_IPV6_INTERNET) != 0) {
-			i2p::transport::transports.SetOnline (true);
-			LogPrint(eLogInfo, "NetState: connected to internet with IPv6 capability");
-		}
-
-		if (
-			(((int)newConnectivity & (int)NLM_CONNECTIVITY_IPV4_INTERNET) == 0) &&
-			(((int)newConnectivity & (int)NLM_CONNECTIVITY_IPV6_INTERNET) == 0)
-		) {
-			i2p::transport::transports.SetOnline (false);
-			LogPrint(eLogInfo, "NetState: connected without internet access");
-		}
-
-		return S_OK;
-	}
-
-private:
-
-	LONG m_ref;
-};
-
-void SubscribeToEvents();
-void UnSubscribeFromEvents();
-
-#else // WINVER == 0x0501
-
-void SubscribeToEvents() { }
-void UnSubscribeFromEvents() { }
-
-#endif // WINVER
-#endif

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

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,15 +0,0 @@
-# Various generated files
-/CMakeFiles/
-/i2pd
-/libi2pd.a
-/libi2pdclient.a
-/libi2pdlang.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,314 +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)
-
-# Win32 build with cmake is not supported
-if(WIN32 OR MSVC OR MSYS OR MINGW)
-  message(SEND_ERROR "cmake build for windows is not supported. Please use MSYS2 with makefiles in project root.")
-endif()
-
-# configurable options
-option(WITH_AESNI           "Use AES-NI instructions set"             ON)
-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_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)
-
-# paths
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
-set(CMAKE_SOURCE_DIR "..")
-
-#Handle paths nicely
-include(GNUInstallDirs)
-
-# architecture
-include(TargetArch)
-target_architecture(ARCHITECTURE)
-
-set(LIBI2PD_SRC_DIR ../libi2pd)
-set(LIBI2PD_CLIENT_SRC_DIR ../libi2pd_client)
-set(LANG_SRC_DIR ../i18n)
-set(DAEMON_SRC_DIR ../daemon)
-
-include_directories(${LIBI2PD_SRC_DIR})
-include_directories(${LIBI2PD_CLIENT_SRC_DIR})
-include_directories(${LANG_SRC_DIR})
-include_directories(${DAEMON_SRC_DIR})
-
-FILE(GLOB LIBI2PD_SRC ${LIBI2PD_SRC_DIR}/*.cpp)
-add_library(libi2pd ${LIBI2PD_SRC})
-set_target_properties(libi2pd PROPERTIES PREFIX "")
-
-if(WITH_LIBRARY)
-  install(TARGETS libi2pd
-    EXPORT libi2pd
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    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})
-endif()
-
-FILE(GLOB CLIENT_SRC ${LIBI2PD_CLIENT_SRC_DIR}/*.cpp)
-add_library(libi2pdclient ${CLIENT_SRC})
-set_target_properties(libi2pdclient PROPERTIES PREFIX "")
-
-if(WITH_LIBRARY)
-  install(TARGETS libi2pdclient
-    EXPORT libi2pdclient
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    COMPONENT Libraries)
-endif()
-
-FILE(GLOB LANG_SRC ${LANG_SRC_DIR}/*.cpp)
-add_library(libi2pdlang ${LANG_SRC})
-set_target_properties(libi2pdlang PROPERTIES PREFIX "")
-
-if(WITH_LIBRARY)
-  install(TARGETS libi2pdlang
-    EXPORT libi2pdlang
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    COMPONENT Libraries)
-endif()
-
-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)
-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
-
-# check for c++17 & c++11 support
-include(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++17" CXX17_SUPPORTED)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11_SUPPORTED)
-if(CXX17_SUPPORTED)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-elseif(CXX11_SUPPORTED)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-else()
-  message(SEND_ERROR "C++17 nor C++11 standard 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(LINUX)
-    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -stdlib=libstdc++") # required for <atomic>
-    list(APPEND CMAKE_REQUIRED_LIBRARIES "stdc++") # required to link with -stdlib=libstdc++
-  endif()
-  if(NOT APPLE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-const-variable -Wno-overloaded-virtual -Wno-c99-extensions")
-  endif()
-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()
-endif()
-
-# Note: AES-NI and AVX is available on x86-based CPU's.
-# Here also ARM64 implementation, but currently we don't support it.
-if(WITH_AESNI AND (ARCHITECTURE MATCHES "x86_64" OR ARCHITECTURE MATCHES "i386"))
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
-  add_definitions(-D__AES__)
-endif()
-
-if(WITH_ADDRSANITIZER)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-endif()
-
-if(WITH_THREADSANITIZER)
-  if(WITH_ADDRSANITIZER)
-    message(FATAL_ERROR "thread sanitizer option cannot be combined with address sanitizer")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread")
-  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)
-  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()
-  # 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")
-  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")
-  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(libi2pdclient PRIVATE -include libi2pd/stdafx.h)
-  target_compile_options(libi2pdlang PRIVATE -include libi2pd/stdafx.h)
-  target_link_libraries(libi2pd stdafx)
-endif()
-
-target_link_libraries(libi2pdclient libi2pd libi2pdlang)
-
-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 below 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!")
-endif()
-
-if(WITH_UPNP)
-  find_package(MiniUPnPc REQUIRED)
-  if(NOT MINIUPNPC_FOUND)
-    message(SEND_ERROR "Could not find MiniUPnPc. Please download and install it first!")
-  else()
-    include_directories(SYSTEM ${MINIUPNPC_INCLUDE_DIR})
-  endif()
-endif()
-
-find_package(ZLIB)
-if(ZLIB_FOUND)
-  link_directories(${ZLIB_ROOT}/lib)
-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()
-
-if(NOT MSYS)
-  include(CheckAtomic)
-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 "Architecture       : ${ARCHITECTURE}")
-message(STATUS "Install prefix:    : ${CMAKE_INSTALL_PREFIX}")
-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 "  PCH              : ${WITH_PCH}")
-message(STATUS "  MESHNET          : ${WITH_MESHNET}")
-message(STATUS "  ADDRSANITIZER    : ${WITH_ADDRSANITIZER}")
-message(STATUS "  THREADSANITIZER  : ${WITH_THREADSANITIZER}")
-message(STATUS "---------------------------------------")
-
-if(WITH_BINARY)
-  add_executable("${PROJECT_NAME}" ${DAEMON_SRC})
-
-  if(WITH_STATIC)
-    set_target_properties("${PROJECT_NAME}" PROPERTIES LINK_FLAGS "-static")
-  endif()
-
-  if(WITH_PCH)
-    target_compile_options("${PROJECT_NAME}" PRIVATE -include libi2pd/stdafx.h)
-  endif()
-
-  if(WITH_HARDENING AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set_target_properties("${PROJECT_NAME}" PROPERTIES LINK_FLAGS "-z relro -z now")
-  endif()
-
-  if(WITH_UPNP)
-    set(UPNP_LIB ${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(WITH_STATIC)
-    set(DL_LIB ${CMAKE_DL_LIBS})
-  endif()
-
-  target_link_libraries(libi2pd ${Boost_LIBRARIES} ${ZLIB_LIBRARY})
-  target_link_libraries("${PROJECT_NAME}" libi2pd libi2pdclient libi2pdlang ${DL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${UPNP_LIB} ${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")
-endif()

build/build_mingw.cmd

@@ -1,86 +0,0 @@
-@echo off
-setlocal enableextensions enabledelayedexpansion
-title Building i2pd
-
-REM Copyright (c) 2013-2020, 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
-REM set MSYSTEM=MSYS
-set MSYSTEM=MINGW32
-
-set "xSH=%WD%bash -lc"
-
-set "FILELIST=i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates contrib/tunnels.d"
-
-REM detecting number of processors
-set /a threads=%NUMBER_OF_PROCESSORS%
-
-REM we must work in root of repo
-cd ..
-
-REM deleting old log files
-del /S build_*.log >> nul 2>&1
-
-echo Receiving latest commit and cleaning up...
-%xSH% "git checkout contrib/* && git pull && make clean" > build\build.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 converting configuration files to DOS format (usable in default notepad)
-%xSH% "unix2dos contrib/i2pd.conf contrib/tunnels.conf contrib/tunnels.d/*" >> build\build.log 2>&1
-
-REM starting building
-set MSYSTEM=MINGW32
-set bitness=32
-call :BUILDING
-
-set MSYSTEM=MINGW64
-set bitness=64
-call :BUILDING
-
-REM building for WinXP
-set "WD=C:\msys64-xp\usr\bin\"
-set MSYSTEM=MINGW32
-set bitness=32
-set "xSH=%WD%bash -lc"
-call :BUILDING_XP
-echo.
-
-REM compile installer
-C:\PROGRA~2\INNOSE~1\ISCC.exe /dI2Pd_TextVer="%tag%" /dI2Pd_Ver="%tag%.0" build\win_installer.iss >> build\build.log 2>&1
-
-del README.txt i2pd_x32.exe i2pd_x64.exe i2pd_xp.exe >> nul
-
-echo Build complete...
-pause
-exit /b 0
-
-:BUILDING
-%xSH% "make clean" >> nul
-echo Building i2pd %tag% for win%bitness%
-%xSH% "make DEBUG=no USE_UPNP=yes -j%threads% && cp i2pd.exe i2pd_x%bitness%.exe && zip -r9 build/i2pd_%tag%_win%bitness%_mingw.zip %FILELIST% && make clean" > build\build_win%bitness%_%tag%.log 2>&1
-goto EOF
-
-:BUILDING_XP
-%xSH% "make clean" >> nul
-echo Building i2pd %tag% for winxp
-%xSH% "make DEBUG=no USE_UPNP=yes USE_WINXP_FLAGS=yes -j%threads% && cp i2pd.exe i2pd_xp.exe && zip -r9 build/i2pd_%tag%_winxp_mingw.zip %FILELIST% && make clean" > build\build_winxp_%tag%.log 2>&1
-
-:EOF

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/win_installer.iss

@@ -1,56 +0,0 @@
-#define I2Pd_AppName "i2pd"
-#define I2Pd_Publisher "PurpleI2P"
-; Get application version from compiled binary
-; Disabled to use definition from command line
-;#define I2Pd_ver GetFileVersionString(AddBackslash(SourcePath) + "..\i2pd_x64.exe")
-
-[Setup]
-AppName={#I2Pd_AppName}
-AppVersion={#I2Pd_TextVer}
-AppPublisher={#I2Pd_Publisher}
-
-DefaultDirName={pf}\I2Pd
-DefaultGroupName=I2Pd
-UninstallDisplayIcon={app}\I2Pd.exe
-OutputDir=.
-OutputBaseFilename=setup_{#I2Pd_AppName}_v{#I2Pd_TextVer}
-
-LicenseFile=..\LICENSE
-SetupIconFile=..\Win32\mask.ico
-
-InternalCompressLevel=ultra64
-Compression=lzma/ultra64
-SolidCompression=true
-
-ArchitecturesInstallIn64BitMode=x64
-ExtraDiskSpaceRequired=15
-
-AppID={{621A23E0-3CF4-4BD6-97BC-4835EA5206A2}
-AppVerName={#I2Pd_AppName}
-AppCopyright=Copyright (c) 2013-2020, The PurpleI2P Project
-AppPublisherURL=http://i2pd.website/
-AppSupportURL=https://github.com/PurpleI2P/i2pd/issues
-AppUpdatesURL=https://github.com/PurpleI2P/i2pd/releases
-
-VersionInfoProductVersion={#I2Pd_Ver}
-VersionInfoVersion={#I2Pd_Ver}
-
-CloseApplications=yes
-
-[Files]
-Source: ..\i2pd_x32.exe; DestDir: {app}; DestName: i2pd.exe; Flags: ignoreversion; Check: not IsWin64; MinVersion: 6.0
-Source: ..\i2pd_x64.exe; DestDir: {app}; DestName: i2pd.exe; Flags: ignoreversion; Check: IsWin64; MinVersion: 6.0
-Source: ..\i2pd_xp.exe; DestDir: {app}; DestName: i2pd.exe; Flags: ignoreversion; Check: IsWin64; OnlyBelowVersion: 6.0
-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
-Source: ..\contrib\tunnels.d\*; DestDir: {userappdata}\i2pd\tunnels.d; Flags: onlyifdoesntexist recursesubdirs createallsubdirs
-
-[Icons]
-Name: {group}\I2Pd; Filename: {app}\i2pd.exe
-Name: {group}\Readme; Filename: {app}\Readme.txt
-
-[UninstallDelete]
-Type: filesandordirs; Name: {app}

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

@@ -0,0 +1,462 @@
+#ifdef _WIN32
+#define _CRT_SECURE_NO_WARNINGS // to use freopen
+#endif
+
+#include "Win32Service.h"
+#include <assert.h>
+#include <strsafe.h>
+#include <windows.h>
+
+#include "Daemon.h"
+#include "util/Log.h"
+
+I2PService *I2PService::s_service = NULL;
+
+BOOL I2PService::isService()
+{
+	BOOL bIsService = FALSE;
+
+	HWINSTA hWinStation = GetProcessWindowStation();
+	if (hWinStation != NULL)
+	{
+		USEROBJECTFLAGS uof = { 0 };
+		if (GetUserObjectInformation(hWinStation, UOI_FLAGS, &uof, sizeof(USEROBJECTFLAGS), NULL) && ((uof.dwFlags & WSF_VISIBLE) == 0))
+		{
+			bIsService = TRUE;
+		}
+	}
+	return bIsService;
+}
+
+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);
+}
+
+
+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;
+	}
+}
+
+
+I2PService::I2PService(PSTR pszServiceName,
+	BOOL fCanStop,
+	BOOL fCanShutdown,
+	BOOL fCanPauseContinue)
+{
+	m_name = (pszServiceName == NULL) ? "" : pszServiceName;
+
+	m_statusHandle = NULL;
+
+	m_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+
+	m_status.dwCurrentState = SERVICE_START_PENDING;
+
+	DWORD dwControlsAccepted = 0;
+	if (fCanStop)
+		dwControlsAccepted |= SERVICE_ACCEPT_STOP;
+	if (fCanShutdown)
+		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 
+	// the stopped signal of the service.
+	m_hStoppedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (m_hStoppedEvent == NULL)
+	{
+		throw GetLastError();
+	}
+}
+
+
+I2PService::~I2PService(void)
+{
+	if (m_hStoppedEvent)
+	{
+		CloseHandle(m_hStoppedEvent);
+		m_hStoppedEvent = NULL;
+	}
+}
+
+
+void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
+{
+	try
+	{
+		SetServiceStatus(SERVICE_START_PENDING);
+
+		OnStart(dwArgc, pszArgv);
+
+		SetServiceStatus(SERVICE_RUNNING);
+	}
+	catch (DWORD dwError)
+	{
+		LogPrint("Win32Service Start", dwError);
+
+		SetServiceStatus(SERVICE_STOPPED, dwError);
+	}
+	catch (...)
+	{
+		LogPrint("Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
+
+		SetServiceStatus(SERVICE_STOPPED);
+	}
+}
+
+
+void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
+{
+	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.
+	}
+
+	// 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("Win32Service Stop", dwError);
+
+		SetServiceStatus(dwOriginalState);
+	}
+	catch (...)
+	{
+		LogPrint("Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
+
+		SetServiceStatus(dwOriginalState);
+	}
+}
+
+
+void I2PService::OnStop()
+{
+	// Log a service stop message to the Application log.
+	LogPrint("Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
+
+	Daemon.stop();
+
+	m_fStopping = TRUE;
+	if (WaitForSingleObject(m_hStoppedEvent, INFINITE) != WAIT_OBJECT_0)
+	{
+		throw GetLastError();
+	}
+	_worker->join();
+	delete _worker;
+}
+
+
+void I2PService::Pause()
+{
+	try
+	{
+		SetServiceStatus(SERVICE_PAUSE_PENDING);
+
+		OnPause();
+
+		SetServiceStatus(SERVICE_PAUSED);
+	}
+	catch (DWORD dwError)
+	{
+		LogPrint("Win32Service Pause", dwError);
+
+		SetServiceStatus(SERVICE_RUNNING);
+	}
+	catch (...)
+	{
+		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("Win32Service Continue", dwError);
+
+		SetServiceStatus(SERVICE_PAUSED);
+	}
+	catch (...)
+	{
+		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("Win32Service Shutdown", dwError);
+	}
+	catch (...)
+	{
+		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)) ?
+		0 : dwCheckPoint++;
+
+	::SetServiceStatus(m_statusHandle, &m_status);
+}
+
+//*****************************************************************************
+
+void FreeHandles(SC_HANDLE schSCManager, SC_HANDLE schService)
+{
+	if (schSCManager)
+	{
+		CloseServiceHandle(schSCManager);
+		schSCManager = NULL;
+	}
+	if (schService)
+	{
+		CloseServiceHandle(schService);
+		schService = NULL;
+	}
+}
+
+void InstallService(PSTR pszServiceName,
+	PSTR pszDisplayName,
+	DWORD dwStartType,
+	PSTR pszDependencies,
+	PSTR pszAccount,
+	PSTR pszPassword)
+{
+	printf("Try to install Win32Service (%s).\n", pszServiceName);
+
+	char szPath[MAX_PATH];
+	SC_HANDLE schSCManager = NULL;
+	SC_HANDLE schService = NULL;
+
+	if (GetModuleFileName(NULL, szPath, ARRAYSIZE(szPath)) == 0)
+	{
+		printf("GetModuleFileName failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	// Open the local default service control manager database
+	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT |
+		SC_MANAGER_CREATE_SERVICE);
+	if (schSCManager == NULL)
+	{
+		printf("OpenSCManager failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	// Install the service into SCM by calling CreateService
+	schService = CreateService(
+		schSCManager,                   // SCManager database
+		pszServiceName,                 // Name of service
+		pszDisplayName,                 // Name to display
+		SERVICE_QUERY_STATUS,           // Desired access
+		SERVICE_WIN32_OWN_PROCESS,      // Service type
+		dwStartType,                    // Service start type
+		SERVICE_ERROR_NORMAL,           // Error control type
+		szPath,                         // Service's binary
+		NULL,                           // No load ordering group
+		NULL,                           // No tag identifier
+		pszDependencies,                // Dependencies
+		pszAccount,                     // Service running account
+		pszPassword                     // Password of the account
+		);
+	if (schService == NULL)
+	{
+		printf("CreateService failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	printf("Win32Service is installed as %s.\n", pszServiceName);
+
+	// Centralized cleanup for all allocated resources.
+	FreeHandles(schSCManager, schService);
+}
+
+void UninstallService(PSTR pszServiceName)
+{
+	printf("Try to uninstall Win32Service (%s).\n", pszServiceName);
+
+	SC_HANDLE schSCManager = NULL;
+	SC_HANDLE schService = NULL;
+	SERVICE_STATUS ssSvcStatus = {};
+
+	// Open the local default service control manager database
+	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
+	if (schSCManager == NULL)
+	{
+		printf("OpenSCManager failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	// Open the service with delete, stop, and query status permissions
+	schService = OpenService(schSCManager, pszServiceName, SERVICE_STOP |
+		SERVICE_QUERY_STATUS | DELETE);
+	if (schService == NULL)
+	{
+		printf("OpenService failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	// Try to stop the service
+	if (ControlService(schService, SERVICE_CONTROL_STOP, &ssSvcStatus))
+	{
+		printf("Stopping %s.\n", pszServiceName);
+		Sleep(1000);
+
+		while (QueryServiceStatus(schService, &ssSvcStatus))
+		{
+			if (ssSvcStatus.dwCurrentState == SERVICE_STOP_PENDING)
+			{
+				printf(".");
+				Sleep(1000);
+			}
+			else break;
+		}
+
+		if (ssSvcStatus.dwCurrentState == SERVICE_STOPPED)
+		{
+			printf("\n%s is stopped.\n", pszServiceName);
+		}
+		else
+		{
+			printf("\n%s failed to stop.\n", pszServiceName);
+		}
+	}
+
+	// Now remove the service by calling DeleteService.
+	if (!DeleteService(schService))
+	{
+		printf("DeleteService failed w/err 0x%08lx\n", GetLastError());
+		FreeHandles(schSCManager, schService);
+		return;
+	}
+
+	printf("%s is removed.\n", pszServiceName);
+
+	// Centralized cleanup for all allocated resources.
+	FreeHandles(schSCManager, schService);
+}

client/Win32Service.h

@@ -0,0 +1,85 @@
+#ifndef WIN_32_SERVICE_H__
+#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             "i2pService"
+
+// Displayed name of the service
+#define SERVICE_DISPLAY_NAME     "i2p router service"
+
+// Service start options.
+#define SERVICE_START_TYPE       SERVICE_DEMAND_START
+
+// List of service dependencies - "dep1\0dep2\0\0"
+#define SERVICE_DEPENDENCIES     ""
+
+// The name of the account under which the service should run
+#define SERVICE_ACCOUNT          "NT AUTHORITY\\LocalService"
+
+// The password to the service account name
+#define SERVICE_PASSWORD         NULL
+#endif
+
+
+class I2PService
+{
+public:
+
+	I2PService(PSTR pszServiceName,
+		BOOL fCanStop = TRUE,
+		BOOL fCanShutdown = TRUE,
+		BOOL fCanPauseContinue = FALSE);
+
+	virtual ~I2PService(void);
+
+	static BOOL isService();
+	static BOOL Run(I2PService &service);
+	void Stop();
+
+protected:
+
+	virtual void OnStart(DWORD dwArgc, PSTR *pszArgv);
+	virtual void OnStop();
+	virtual void OnPause();
+	virtual void OnContinue();
+	virtual void OnShutdown();
+	void SetServiceStatus(DWORD dwCurrentState,
+		DWORD dwWin32ExitCode = NO_ERROR,
+		DWORD dwWaitHint = 0);
+
+private:
+
+	static void WINAPI ServiceMain(DWORD dwArgc, LPSTR *lpszArgv);
+	static void WINAPI ServiceCtrlHandler(DWORD dwCtrl);
+	void WorkerThread();
+	void Start(DWORD dwArgc, PSTR *pszArgv);
+	void Pause();
+	void Continue();
+	void Shutdown();
+	static I2PService* s_service;
+	PSTR m_name;
+	SERVICE_STATUS m_status;
+	SERVICE_STATUS_HANDLE m_statusHandle;
+
+	BOOL m_fStopping;
+	HANDLE m_hStoppedEvent;
+
+	std::thread* _worker;
+};
+
+void InstallService(PSTR pszServiceName,
+	PSTR pszDisplayName,
+	DWORD dwStartType,
+	PSTR pszDependencies,
+	PSTR pszAccount,
+	PSTR pszPassword);
+
+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/android_binary_only/.gitignore

@@ -1,18 +0,0 @@
-gen
-tests
-bin
-libs
-log*
-obj
-.gradle
-.idea
-.externalNativeBuild
-ant.properties
-local.properties
-build.sh
-android.iml
-build
-gradle
-gradlew
-gradlew.bat
-

contrib/android_binary_only/jni/Android.mk

@@ -1,74 +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 := $(IFADDRS_PATH)/ifaddrs.c \
-	$(wildcard $(LIB_SRC_PATH)/*.cpp)\
-	$(wildcard $(LIB_CLIENT_SRC_PATH)/*.cpp)\
-	$(DAEMON_SRC_PATH)/UnixDaemon.cpp \
-	$(DAEMON_SRC_PATH)/Daemon.cpp \
-	$(DAEMON_SRC_PATH)/UPnP.cpp \
-	$(DAEMON_SRC_PATH)/HTTPServer.cpp \
-	$(DAEMON_SRC_PATH)/I2PControl.cpp \
-	$(DAEMON_SRC_PATH)/i2pd.cpp
-include $(BUILD_EXECUTABLE)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := boost_system
-LOCAL_SRC_FILES := $(BOOST_PATH)/boost-1_72_0/$(TARGET_ARCH_ABI)/lib/libboost_system.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost-1_72_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_72_0/$(TARGET_ARCH_ABI)/lib/libboost_date_time.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost-1_72_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_72_0/$(TARGET_ARCH_ABI)/lib/libboost_filesystem.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost-1_72_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_72_0/$(TARGET_ARCH_ABI)/lib/libboost_program_options.a
-LOCAL_EXPORT_C_INCLUDES := $(BOOST_PATH)/boost-1_72_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.1a-clang/$(TARGET_ARCH_ABI)/lib/libcrypto.a
-LOCAL_EXPORT_C_INCLUDES := $(OPENSSL_PATH)/openssl-1.1.1a-clang/include
-include $(PREBUILT_STATIC_LIBRARY)
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE := ssl
-LOCAL_SRC_FILES := $(OPENSSL_PATH)/openssl-1.1.1a-clang/$(TARGET_ARCH_ABI)/lib/libssl.a
-LOCAL_EXPORT_C_INCLUDES := $(OPENSSL_PATH)/openssl-1.1.1a-clang/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)/miniupnpc-2.1/$(TARGET_ARCH_ABI)/lib/libminiupnpc.a
-LOCAL_EXPORT_C_INCLUDES := $(MINIUPNP_PATH)/miniupnpc-2.1/include
-include $(PREBUILT_STATIC_LIBRARY)

contrib/android_binary_only/jni/Application.mk

@@ -1,40 +0,0 @@
-APP_ABI := all
-#APP_ABI += x86
-#APP_ABI += x86_64
-#APP_ABI += armeabi-v7a
-#APP_ABI += arm64-v8a
-#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
-
-NDK_TOOLCHAIN_VERSION := clang
-APP_STL := c++_static
-
-# Enable c++17 extensions in source code
-APP_CPPFLAGS += -std=c++17 -fvisibility=default -fPIE
-
-APP_CPPFLAGS += -DANDROID_BINARY -DANDROID -D__ANDROID__ -DUSE_UPNP
-APP_LDFLAGS += -rdynamic -fPIE -pie
-ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
-APP_CPPFLAGS += -DANDROID_ARM7A
-endif
-
-# Forcing debug optimization. Use `ndk-build NDK_DEBUG=1` instead.
-#APP_OPTIM  := debug
-
-# git clone https://github.com/PurpleI2P/Boost-for-Android-Prebuilt.git -b boost-1_72_0
-# 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

contrib/android_binary_pack/.gitignore

@@ -1,2 +0,0 @@
-archive
-i2pd_*_android_binary.zip

contrib/android_binary_pack/build-archive

@@ -1,48 +0,0 @@
-#!/bin/bash
-
-# Copyright (c) 2013-2020, The PurpleI2P Project
-#
-# This file is part of Purple i2pd project and licensed under BSD3
-#
-# See full license text in LICENSE file at top of project tree
-
-GITDESC=$(git describe --tags)
-
-declare -A ABILIST=(
-	["armeabi-v7a"]="armv7l"
-	["arm64-v8a"]="aarch64"
-	["x86"]="x86"
-	["x86_64"]="x86_64"
-)
-
-# Remove old files and archives
-if [ -d archive ]; then
-	rm -r archive
-fi
-
-if [ -f ../i2pd_*_android_binary.zip ]; then
-	rm i2pd_*_android_binary.zip
-fi
-
-# Prepare files for package
-mkdir archive
-
-for ABI in "${!ABILIST[@]}"; do
-	if [ -f ../android_binary_only/libs/${ABI}/i2pd ]; then
-		cp ../android_binary_only/libs/${ABI}/i2pd archive/i2pd-${ABILIST[$ABI]}
-	fi
-done
-
-cp i2pd archive/i2pd
-cp -rH ../android/assets/certificates archive/
-cp -rH ../android/assets/tunnels.conf.d archive/
-cp -H ../android/assets/i2pd.conf archive/
-cp -H ../android/assets/tunnels.conf archive/
-
-# Compress files
-cd archive
-zip -r6 ../i2pd_${GITDESC}_android_binary.zip .
-
-# Remove temporary folder
-cd ..
-rm -r archive

contrib/android_binary_pack/i2pd

@@ -1,33 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2013-2020, The PurpleI2P Project
-#
-# This file is part of Purple i2pd project and licensed under BSD3
-#
-# See full license text in LICENSE file at top of project tree
-#
-# That script written for use with Termux.
-
-# https://stackoverflow.com/a/246128
-SOURCE="${0}"
-while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
-  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
-done
-DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
-
-arch=$(uname -m)
-
-screenfind=$(which screen)
-if [ -z $screenfind ]; then
-  echo "Can't find 'screen' installed. That script needs it!";
-  exit 1;
-fi
-
-if [ -z i2pd-$arch ]; then
-  echo "Can't find i2pd binary for your archtecture.";
-  exit 1;
-fi
-
-screen -AmdS i2pd ./i2pd-$arch --datadir=$DIR

contrib/apparmor/usr.sbin.i2pd

@@ -1,25 +0,0 @@
-# Basic profile for i2pd
-# Should work without modifications with Ubuntu/Debian packages
-# Author: Darknet Villain <supervillain@riseup.net>
-#
-#include <tunables/global>
-
-profile i2pd /{usr/,}sbin/i2pd {
-  #include <abstractions/base>
-  #include <abstractions/openssl>
-  #include <abstractions/nameservice>
-
-  # path specific (feel free to modify if you have another paths)
-  /etc/i2pd/** r,
-  /var/lib/i2pd/** rw,
-  /var/log/i2pd/i2pd.log w,
-  /{var/,}run/i2pd/i2pd.pid rwk,
-  /{usr/,}sbin/i2pd mr,
-  @{system_share_dirs}/i2pd/** r,
-
-  # user homedir (if started not by init.d or systemd)
-  owner @{HOME}/.i2pd/   rw,
-  owner @{HOME}/.i2pd/** rwk,
-
-  #include if exists <local/usr.sbin.i2pd>
-}

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/acetone_at_mail.i2p.crt

@@ -1,32 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFfzCCA2egAwIBAgIEctG1gDANBgkqhkiG9w0BAQ0FADBwMQswCQYDVQQGEwJY
-WDELMAkGA1UECAwCWFgxCzAJBgNVBAcMAlhYMR4wHAYDVQQKDBVJMlAgQW5vbnlt
-b3VzIE5ldHdvcmsxDDAKBgNVBAsMA0kyUDEZMBcGA1UEAwwQYWNldG9uZUBtYWls
-LmkycDAeFw0yMTAxMjUxMDMyMjBaFw0zMTAxMjMxMDMyMjBaMHAxCzAJBgNVBAYT
-AlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNVBAoMFUkyUCBBbm9u
-eW1vdXMgTmV0d29yazEMMAoGA1UECwwDSTJQMRkwFwYDVQQDDBBhY2V0b25lQG1h
-aWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAwqF/BRRmvZ54
-5XArgxbytDi7m7MDjFE/whUADruHj/9jXGCxE8DDiiKTt3yhfakV0SNo5xk7AMD+
-wqiSNC5JCHTm18gd2M4cQLIaOVRqucLLge4XVgk2WPX6OT98wfxh7mqA3wlSdEpj
-dY3Txtkf7VfZLicG76/RBtLFW3aBdsn63hZaQqZE4x/5MJyPVZx59+lys5RmMi0o
-LpXJy4HOu1/Gl1iKDJoI/ARFG3y7uP/B+ZtZBitJetTs0HcqycnNJq0tVZf2HiGF
-JNy67AL4foxNYPXP6QsvXvp6LRpGANaBCkFCBlriSF+x1zO2H3uAkRnuLYXuKIfB
-HudejTp4R57VgZGiHYoawHaF17FVAApue9G8O82XYECjhET35B9yFoOBHTvaMxLU
-CKrmayH8KMQon95mfe1qpoO3/YDa8DCxkjAfjdtytat7nt2pGZMH6/cLJxcFiofh
-RtRVvb+omv/X12j/6iCFrwP4NvBnAZsa736igbjpyee5n+CSyYxd9cJkRX1vQVk7
-WFSqL58Pz+g6CKJmdMPvqNOfUQ6mieBeejmx35B4pLzLcoNxw8R3O1+I2l4dg042
-dEydKRQNwdzOec4jYwnKR40iwIyZxpchXWGRbBdyF5RQCbIIo60QBJlfXMJ2svan
-q5lYIeWeY3mlODXu4KH4K09y10KT8FsCAwEAAaMhMB8wHQYDVR0OBBYEFMh+DoIL
-APNiu2o+6I9A49joNYQuMA0GCSqGSIb3DQEBDQUAA4ICAQBFeOJi0rmkqN5/E3IB
-nE2x4mUeLI82tUcN2D3Yu8J81vy4DnH+oMRQFDtYEHW5pfirRmgSZ7MQwYQnqWLp
-iTE7SyCxlqGrmVsYp7PzfS1pUT2QeWPtsNYUDdraG0Zr9BkIGB60VMhjMSa9WUrj
-lbchzr6E/j/EsEOE7IK08JxIDKCDZM2LLwis4tAM6tmiylkMf2RlUBIRBs1TCO+q
-x3yByttNE2P4nQyQVQpjc1qsaOMvJvbxun37dwo+oTQy+hwkA86BWTDRYdN3xwOk
-OfAOtlX6zM/wCKMN0ZRnjZoh59ZCn4JXokt3IjZ4n8qJOuJFRKeKGmGeKA8uaGW8
-ih5tdB99Gu5Z8LOT1FxAJKwQBn5My0JijPoMit4B0WKNC8hy2zc2YvNfflu1ZRj5
-wF4E5ktbtT/LWFSoRPas/GFS8wSXk/kbSB0ArDcRRszb3JHqbALmSQxngz3rfwb3
-SHwQIIg956gjMDueEX5CrGrMqigiK53b9fqtpghUrHDsqtEXqeImpAY65PX1asqo
-metDNuETHF7XrAjP7TGJfnrYQyeK90iS7j1G68ScBGkKY2nsTnFoXkSk5s5D338E
-SUzPaOlh91spmkVY6gQTVQ7BakADBHw+zBgDA1gBN/4JPvgN36hquj63+aG1cKy3
-3ZUnv2ipo2fpr69NtuBnutK6gw==
------END CERTIFICATE-----

contrib/certificates/reseed/backup_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFfTCCA2WgAwIBAgIEOprmhjANBgkqhkiG9w0BAQ0FADBvMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEYMBYGA1UEAwwPYmFja3VwQG1haWwu
+aTJwMB4XDTEzMTAxMzEzNDQ1NVoXDTIzMTAxMzEzNDQ1NVowbzELMAkGA1UEBhMC
+WFgxCzAJBgNVBAgTAlhYMQswCQYDVQQHEwJYWDEeMBwGA1UEChMVSTJQIEFub255
+bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGDAWBgNVBAMMD2JhY2t1cEBtYWls
+LmkycDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIoAkobXwk/Enf1d
+roHyqCyvcJfZJVTwb/LgYWAvCBMCr+RGqlSgtk3g69Y3I0xU08fD2kGt3r5Pwsbr
+omXIbJAcccyLqmQ5QX6QgL+X9VpMDp9C4h2RogCrqLBAWw4cuZ4RS9VCpP1Yis7H
+uejYqENP86p7BsRnuW/4cYnfunAdMpss4LpRGQXt1nTX+kfgCYgnKFbFqwAHt7yV
+Ds+Pe6FuBHPlp+sc1amKRcUnSvhXLsv43VicnT7xYL/kUsN83wrtHA3B4aGDx3aA
+3/EzuRmIXQB0BlTZILMEyYwG/nc4OsW82QYrvEZ9BIg9A4lF/wS/KZCICPxLF2zo
+dGjnmlgkiA4s8eO+va/ElHyELjckVXqmG1eXHhSkEsDvOQJy01IUuwLinvq7cUbJ
+HfJBZJllEg+sLDCv3FkEqN+XjBNFfQN4oNew4w6IPY6YH1INVB9LL0Cmdu4DudLv
+TY8OcI8eSfez3hmm+pYQ23PJRYYnvRDnRECyIWBegkckWRh8U/WvZUYUvETK6EDl
+/0KpTtfzX6MqHA5D6bTAB8Y3ijGMLrZ/B5vj5yCoZbLiGme9X2moR2k1LEhdhtzV
+exsqezCpg6dn48FTX7mHjvR5/r4kz2jqBGmdPUWIIxnjFUzDUK3llVQiHihleHpe
+jL4LqnhBGKWFRTaVwaIkBG4zAfIzAgMBAAGjITAfMB0GA1UdDgQWBBQNkfW7bSMl
+1/4KDbgwrkf9x1Zu/TANBgkqhkiG9w0BAQ0FAAOCAgEAGg3a3rTf0EznQocmio0T
+5gCoL0n8h6yKW/PyPAIELrd9wiYjhJFcWvMTcJJJnVqmAL5vpvhaAFVtAfx70MGa
+0DZ7FvytK5hEfF4IqOFDyEEVGJR5rIpVK4MeI1nmwEsxdbW+FhODjtRzgYO8XBME
+Xj4aY1FWg9vxc3reUj6PSFsZtsB0aLiRgL9JDovJIiRw0Uqr1v2wXBte5yVCxDge
+vTREZtpK4cKetoOa68pwSXI32JwKE18j6bfdKVBCcYQKlKP/3gHGduaDrQv3w32S
+DRym5s6MREeTUOtAw4wq46KpdOX8yyAqJPrCfMwS6ORd3t+egqOw0PUnsqb97w4O
+lUtrRYvb2cOj60SmRx4vJvItyuHbKqIK7o2e1RcUZPXYoAVx2ww4XB2Wk4D7LSAs
+cS7nLj8yAqzJ2qqtBzxu+zILJtkVa12dKF0xmS0BxBp4sCYiBtmAVE8AWQqEuSHA
+FrMWqoXcjcfdvvyX487FFWWUE7ZBIn0hee2sK9J9+SPtqczJaN7TF3K3nzo65WJG
+1epltmq2Ugjb67Gz7v4y7H23DJ/qhm8yLtCHTj69HTta5I08j6Kut924WLZaiMO/
+4YoEL5AE63X0sxYibKFQiq7FW5nUJA280GRlY3xSMFzlB2ggazrUV3YAWVDhfdnI
+flpzWXkFM2D36OUaubfe9YY=
+-----END CERTIFICATE-----

contrib/certificates/reseed/bugme_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFezCCA2OgAwIBAgIEUQYyQjANBgkqhkiG9w0BAQ0FADBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOYnVnbWVAbWFpbC5p
+MnAwHhcNMTQxMTA2MDkxMTE0WhcNMjQxMTA1MDkxMTE0WjBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOYnVnbWVAbWFpbC5p
+MnAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCrThOH0eSDT0VnCSBC
+sqYmAydWH+O8eNttDXr2mSvZLhvAW+6/xHTkKhaWvkIvvS0Vh8hujMnD90Cgp4Fk
+TKCxMj9K527o5xIZwWW05OevbjlBwIpVLO1PjmsfsoD1nIX14eEzJSEoAulKsv7V
+jGUC/6hC11mmVvH9buQLSRv6sCjuAcMszmw3TAD+XYBIs+z57KuwYXtX3+OA543c
+l1/ZKLYkkwY8cwzZqWDVWqTKP5TfVae58t40HhJk3bOsr21FZsaOjlmao3GO+d/3
+exKuUGJRcolSqskL3sZ1ovFqko81obvvx0upI0YA0iMr/NRGl3VPuf/LJvRppYGc
+LsJHgy9TIgtHvaXRi5Nt4CbKl9sZh/7WkkTTI5YGvevu00btlabAN+DSAZZqdsB3
+wY8HhM1MHiA9SWsqwU65TwErcRrjNna2FiDHEu0xk5+/iAGl6CSKHZBmNcYKXSv8
+cwShB0jjmciK0a05nC638RPgj0fng7KRrSglyzfjXRrljmZ40LSBL/GGMZMWpOM7
+mEsBH5UZJ/2BEmjc9X9257zBdx8BK8y1TXpAligpNBsERcTw1WP1PJ35einZvlXW
+qI3GwMf0sl26sn+evcK0gDl27jVDZ45MtNQEq64M4NV3Tn9zq0eg/39YvjVeqrI5
+l7sxmYqYGR6BuSncwdc4x+t6swIDAQABoyEwHzAdBgNVHQ4EFgQU/REZ7NMbVZHr
+Xkao6Q8Ccqv2kAMwDQYJKoZIhvcNAQENBQADggIBACc2YjLVNbl1kJUdg2klCLJt
+5LjNTiIZa2Cha5GStlC/lyoRRge6+q/y9TN3tTptlzLPS9pI9EE1GfIQaE+HAk+e
+/bC3KUOAHgVuETvsNAbfpaVsPCdWpFuXmp/4b9iDN7qZy4afTKUPA/Ir/cLfNp14
+JULfP4z2yFOsCQZ5viNFAs1u99FrwobV2LBzUSIJQewsksuOwj96zIyau0Y629oJ
+k+og88Tifd9EH3MVZNGhdpojQDDdwHQSITnCDgfRP5yER1WIA4jg6l+mM90QkvLY
+5NjWTna5kJ3X6UizvgCk365yzT2sbN3R9UGXfCJa9GBcnnviJtJF3+/gC0abwY2f
+NtVYp32Xky45NY/NdRhDg0bjHP3psxmX+Sc0M9NuQcDQ+fUR+CzM0IGeiszkzXOs
+RG+bOou2cZ81G4oxWdAALHIRrn7VvLGlkFMxiIZyhYcTGQZzsTPT6n18dY99+DAV
+yQWZfIRdm8DOnt0G+cwfeohc/9ZwDmj4jJAAi0aeTXdY6NEGIVydk6MAycEhg2Hx
+9EV96kRwZNIW0AGY8CozECFL3Eyo2ClQVV4Q35SsBibsitDjM03usc2DJ/qjynXA
+C8HoOSWgbddiBvqZueqK8GdhykOy3J3ysr+MNN/lbG48LqkQr1OWxev9rGGQ6RJT
+wpBgPyAFAwouPy1whmnx
+-----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/hankhill19580_at_gmail.com.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIF3TCCA8WgAwIBAgIRAKye34BRrKyQN6kMVPHddykwDQYJKoZIhvcNAQELBQAw
-dzELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwGA1UE
-ChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxIDAeBgNVBAMM
-F2hhbmtoaWxsMTk1ODBAZ21haWwuY29tMB4XDTIwMDUwNzA1MDkxMFoXDTMwMDUw
-NzA1MDkxMFowdzELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJY
-WDEeMBwGA1UEChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAx
-IDAeBgNVBAMMF2hhbmtoaWxsMTk1ODBAZ21haWwuY29tMIICIjANBgkqhkiG9w0B
-AQEFAAOCAg8AMIICCgKCAgEA5Vt7c0SeUdVkcXXEYe3M9LmCTUyiCv/PHF2Puys6
-8luLH8lO0U/pQ4j703kFKK7s4rV65jVpGNncjHWbfSCNevvs6VcbAFoo7oJX7Yjt
-5+Z4oU1g7JG86feTwU6pzfFjAs0RO2lNq2L8AyLYKWOnPsVrmuGYl2c6N5WDzTxA
-Et66IudfGsppTv7oZkgX6VNUMioV8tCjBTLaPCkSfyYKBX7r6ByHY86PflhFgYES
-zIB92Ma75YFtCB0ktCM+o6d7wmnt10Iy4I6craZ+z7szCDRF73jhf3Vk7vGzb2cN
-aCfr2riwlRJBaKrLJP5m0dGf5RdhviMgxc6JAgkN7Ius5lkxO/p3OSy5co0DrMJ7
-lvwdZ2hu0dnO75unTt6ImR4RQ90Sqj7MUdorKR/8FcYEo+twBV8cV3s9kjuO5jxV
-g976Q+GD3zDoixiege3W5UT4ff/Anm4mJpE5PKbNuO+KUjk6WA4B1PeudkEcxkO4
-tQYy0aBzfjeyENee9otd4TgN1epY4wlHIORCa3HUFmFZd9VZMQcxwv7c47wl2kc9
-Cv1L6Nae78wRzRu2CHD8zWhq+tv5q7Md2eRd3mFPI09ljsOgG2TQv6300WvHvI5M
-enNdjYjLqOTRCzUJ2Jst4BZsvDxjWYkHsSZc1UORzm2LQmh2bJvbhC3m81qANGw6
-ZhcCAwEAAaNkMGIwDgYDVR0PAQH/BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMC
-BggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCAGA1UdDgQZBBdoYW5raGlsbDE5
-NTgwQGdtYWlsLmNvbTANBgkqhkiG9w0BAQsFAAOCAgEAVtMF7lrgkDLTNXlavI7h
-HJqFxFHjmxPk3iu2Qrgwk302Gowqg5NjVVamT20cXeuJaUa6maTTHzDyyCai3+3e
-roaosGxZQRpRf5/RBz2yhdEPLZBV9IqxGgIxvCWNqNIYB1SNk00rwC4q5heW1me0
-EsOK4Mw5IbS2jUjbi9E5th781QDj91elwltghxwtDvpE2vzAJwmxwwBhjySGsKfq
-w8SBZOxN+Ih5/IIpDnYGNoN1LSkJnBVGSkjY6OpstuJRIPYWl5zX5tJtYdaxiD+8
-qNbFHBIZ5WrktMopJ3QJJxHdERyK6BFYYSzX/a1gO7woOFCkx8qMCsVzfcE/z1pp
-JxJvshT32hnrKZ6MbZMd9JpTFclQ62RV5tNs3FPP3sbDsFtKBUtj87SW7XsimHbZ
-OrWlPacSnQDbOoV5TfDDCqWi4PW2EqzDsDcg+Lc8EnBRIquWcAox2+4zmcQI29wO
-C1TUpMT5o/wGyL/i9pf6GuTbH0D+aYukULropgSrK57EALbuvqnN3vh5l2QlX/rM
-+7lCKsGCNLiJFXb0m6l/B9CC1947XVEbpMEAC/80Shwxl/UB+mKFpJxcNLFtPXzv
-FYv2ixarBPbJx/FclOO8G91QC4ZhAKbsVZn5HPMSgtZe+xWM1r0/UJVChsMTafpd
-CCOJyu3XtyzFf+tAeixOnuQ=
------END CERTIFICATE-----

contrib/certificates/reseed/hottuna_at_mail.i2p.crt

@@ -1,33 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFxzCCA6+gAwIBAgIQZfqn0yiJL3dGgCjeOeWS6DANBgkqhkiG9w0BAQsFADBw
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEZMBcGA1UEAwwQ
-aG90dHVuYUBtYWlsLmkycDAeFw0xNjExMDkwMzE1MzJaFw0yNjExMDkwMzE1MzJa
-MHAxCzAJBgNVBAYTAlhYMQswCQYDVQQHEwJYWDELMAkGA1UECRMCWFgxHjAcBgNV
-BAoTFUkyUCBBbm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRkwFwYDVQQD
-DBBob3R0dW5hQG1haWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC
-AgEA21Bfgcc9VVH4l2u1YvYlTw2OPUyQb16X2IOW0PzdsUO5W78Loueu974BkiKi
-84lQZanLr0OwEopdfutGc6gegSLmwaWx5YCG5uwpLOPkDiObfX+nptH6As/B1cn+
-mzejYdVKRnWd7EtHW0iseSsILBK1YbGw4AGpXJ8k18DJSzUt2+spOkpBW6XqectN
-8y2JDSTns8yiNxietVeRN/clolDXT9ZwWHkd+QMHTKhgl3Uz1knOffU0L9l4ij4E
-oFgPfQo8NL63kLM24hF1hM/At7XvE4iOlObFwPXE+H5EGZpT5+A7Oezepvd/VMzM
-tCJ49hM0OlR393tKFONye5GCYeSDJGdPEB6+rBptpRrlch63tG9ktpCRrg2wQWgC
-e3aOE1xVRrmwiTZ+jpfsOCbZrrSA/C4Bmp6AfGchyHuDGGkRU/FJwa1YLJe0dkWG
-ITLWeh4zeVuAS5mctdv9NQ5wflSGz9S8HjsPBS5+CDOFHh4cexXRG3ITfk6aLhuY
-KTMlkIO4SHKmnwAvy1sFlsqj6PbfVjpHPLg625fdNxBpe57TLxtIdBB3C7ccQSRW
-+UG6Cmbcmh80PbsSR132NLMlzLhbaOjxeCWWJRo6cLuHBptAFMNwqsXt8xVf9M0N
-NdJoKUmblyvjnq0N8aMEqtQ1uGMTaCB39cutHQq+reD/uzsCAwEAAaNdMFswDgYD
-VR0PAQH/BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAPBgNV
-HRMBAf8EBTADAQH/MBkGA1UdDgQSBBBob3R0dW5hQG1haWwuaTJwMA0GCSqGSIb3
-DQEBCwUAA4ICAQCibFV8t4pajP176u3jx31x1kgqX6Nd+0YFARPZQjq99kUyoZer
-GyHGsMWgM281RxiZkveHxR7Hm7pEd1nkhG3rm+d7GdJ2p2hujr9xUvl0zEqAAqtm
-lkYI6uJ13WBjFc9/QuRIdeIeSUN+eazSXNg2nJhoV4pF9n2Q2xDc9dH4GWO93cMX
-JPKVGujT3s0b7LWsEguZBPdaPW7wwZd902Cg/M5fE1hZQ8/SIAGUtylb/ZilVeTS
-spxWP1gX3NT1SSvv0s6oL7eADCgtggWaMxEjZhi6WMnPUeeFY8X+6trkTlnF9+r/
-HiVvvzQKrPPtB3j1xfQCAF6gUKN4iY+2AOExv4rl/l+JJbPhpd/FuvD8AVkLMZ8X
-uPe0Ew2xv30cc8JjGDzQvoSpBmVTra4f+xqH+w8UEmxnx97Ye2aUCtnPykACnFte
-oT97K5052B1zq+4fu4xaHZnEzPYVK5POzOufNLPgciJsWrR5GDWtHd+ht/ZD37+b
-+j1BXpeBWUBQgluFv+lNMVNPJxc2OMELR1EtEwXD7mTuuUEtF5Pi63IerQ5LzD3G
-KBvXhMB0XhpE6WG6pBwAvkGf5zVv/CxClJH4BQbdZwj9HYddfEQlPl0z/XFR2M0+
-9/8nBfGSPYIt6KeHBCeyQWTdE9gqSzMwTMFsennXmaT8gyc7eKqKF6adqw==
------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-----

contrib/certificates/reseed/meeh_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFeTCCA2GgAwIBAgIEZZozujANBgkqhkiG9w0BAQ0FADBtMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEWMBQGA1UEAwwNbWVlaEBtYWlsLmky
+cDAeFw0xNDA2MjgyMjQ5MDlaFw0yNDA2MjcyMjQ5MDlaMG0xCzAJBgNVBAYTAlhY
+MQswCQYDVQQIEwJYWDELMAkGA1UEBxMCWFgxHjAcBgNVBAoTFUkyUCBBbm9ueW1v
+dXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRYwFAYDVQQDDA1tZWVoQG1haWwuaTJw
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAnVnmPE4uUvCky0yCnnVH
+cJEDqzwDPupx0zr0YDlhZk5VOPPecx5haayJ/V6nXPc1aVVWn+CHfedcF2aBgN4K
+5aBueS/l6l5WHcv02DofAqlTmyAws3oQeR1qoTuW24cKRtLR7h5bxv63f6bgp6e+
+RihFNez6UxErnRPuJOJEO2Im6EgVp6fz7tQ7R35zxAUeES2YILPySvzy2vYm/EEG
+jXX7Ap2A5svVo90xCMOeUZ/55vLsjyIshN+tV87U4xwvAkUmwsmWVHm3BQpHkI6z
+zMJie6epB8Bqm0GYm0EcElJH4OCxGTvDLoghpswbuUO7iy3JSfoL7ZCnoiQdK9K4
+yVVChj8lG+r7KaTowK96iZep+sZefjOt5VFGuW2Fi/WBv3ldiLlJAo/ZfrUM4+vG
+fyNBXbl6bX87uTCGOT1p3dazo+zJMsAZ+Y93DlM/mDEWFa1kKNrs74syzaWEqF4L
+KQE6VoYn80OOzafSigTVQgSwUtQtB0XGhMzJhyxU2XHWe1LFIy7Pta0B+lDiZj7c
+I8nXxYjsDfEu/Elj/Ra9N6bH0awmgB5JDa+Tbir+oEM5SyDfpSaCGuatdGxjweGI
+kVmFU0SqCZV/8TXbIu6MUVzTZMZVT94edifFSRad4fqw7eZbSXlPu++3d1/btn6h
+ibM04nkv0mm+FxCKB/wdAkECAwEAAaMhMB8wHQYDVR0OBBYEFO7jIkSRkoXyJcho
+9/Q0gDOINa5EMA0GCSqGSIb3DQEBDQUAA4ICAQBzfWO7+8HWOKLaYWToJ6XZbpNF
+3wXv1yC4W/HRR80m4JSsq9r0d7838Nvd7vLVP6MY6MaVb/JnV76FdQ5WQ6ticD0Y
+o3zmpqqbKVSspN0lrkig4surT88AjfVQz/vEIzKNQEbpzc3hC2LCiE2u+cK/ix4j
+b9RohnaPvwLnew5RNQRpcmk+XejaNITISr2yQIwXL7TEYy8HdGCfzFSSFhKe9vkb
+GsWS5ASrUzRoprswmlgRe8gEHI+d51Z7mWgna0/5mBz9bH/3QXtpxlLWm3bVV+kt
+pZjQDTHE0GqG2YsD1Gmp4LU/JFhCojMTtiPCXmr9KFtpiVlx06DuKm5PC8Ak+5w+
+m/DQYYfv9z+AA5Y430bjnzwg67bhqVyyek4wcDQinFswv3h4bIB7CJujDcEqXXza
+lhG1ufPPCUTMrVjh7AShohZraqlSlyQPY9vEppLwD4W1d+MqDHM7ljOH7gQYaUPi
+wE30AdXEOxLZcT3aRKxkKf2esNofSuUC/+NXQvPjpuI4UJKO3eegi+M9dbnKoNWs
+MPPLPpycecWPheFYM5K6Ao63cjlUY2wYwCfDTFgjA5q8i/Rp7i6Z6fLE3YWJ4VdR
+WOFB7hlluQ//jMW6M1qz6IYXmlUjcXl81VEvlOH/QBNrPvX3I3SYXYgVRnVGUudB
+o3eNsanvTU+TIFBh2Q==
+-----END CERTIFICATE-----

contrib/certificates/reseed/orignal_at_mail.i2p.crt

@@ -1,32 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFfzCCA2egAwIBAgIEbNbRPjANBgkqhkiG9w0BAQ0FADBwMQswCQYDVQQGEwJY
-WDELMAkGA1UECAwCWFgxCzAJBgNVBAcMAlhYMR4wHAYDVQQKDBVJMlAgQW5vbnlt
-b3VzIE5ldHdvcmsxDDAKBgNVBAsMA0kyUDEZMBcGA1UEAwwQb3JpZ25hbEBtYWls
-LmkycDAeFw0yMTA3MDYyMjExMDFaFw0zMTA3MDQyMjExMDFaMHAxCzAJBgNVBAYT
-AlhYMQswCQYDVQQIDAJYWDELMAkGA1UEBwwCWFgxHjAcBgNVBAoMFUkyUCBBbm9u
-eW1vdXMgTmV0d29yazEMMAoGA1UECwwDSTJQMRkwFwYDVQQDDBBvcmlnbmFsQG1h
-aWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvNJz2KGuAkHP
-tGFobfLvpybtxB50fkcEsTc9opmiy7wBKK9rSI01VS616IhABkWKZVfK2A9NqpGv
-v/CyhTKoaeSNeXY7+zORUWgWK/zA9fA4GRZFqlW8j4tbompDwcLYNqRBCsn1C0OY
-YA5JhXPBixMcnXl8N8x4sXhQ4l9R3+QrydhUHRvgDc8dOxRyIX7zuQAyf8tmA2Xo
-xZLdvDcCJdLBIbFwxhIceIhgcOwaOx7oRkZDZdYcLJd3zjyPbu8JtOM2ZkwH7r+0
-ro5PktuDp2LAS6SII5yYNcwcrvPZGPqhLdifIw1BrdTIb/rIkQZ5iXOOdyPmT7e8
-IwAJcPFlfvrS4Vbi9oDqyx3aDUBoubgmFnO1TirL56ck83R/ubcKtdnyzAn5dp+f
-ZNYW6/foSBpDDOCViylbFAR5H0HJEbBns7PZx6mGEEI4tUAJdNYl7Ly7Df60a9Rz
-cD/gz08U9UwFXYKoT6roEjToADGAzb5MI4cVlAb2AmQaMNXNe04HcDL1bU50mkNU
-amqPv8nxf72fBQCEmZz2G57T6QiYTtcCwiWS1QdWsuaOtCo9zO0MKcjzSdUxuxEc
-dXhjQdNegsgg/Xk7bJ8lKOsACqMpFftdPmuyeZU2t+3RPuBpV/0j2qUfg/y6kb0z
-CxAOYmlcL4kqw4VT+5V/EeZLIG0h9I0CAwEAAaMhMB8wHQYDVR0OBBYEFD/wJObg
-CCDuhMJCVWTSTj+B3rsUMA0GCSqGSIb3DQEBDQUAA4ICAQC0PjsTSPWlGbLNeeI8
-F0B5xAwXYJzZ7/LRxh8u42HDUqVIDjqkuls1l3v9D7htty2Gr3Ws2dcvcOr2KcOy
-mEWg+jdP/N3vt9IkZeVS4YQoPgq6orn7lVkk00bcKb24f7ZnoQnnVV0/m42Y5P4j
-LLh+8MBxsez9azXyZbDVEkgsMUAkdVO6KNz6scqz7wb8egV2GAMAp7cwChC6lanK
-gv9ZyJhG/HdTv6VyuMZhJy6rX4geM97tm1iHu1VLsQcIzBKAdEvWJv8ofMeiyINe
-hqAP9NYaeowKi975NOrmf+XZwxd0niApIohV684RCVUfL8H7HSPbdXhBJ/WslyDP
-cTGhA2BLqEXZBn/nLQknlnl0SZTQxG2n4fEgD1E5YS/aoBrig/uXtWm2Zdf8U3mM
-+bNXhbi9s7LneN2ye8LlNJBSRklNn/bNo8OmzLII1RQwf1+vaHT96lASbTVepMZ/
-Y9VcC8fAmho/zfQEKueLEB03K+gr2dGD+1crmMtUBjWJ9vPjtooZArtkDbh+kVYA
-cx4N4NXULRwxVWZe5wTQOqcZ3qSS1ClMwaziwychGaj8xRAirHMZnlPOZO1UK4+5
-8F4RMJktyZjNgSLP76XPS4rJK5fobuPqFeA4OpDFn/5+/XeQFF6i6wntx1tzztzH
-zc+BrVZOdcYPqu9iLXyRQ9JwwA==
------END CERTIFICATE-----

contrib/certificates/reseed/r4sas-reseed_at_mail.i2p.crt

@@ -1,32 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFiTCCA3GgAwIBAgIEY2XeQjANBgkqhkiG9w0BAQ0FADB1MQswCQYDVQQGEwJY
-WDELMAkGA1UECAwCWFgxHjAcBgNVBAcMFUkyUCBBbm9ueW1vdXMgTmV0d29yazEL
-MAkGA1UECgwCWFgxDDAKBgNVBAsMA0kyUDEeMBwGA1UEAwwVcjRzYXMtcmVzZWVk
-QG1haWwuaTJwMB4XDTE3MDYyMjEwNTQ1NFoXDTI3MDYyMDEwNTQ1NFowdTELMAkG
-A1UEBhMCWFgxCzAJBgNVBAgMAlhYMR4wHAYDVQQHDBVJMlAgQW5vbnltb3VzIE5l
-dHdvcmsxCzAJBgNVBAoMAlhYMQwwCgYDVQQLDANJMlAxHjAcBgNVBAMMFXI0c2Fz
-LXJlc2VlZEBtYWlsLmkycDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
-ANgsj5LhF4uGG4RDueShqYQZsG5Rz6XUAtK9sVGFdmdJTDZirUMZcCGCGZP/Harz
-QaZU9EYxOCztnpLCQksSCpdRsij56MURS0tW/1x7LHIDUOi911Of57jgIHH+3E5n
-6tuRxEk6J/9Ji3PI+89kl0sPKMVFMyKkINprVTA5zr/keyYEG0p6HSEYYiJkQH78
-8uoOCAmlk9mxkJFb+zviCk6jsYwdH+ofD6Lw5ueOlYUbeZ9Nd7jfSdf20XM7ofIw
-W2COtsbq3J7vNrQJMV7HkHxVx/7OqmjQF02OahZFZREVZqbHpL501iTn9Iqd5qKq
-IsxYjk7ZnP4UUCBk8NOU5TuWsy0qNw+TJDI9s55Fi4KPtXWf47HIl6CdpM5y/D5L
-eufCojSwPKlrD6x9gTyJdBggBZRIyplXdKffo/95hUhEkv86yfsVVR7Gu1uy0O8T
-Gtb8Da/oi5eEZBHWonLVicLPei5jeo+1gbR09PQ6s41uMZlOhMe4RSgiIQj/7UVo
-ffKdl1MPNKr1u2fgVj8kxqg8ZivWKQ2taEgimU2EkQcNcE96M9yQlNNpNvqSAQVk
-wYXlHt0AN6A1A8u1pItxaTwXnbmx+OBJZoKl4ZQeaC8wtKjTgAgVXp+g5iot2gir
-LjxCRx1WLG1c8vRg1W8CDZII8Swc8EWpMhI+0hPv7/4/AgMBAAGjITAfMB0GA1Ud
-DgQWBBTN5sKbrNzwE8sgMGDekfOPgX8/JDANBgkqhkiG9w0BAQ0FAAOCAgEAjLaB
-bHqvFTs0ikAtesk9r8+8XVIsP5FR57zZCek2vxkHcCQWw8Uqs3ndInRX4FirKSLT
-WRb4aSwFCkrmwueecTpXN/RBC+fZj+POCfdILEsA+FGreAM2q5ZXv/Q0jyIXOXEM
-+KL0JZXnNS0/dqR3IYbC7f39CL6Sf40gRGTwTWWGg3KnynoS0v1zQcZLTMhHBD2X
-tgdIPbroq9t4gXa7Dhm0egYfQOI/7re2wiZT7UWVVwEpYqKf6JApFHa1nNOFMrLF
-45JHQIHArkoxpQdfSe9HBoyJiB5vz398rHZeqbJaF3PIg9rxWWY/NvvOVuIk8U5z
-0jExhg29a88B32U7ndvQJqIuGiQghzCiLxC/y1+wAdpeDSbD3OAOHqplvMj3BUn9
-yhDSLSjtfBJjnXKxtEcWLR0edHCGEk5mAcL7q1WNxDpxaICwGGpNZN53CtFx7amb
-egYil448DmiqoQTCTE9pBz8YjwiVfCYLYv17O0NJyYM9Efy/wL3rFlsPJniWHMuH
-imZybVU4ukjvfOZ+LY4COTwz6w4sfA7a+i+2mOynC7eKX8Yg6i1nXlcY1Z8ykNgi
-7B3kz1T/DV56CIm6QUWtepfuKTYq4C6QrBBIXLk1d5g95aWA21u1LRqNZ9GLH+eA
-gfvIm7v+cELj8a53EQY0LafzZqNC5kQAp916coU=
------END CERTIFICATE-----

contrib/certificates/reseed/reseed_at_diva.exchange.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIF0zCCA7ugAwIBAgIQWjHyC+NRh3emuuAwcEnKSjANBgkqhkiG9w0BAQsFADB0
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEdMBsGA1UEAwwU
-cmVzZWVkQGRpdmEuZXhjaGFuZ2UwHhcNMjAwNjA5MDUzNjQ1WhcNMzAwNjA5MDUz
-NjQ1WjB0MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4w
-HAYDVQQKExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEdMBsG
-A1UEAwwUcmVzZWVkQGRpdmEuZXhjaGFuZ2UwggIiMA0GCSqGSIb3DQEBAQUAA4IC
-DwAwggIKAoICAQC6BJGeMEgoXk9dlzKVfmwHrT2VpwTT+wRJvh3eAM746u4uDT2y
-NPHXhdGcQ9dRRZ63T98IshWCwOmWSlm1kdWkmKkVVb93GUoMQ3gziCi0apLJMAau
-gEu/sPCbORS2dPsQeAPW2eIsJO7dSjTRiQAuquW//NcIXG4gnxDA52lgke1BvpKr
-83SJlCrqECAy6OKtZ49yn75CqmPPWFn0b/E8bxruN5ffeipTTospvdEtT41gXUqk
-hOz3k8ang+QTWiP//jOjk31KXZ2dbh0LOlNJOvRxCqQmBZafNxxCR4DH8RewfPlL
-qOiOJVzbLSP9RjqPLwnny5BOjbLWXcaybN5Qv2Pyd4mKtN3EpqBwRu7VnzXpsuuG
-gRbxNmfKJ/vBEGrZAHAxi0NkHHEEne3B7pPDc2dVZHOfTfCu31m9uDHZ4eHEsNOJ
-SJRiGjq74l0chCSlBGLrD1Y9LPyqadjdwuB9bzM0tMFC1wPflanQCflhhnEzAfbN
-BaU2GRXo/I1UCDW/dH1FIkqEe61eMW1Lwqr5tdlrUpdr5VIddTyNJRBJogbZ+HZE
-8mcoJW2lXRAkYi7KEm4b4EQNe7sbRNTF0j+fAJ+3ZOZ3O3SMHss6ignlSa+giVim
-VvL+Joc6wpSzxpeNPf6m82cEO/UvifFYeOC9TpiRriSt+vvgQVzQtfQ+fQIDAQAB
-o2EwXzAOBgNVHQ8BAf8EBAMCAoQwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUF
-BwMBMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFHJlc2VlZEBkaXZhLmV4Y2hh
-bmdlMA0GCSqGSIb3DQEBCwUAA4ICAQCFGOb1dHlwjmgFHEER6oMiGWl1mI3Hb7GX
-NNI6QUhZQ+iEWGYtsOTk3Q8xejL8t6AG/ZLXfZviLIJXZc5XZfPXk0ezDSC2cYxQ
-ZAyYPw2dRP14brI86sCSqNAFIax/U5SM3zXhCbBiTfaEoBPfDpvKjx+VliaITUnc
-sHTRn+C5ID5M8cZIqUSGECPEMU/bDtuRNJLTKYaJ98yXtYuS2CWsMEM4o0GGcnYQ
-5HOZT/lbbwfq1Ks7IyJpeIpRaS5qckGcfgkxFY4eGujDuaFeWC+HCIh9RzBJrqZR
-73Aly4Pyu7Jjg8xCCf9MswDjtqAjEHgWCmRLWL7p3H6cPipFKNMY6yomYZl5urE7
-q6DUAZFKwPqlZpyeaY4/SVvaHTxuPp7484s3db4kPhdmuQS/DOB/7d+cn/S580Vy
-ALqlFQjtjLEaT16upceAV0gYktDInE6Rtym/OsqilrtYks/Sc0GROSz8lJhDDWbr
-W3t92muSXDh0rYrEUYWl+xl1gSTpbIP75zzU+cUr1E/qlRY9qZn66FsJpOuN0I0q
-UXsQS/bPDcA+IW48Hd9LfO9gtTWZslwFTimjEvQ2nJAnUlUQP6OfuPUKHoYX/CwY
-2LCN8+pv2bKPDVHvp0lf6xrbbZNvFtzfR0G3AprZjYpuu2XgjVB5nJnwmbH74b9w
-LD8d2z2Lgg==
------END CERTIFICATE-----

contrib/certificates/reseed/sindu_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFezCCA2OgAwIBAgIEPSs1SjANBgkqhkiG9w0BAQ0FADBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOc2luZHVAbWFpbC5p
+MnAwHhcNMTQwNzIxMDAwNjUwWhcNMjQwNzIwMDAwNjUwWjBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOc2luZHVAbWFpbC5p
+MnAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCnYMNclgj1gIJfot6f
+65jbcXpcqf9hhL/uYiU4+uxVevWyJvNHpMzhPWNN4l3HihJJsINsPs/MsZ83Guva
+GW5S/93I617kyjs/ZVpEtfABGewho0m9VCBV2/N1mJpHvvR+9OR+YVuWlTB/8sTG
+2smdRj/dkKvewN5PSTQH350yT18NR/DmZUU1Iwa7vrNw8ol3rP3qx9UGpFN3JE7V
+Q9cA1nktMiFUm76eOPOoln04WDqW2rvArXzvhSApvt0JsLBrZDzM3cx2Rc2UdjIC
+h+Ha+G4CLjszfZfQAFJYPred38Gg6wuXiza/wCBSPiB92i94hIQF/OSeukaMiqwG
+dRAcBT84/U9bddqHlIICw14PkNHOGUyJGjGKWQl/2bLX43ghWkUJmsTXS3iVcOTc
+gb/7MoCRBdL0q2GyEJXuAoKXD9VqD3g+EdcBTQxS9lhZ0iTR7423pg6FP43VMEUC
+HUi/BOX1tCY6iRzD1Su6ISIx7klH/sAWWa+SybLFXWtZJxHXXJICiBHJWRbWgtlu
+5V+at66yg/LNpyfW3Am08gDV0kiWUBN2Ct4TX9PAQmNDisNgi2AzdZHIfX6tRpU8
+UnNcnZGOh4+HXQwJtI0y83C8TsXJUFYfGFWqXN69sMEmgtX8/w+YUqjtb2GcX1HN
+6z9u9lH40JCFHTA/clPqOSQ+MQIDAQABoyEwHzAdBgNVHQ4EFgQU4R6x7ArVpSVs
+b8VTBXmodXzyraEwDQYJKoZIhvcNAQENBQADggIBAJEHLSDBRU2x6EalmN2W952p
+MEO5lGD+ZfUVK0c44t1O53naffwZx9QmDmrC4TjeQrLOpAXLQ8GJHAGeZVmYRgkf
+OioKde5uuqVcxqNxArO8VyYGwsuNVPCaBV+SyIO+EmWogidSIrOP2WsRRS2NBhLV
+2dp3TvMeod9bPwRl00guvv9iqL0UVSpQSlfGkAQTVpyADOaQHOzeoCpmtPOfB6OK
+syB/Z/6HElKoUbvhynaASLgmo3wM93PVJQ2Ho294bQHtDl2qcOksJQvWfCgi7Zrt
+KuHaM/a2kItzI6JmyNFXgsKQSDJ4UvoppppgD7K48zOtSipGuZAADC5w5HdVvIGJ
+1Czva8kTcmC6AMc+4tACGqYZEAEokkeXn+pIIqKVj2eQukT/0dLGGHbKmxp3Z0f2
+pIH2Draq8JPdacr9P/xqEWUuViaOuC5OBjY8Fg3fmVCpwefIuk+DBhbJjEugB0Cu
+brJpqNznoYahkbyAXIA8T+QJYMhoGWmaIcaPWK6K3nArvaxzwJbb9Egyivhyp9Rr
+r2QMEZ+cPO8p1mEhKpL/wGqAzYyla8SJ06PzLc1lQeGiClu1nbZj5AgkZ1DLa8SD
+iO7+e6rS0q1bzc7smE5JzZRiOVqKij/ReKa2uebLLI4wgAhz5ymaD1HfZY+3dV9T
+WX89Xn2UyQf5kHifiDKL
+-----END CERTIFICATE-----

contrib/certificates/router/killyourtv_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFhTCCA22gAwIBAgIELuRWgDANBgkqhkiG9w0BAQ0FADBzMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEcMBoGA1UEAwwTa2lsbHlvdXJ0dkBt
+YWlsLmkycDAeFw0xMzEwMDYyMTM5MzFaFw0yMzEwMDYyMTM5MzFaMHMxCzAJBgNV
+BAYTAlhYMQswCQYDVQQIEwJYWDELMAkGA1UEBxMCWFgxHjAcBgNVBAoTFUkyUCBB
+bm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRwwGgYDVQQDDBNraWxseW91
+cnR2QG1haWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAig3u
+niLWm0y/TFJtciHgmWUt20FOdQrxkiSZ87G8xjuGfq7TbGIiVDn7pQZcHidpq+Dk
+47sm+Swqhb4psSijj0AXUEVKlV39jF5IZE+VUgmEtMqQbnBkWudaTJPWcEe9T/Kd
+8Oz2jgsnrD/EGVTMKBBjt/gk8VqTWvpCdCF1GhqcCeUTFHzjhN9jtoRCaJ2DClpO
+Px+86+d3s9PqUFo8gcD/dbbyJCMqUCMBLtIy/Ooouxb9cfWtXfyOlphU+enmdvuA
+0BDewb9pOJg2/kVd9/9moDWcBGChLOlfSlxpDwyUtcclcpvwnG7c6o4or6gqLeOf
+AbCpse623utV7fWlFWG7M4AQ/2emhhe4YoMJQnflydzV8bPRJxRTeW1j/9UfpvLT
+nO5LHp0oBXE0GqAPjxuAr+r5IDXFbkKYNjK5oWQB/Ul3LkexulYdCzHWbGd1Ja5b
+sbiOy6t/hH6G8DD75HYb+PQZaNZWBv90EyOq1JDSUPw6nxVbhiBldi3ipc8/1X51
+FbzBqJ+QO1XKrKqxWxBKoTekuy38KRzsmkSCpY+WJ9f0gLOKtxzVO2HNNqqVFGQf
+RGIbrNA0JSRQ1fgelccfrcRIXIZ3B8Tk/wxCIzCY6Yvg2jezz2xJkVdqOUsznS2v
++xJe67PYIAeMVtcfO4kmuCvyIYhsUEpob2n/5lkCAwEAAaMhMB8wHQYDVR0OBBYE
+FCLneov6QMtvra5FSoSLhdymi++rMA0GCSqGSIb3DQEBDQUAA4ICAQAIcqbiwjdQ
+M9VlGBiHe5eVsL6OM9zfRqR1wnRg4Q6ce65XDfEOYleBWaaNJA4BdykcA4fkUN1h
+M2D9FDQScsyPTOuzJ6o75TYh0JOtF51yCi9iuemcosxAwsm90ZXGuMDfDYeyND5c
+PAkWfyCP+jwLYbNo/hkNqyv+XWHXPQmT2adRnPXINVUQuBxVPC//C9wv2uDYWhgS
+f8M425VPp4/R/uks9mlzTx08DwacvouD0YOC+HZE4sWq+2smgeBInMiyr/THYzl+
+baMtYgVs8IKUD2gtjfXZoaQNg3eq5SedSf/5F0S/LCdu9/ccQ8CzSEoVTiQFtO78
+SaU37xai8+QTSVpPuINigxCoXmkubBd+voEmWRcBd/XB5L+u+MFU/jXyyBj2BXVj
+6agqVzY53KVYt23/63QliAUWyxT+ns9gRxVN1jrMhHdiDwsdT4NbzHxg1Su4eiHv
+C/wjD3Dga0BRTEGylpHZGzb1U1rZRHM3ho3f1QkmRPPLcBUMTyUTxJm+GEeuhPvp
++TBf3Kg/YkdpnEMlagqcyHuIrf3m8Z/pTmpOIbekJWbbA7tluvWbMWw2ARB7dUOE
+fHYVISh0DTw2oVXxM82/q8XXHnhEXv2nW3K40x1VabxUN+sF4M/7YA8nJqwsPJei
+749STYJRfZXdIe69M9zpM5unxENAsiPJgQ==
+-----END CERTIFICATE-----

contrib/certificates/router/str4d_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFezCCA2OgAwIBAgIEHLJfZzANBgkqhkiG9w0BAQ0FADBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOc3RyNGRAbWFpbC5p
+MnAwHhcNMTMxMDI2MTExODQxWhcNMjMxMDI2MTExODQxWjBuMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEXMBUGA1UEAwwOc3RyNGRAbWFpbC5p
+MnAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvw0vTay1IPOgxvwe8
+yt5jGakha20kw9qDb6zbEL87EWEkeOzdu7iUC69lkxVP9Ws8EbLtkeMf/CXg6CC1
+e+w8WpOHj5prOsiOlrIO+2I1tKMaMUuJDX2wK4I5ZSw/Kieimh9xqOBZknDmtwjw
+2HPW8rpxMqrScaGAP6sQD8Gh4XKKkLogfxYPzF8NnC6O8vBkFKVU2WSVZ0jPAQfv
+6luPdA+5lES+5UPWr9Yhv/CX4siGKUTxchqJRf2VU4o5BzzXae4asVA/NY7lKgEw
+eDDufbm0mRFWP4mbmXRlODuJ8GMnJbMQkNcAvZUnUcvpSTnGnIvxyxtXP5P6ic8V
+3b9HV2eIsbfO1xrgyr6/9qgGpXcdDJejhvNg6fZgQeO40bOGQYwV8bNvsNQHqnZl
+KsVhsMQkOubMxcHTBadcifi8PmdeJ5hxyyqJmyrwkmg2ijnN521M6YkoBzl+8VAi
+zLmqKZfvN5t+pb9PZ3U3jHfkeIEwDRYRAOsvVqch5+ZfSv8x/Te6o15zDKPJQtWK
+ty42GV1vERw30oSZQdrRRy/+4+HSRs3/Zb368OdAbcr+f/xPvwceYGWPeNNIoZ/x
+xkIQE3xgEK+eJyPM9McjlCAezZZclT7fWfiEYNJAiS3fGALi+a+cGYWWULxCXpz+
+y397OHhZBhnh7D9K8aPePB8tCwIDAQABoyEwHzAdBgNVHQ4EFgQUezvGHq3h1gbC
+Hs2LLVoll5fIUWMwDQYJKoZIhvcNAQENBQADggIBAF7SG1WBcE1r5eyTp/BLFZfG
+iPtvqu+B1L2HutPum/Xf8A5fxR4kcKAKpVdu6vnDzCRAsAC9YvyETgAzI2nfVgLk
+l9YZ31tSi6qxnMsQsV5o9lt/q2Rvsf2Zi/Ir8AlWtvnP8YG0Aj/8AG8MyhMLaIdj
+M2FuakPs8RqEjoJL9dTOC9VTQpNTwBH9guP9UalWYwlkaXDzMoyO4nswT/GpCpg8
+4m4RO6grzdsEIamD/PCBM5f/vq+y08GaqfXpX9+8CbaX3tdzd3x48wPphmdpkptk
+aRELIpLJZiK+Mos7W+0ZS8SHxGDIosjqVsgbZPmk12+VBcVgLOr8W1D7osS4OY59
+2GMUVV/GhoDh8wR/Td5wpZlcPE0NWmljjVg9+1E8ePAyMZy+U1KCiMlRVdRy518O
+dOzzUUQGqGQHosRrH0ypS3MGbMLmbuWFRiz7q/3mUmW2xikH9I1t/6ZMNUvh+IWL
+kGAaEf2JIv/D8+QsC0Un1W09DgvYz7qmKSeHhBixlLe68vgXtz/Fa+rRMsmPrueo
+4wk/u/VyILo0BJP860APJMZbm+DPfGhV9DF9L5Gx9+d/BlduBVGHc+AQSWbU70dS
+eH4/rgUYRikWlgwUxjY8/QQTlfx5xl28tG0xdO9libN22z7UwTGfm48BQIdrTyER
+hqQ7usTy3oaWD85MbJ0q
+-----END CERTIFICATE-----

contrib/certificates/router/zzz_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFdzCCA1+gAwIBAgIEcwrwsjANBgkqhkiG9w0BAQ0FADBsMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEVMBMGA1UEAwwMenp6QG1haWwuaTJw
+MB4XDTEzMDkzMDE3NDEyNVoXDTIzMDkzMDE3NDEyNVowbDELMAkGA1UEBhMCWFgx
+CzAJBgNVBAgTAlhYMQswCQYDVQQHEwJYWDEeMBwGA1UEChMVSTJQIEFub255bW91
+cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxFTATBgNVBAMMDHp6ekBtYWlsLmkycDCC
+AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJV4ptvhlfrcize9/ARz4lUy
+iLtLMSvSST1BdZjLJTwus05EUs0oiqnv9qXYIWGRB97aKlAmqSxsn4ZgBttCgmev
+IkuiZ8kbdqI5YaT98yKW5P2Prt9p9cPbnz5/qjwZ5L9W+k/Itx7bv2pkNEP0NLYo
+NrgHHTb1hsyRxc0lfPYk2BwsIi8hIWBHNrRpR41EWFXfqPcdsxS8cQhxVj4zLG/R
+aMm4H8T+V1R1Khl4R4qqRgXBP305xqqRoawHmZ/S9/RkF0Ji6IYwBq9iWthWol6W
+sMDn1xhZk9765fk+ohAC2XWuGSFCr02JOILRV3x/8OUxT1GYgYjc7FfyWIekg/pZ
+yotlhL2I3SMWOH3PdG58iDY121hq/LsSKM9aP20rwtvssnw+8Aex01YDkI3bM6yO
+HNi+tRojaJcJciBWv6cuiFKvQdxj/mOhOr0u0lHLlJ4jqES8uvVJkS7X/C4BB7ra
+bJYQgumZMYvVQJFIjo8vZxMXue53o65FRidvAUT29ay54UTiL7jRV9w1wHnzLapU
+xT1v7kWpWJcZ1zzC8coJjW+6ijkk38cVLb80u1Q4kEbmP2rDxw6jRvmqg6DcCKjK
+oqDt+XQ6P5grxAxLT+VMfB404WHHwNs6BB841//4ZnXvy3msMONY/5y0fsblURgh
+IS2UG1TAjR+x7+XikGx9AgMBAAGjITAfMB0GA1UdDgQWBBSvx/fCCP8UeHwjN65p
+EoHjgRfiIzANBgkqhkiG9w0BAQ0FAAOCAgEAYgVE1Aa/Ok5k+Jvujbx72bktRWXo
+Y4UfbWH/426VdgqXt3n9XtJUNM2oI4ODwITM4O15SyXQTLJhnvJz5ELcJV8nqviZ
+RjK2HNX1BW7IEta3tacCvVnjzZ265kCT59uW+qmd+5PiaAYI5lYUn8P6pe+6neSa
+HW6ecXCrdxJetSYfUUuKeV6YHpdzfjtZClLmwl91sJUBKcjK+Q9G/cE6HnwcDH1s
+uXr7SgkBt/qc/OlNuu4fnTqUA58TAumdq9cD+eLBilDFrux1HsUZMuBUp64x5oPi
+gme+3VewsczfFEtrxaG6+l6UA40Lerdx9XECZcDCcFsK6MS1uQ2HYjsyZcWnNT3l
+6eDNUbjrllwxDdRAk0cbWiMuc21CFq/1v2QMXk88EiBjEajqzyXUPmKzwFhit6pr
+5kfjfXNq+pxQSCoaqjpzVKjb3CqMhSlC8cLgrPw6HEgGnjCy4cTLFHlVmD64M778
+tj6rE7CntcmUi8GKmZKyaMyUo3QQUcrjO5IQ4+3iGUgMkZuujyjrZiOJbvircPmK
+4IQEXzJ/G00upqtqKstRybaWSbJ/k6iuturtA2n8MJiCBjhLy8dtTgDbFaDaNF7F
+NHeqQjIJDLhYDy6mi4gya3A0ort777Inl/rWYLo067pYM+EWDw66GdpbEIB0Bp71
+pwvcQcjIzbUzEK0=
+-----END CERTIFICATE-----

contrib/certificates/ssl/193.150.121.66.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDgDCCAmgCCQCAKEkFUJcEezANBgkqhkiG9w0BAQUFADCBgTELMAkGA1UEBhMC
+Tk8xDTALBgNVBAgMBE9zbG8xDTALBgNVBAcMBE9zbG8xDDAKBgNVBAoMA0kyUDEM
+MAoGA1UECwwDSTJQMRcwFQYDVQQDDA4xOTMuMTUwLjEyMS42NjEfMB0GCSqGSIb3
+DQEJARYQbWVlaEBpMnBtYWlsLm9yZzAeFw0xMzA2MjcxODM2MjhaFw0yMDA2MjUx
+ODM2MjhaMIGBMQswCQYDVQQGEwJOTzENMAsGA1UECAwET3NsbzENMAsGA1UEBwwE
+T3NsbzEMMAoGA1UECgwDSTJQMQwwCgYDVQQLDANJMlAxFzAVBgNVBAMMDjE5My4x
+NTAuMTIxLjY2MR8wHQYJKoZIhvcNAQkBFhBtZWVoQGkycG1haWwub3JnMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuBuFY4ZFvsbr5l1/s/GeUBLIWQLB
+nqrRkonrwCyxgjSnnG1uz/Z5nf6QDUjiVnFKMXenLaDn4KCmEi4LjWQllhK9r6pj
+BRkR7C0DTHq7WqfyvWnGSZZsOJDiH2vLlivV8N9oGdjxvv0N9No3AJcsmLYrxSLi
+6/JF8xZ2HGuT/oWW6aWvpIOKpIqti865BJw5P5KgYAS24J8vHRFM3FA4dfLNTBA2
+IGqPqYLQA+2zfOC4z01aArmcYnT1iJLT7krgKnr/BXdJfGQ2GjxkRSt8IwB6WmXA
+byz6QdNYM/0eubi102/zpD/DrySTU2kc8xKjknGUqBJvVdsL+iLK98uJrQIDAQAB
+MA0GCSqGSIb3DQEBBQUAA4IBAQCTimMu3X7+ztXxlIFhwGh42GfMjeBYT0NHOLAy
+ZtQNRqhNvkl3jZ4ERPLxP99+bcAfCX0wgVpgD32OWEZopwveRyMImP8HfFr4NnZ+
+edbM37fRYiVJv57kbi6O0rhEC7J5JF+fnCaZVLCuvYIrIXTdxTjvxuLhyan6Ej7V
+7iGDJ8t16tpLVJgcXfRg+dvAa6aDOK6x3w78j0bvh6rhvpOd9sW/Nk3LBKP4Xgkx
+PHkqm3hNfDIu8Hubeav9SA1kLVMS/uce52VyYMEDauObfC65ds0GRmCtYhZqMvj+
+FFCbssLraVJE9Hi/ZKGu33jNngDCG+wG+nmleksMYE1yTSRt
+-----END CERTIFICATE-----

contrib/certificates/ssl/i2p.mooo.com.crt

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIIDvjCCAyegAwIBAgICZhcwDQYJKoZIhvcNAQEFBQAwdTELMAkGA1UEBhMCVVMx
+DTALBgNVBAgMBG5vbmUxDTALBgNVBAcMBG5vbmUxDTALBgNVBAoMBG5vbmUxDTAL
+BgNVBAsMBG5vbmUxFTATBgNVBAMMDGkycC5tb29vLmNvbTETMBEGCSqGSIb3DQEJ
+ARYEbm9uZTAeFw0xMTEwMjMyMTM2NDFaFw0xOTEwMjMyMTM2NDFaMGYxCzAJBgNV
+BAYTAlVTMQ0wCwYDVQQIDARub25lMQ0wCwYDVQQKDARub25lMQ0wCwYDVQQLDARu
+b25lMRUwEwYDVQQDDAxpMnAubW9vby5jb20xEzARBgkqhkiG9w0BCQEWBG5vbmUw
+ggGPMA0GCSqGSIb3DQEBAQUAA4IBfAAwggF3AoIBbgMG1O7HRVa7UoiKbQTmKy5m
+x79Na8vjD3etcOwfc4TSenQFvn+GbAWkJwKpM8uvOcgj1CxNeHWdSaeTFH1OwJsw
+vl3leJ7clMdo3hpQDhPeGzBLyOiWwFHVn15YKa9xcM7S9Op5Q6rKBHUyyx1vGSz+
+/NBmkktpI6rcGFfP3ISRL0auR+db+adWv4TS6W8YiwQIVZNbSlKP6FNO9Mv1kxQZ
+KoHPn8vT/LtAh1fcI6ryBuy3F5oHfbGumIwsS5dpowryFxQzwg5vtMA7AMCMKyXv
+hP/W6OuaaEP5MCIxkWjQs35gOYa8eF1dLoy3AD9yVVhoNrA8Bc5FnVFJ32Qv7agy
+qRY85cXBA6hT/Qzs/wWwp7WrrnZuifaSv/u/Ayi5vX42/bf86PSM2IRNIESoA98A
+NFz4U2KGq9s1K2JbkQmnFy8IU0w7CMq6PvNEm/uNjSk6OE1rcCXML+EuX0zmXy8d
+PjRbLzC9csSg2CqMtQIDAQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQf
+Fh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUdjuOczdG
+hUpYzH0UXqKrOleT8GkwHwYDVR0jBBgwFoAU+SKWC49cM5sCodv89AFin3pkS0Yw
+DQYJKoZIhvcNAQEFBQADgYEAKYyWlDIStjjbn/ZzVScKR174I8whTbdqrX/vp9dr
+2hMv5m4F+aswX4Jr58WneKg2LvRaL6xEhoL7OAQ6aB/7xVSpDjIrrBLZd513NAam
+X6bOPYJ6IH7Vw9ClFY3AlfzsNlgRMXno7rySKKzhg24kusNwKDH2yCphZy4BgjMn
+y6A=
+-----END CERTIFICATE-----

contrib/certificates/ssl/i2p.mooo.com2.crt

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIIDvTCCAqWgAwIBAgIJAOeW0ejPrHimMA0GCSqGSIb3DQEBCwUAMHUxCzAJBgNV
+BAYTAlVTMQ0wCwYDVQQIDARub25lMQ0wCwYDVQQHDARub25lMQ0wCwYDVQQKDARu
+b25lMQ0wCwYDVQQLDARub25lMRUwEwYDVQQDDAxpMnAubW9vby5jb20xEzARBgkq
+hkiG9w0BCQEWBG5vbmUwHhcNMTUwMjA4MTczMzA5WhcNMTkwMzE5MTczMzA5WjB1
+MQswCQYDVQQGEwJVUzENMAsGA1UECAwEbm9uZTENMAsGA1UEBwwEbm9uZTENMAsG
+A1UECgwEbm9uZTENMAsGA1UECwwEbm9uZTEVMBMGA1UEAwwMaTJwLm1vb28uY29t
+MRMwEQYJKoZIhvcNAQkBFgRub25lMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAqxej7oRl9GOb8benIBCENrJXoow1iWhI9M+2nU0SaonrCDql5M2YMlwd
+HzYUWtFbRjz2NinjB0fgFq9cfzHfr1Sc8k/OeGg1jvNfqt8wWo9tryQNjiHtDQUZ
+6lQ5T13I+lj0CBasowgbApKQfrYjvaeuTaVYTfP8IVA60hoUQ+sy9JN+Unsx3/0Y
+PLLd98+bT27qYuBNRB1g/ifUTd9Wosj2PevGBlCxYDaUjmCG4Q8kcQr87KvM6RTu
+3AV61s/Wyy1j2YemlGG/ZhJ44YnlVMSu1vTjt9HInVf3lRRx/+RzbQO3lqeVC8LC
+Bq3KbSlfJVx4vHslfHwBFw9A4rmD1QIDAQABo1AwTjAdBgNVHQ4EFgQUsSUvX0ED
+yivB67iksVwZ+b8vLtQwHwYDVR0jBBgwFoAUsSUvX0EDyivB67iksVwZ+b8vLtQw
+DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAde4wts7Q8TylFEc38ftJ
+2f285fFIR7P1SSbBcHPK2eBwLEg0zJyFrCeiHuEpPrn+d5GqL2zOskjfcESGmDBT
+aFajj8jPBJj/AmpkdWJG6a1YKro5tu9wrlenGwHOHu2/Cl0IJvafxrOs2x4G+2Nl
+5Hcw/FIy8mK7eIch4pACfi0zNMZ6KMCKfX9bxPrQo78WdBfVjbrIBlgyOQJ5NJEF
+JlWvS7Butv7eERi4I2huN5VRJSCFzjbuO+tjP3I8IB6WgdBmTeqq8ObtXRgahBuD
+ZmkvqVSfIzK5JN4GjO8FOdCBomuwm9A92kgmAptwQwAHM9qCDJpH8L07/7poxlGb
+iA==
+-----END CERTIFICATE-----