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

.editorconfig

@@ -1,39 +0,0 @@
-# editorconfig.org
-
-root = true
-
-[*]
-# Unix style files
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[Makefile,Makefile.*]
-indent_style = tab
-indent_size = 4
-
-[*.cmd]
-indent_style = space
-indent_size = 2
-end_of_line = crlf
-
-[*.{h,cpp}]
-indent_style = tab
-indent_size = 4
-
-[*.rc]
-indent_style = space
-indent_size = 4
-
-[*.{md,markdown}]
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = false
-
-[*.yml]
-indent_style = space
-indent_size = 2
-
-[*.patch]
-trim_trailing_whitespace = false

.gitattributes

@@ -1 +0,0 @@
-/build/build_mingw.cmd eol=crlf

.github/workflows/build-deb.yml

@@ -1,61 +0,0 @@
-name: Build Debian packages
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build-deb.yml
-    - contrib/**
-    - daemon/**
-    - debian/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Makefile
-    - Makefile.linux
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-jobs:
-  build:
-    name: ${{ matrix.dist }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        dist: ['buster', 'bullseye', 'bookworm']
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Commit Hash
-      id: commit
-      uses: prompt/actions-commit-hash@v3.0.0
-
-    - name: Build package
-      uses: jtdor/build-deb-action@v1
-      with:
-        docker-image: debian:${{ matrix.dist }}-slim
-        buildpackage-opts: --build=binary --no-sign
-        before-build-hook: debchange --controlmaint --local "+${{ steps.commit.outputs.short }}~${{ matrix.dist }}" -b --distribution ${{ matrix.dist }} "CI build"
-        extra-build-deps: devscripts git
-
-    - name: Upload package
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd_${{ matrix.dist }}
-        path: debian/artifacts/i2pd_*.deb
-
-    - name: Upload debugging symbols
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-dbgsym_${{ matrix.dist }}
-        path: debian/artifacts/i2pd-dbgsym_*.deb

.github/workflows/build-freebsd.yml

@@ -1,50 +0,0 @@
-name: Build on FreeBSD
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build-freebsd.yml
-    - build/CMakeLists.txt
-    - build/cmake_modules/**
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Makefile
-    - Makefile.bsd
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: with UPnP
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Test in FreeBSD
-      id: test
-      uses: vmactions/freebsd-vm@v1
-      with:
-        usesh: true
-        mem: 2048
-        sync: rsync
-        copyback: 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
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-freebsd
-        path: build/i2pd

.github/workflows/build-osx.yml

@@ -1,45 +0,0 @@
-name: Build on OSX
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build-osx.yml
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Makefile
-    - Makefile.homebrew
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-jobs:
-  build:
-    name: With USE_UPNP=${{ matrix.with_upnp }}
-    runs-on: macOS-latest
-
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['yes', 'no']
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Install required formulae
-      run: |
-        find /usr/local/bin -lname '*/Library/Frameworks/Python.framework/*' -delete
-        brew update
-        brew install boost miniupnpc openssl@1.1
-
-    - name: List installed formulae
-      run: brew list
-
-    - name: Build application
-      run: make HOMEBREW=1 USE_UPNP=${{ matrix.with_upnp }} PREFIX=$GITHUB_WORKSPACE/output -j3

.github/workflows/build-windows-msvc.yml-disabled

@@ -1,80 +0,0 @@
-name: Build on Windows with MSVC
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build-windows-msvc.yml
-    - build/CMakeLists.txt
-    - build/cmake_modules/**
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Win32/**
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-jobs:
-  build:
-    name: Build
-    runs-on: windows-latest
-    env:
-      boost_path: ${{ github.workspace }}\boost_1_83_0
-      openssl_path: ${{ github.workspace }}\openssl_3_2_1
-
-    strategy:
-      fail-fast: false
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Build and install zlib
-      run: |
-        powershell -Command "(Invoke-WebRequest -Uri https://raw.githubusercontent.com/r4sas/zlib.install/master/install.bat -OutFile install_zlib.bat)"
-        powershell -Command "(Get-Content install_zlib.bat) | Set-Content install_zlib.bat" # fixing line endings
-        set BUILD_TYPE=Debug
-        ./install_zlib.bat
-        set BUILD_TYPE=Release
-        ./install_zlib.bat
-        del install_zlib.bat
-
-    - name: Install Boost
-      run: |
-        powershell -Command "(Start-BitsTransfer -Source https://sourceforge.net/projects/boost/files/boost-binaries/1.83.0/boost_1_83_0-msvc-14.3-64.exe/download -Destination boost_1_83_0-msvc-14.3-64.exe)"
-        ./boost_1_83_0-msvc-14.3-64.exe /DIR="${{env.boost_path}}" /VERYSILENT /SUPPRESSMSGBOXES /SP-
-
-    - name: Install OpenSSL
-      run: |
-        powershell -Command "(Start-BitsTransfer -Source https://slproweb.com/download/Win64OpenSSL-3_2_1.exe -Destination Win64OpenSSL-3_2_1.exe)"
-        ./Win64OpenSSL-3_2_1.exe /DIR="${{env.openssl_path}}" /TASKS="copytobin" /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /SP-
-
-    - name: Make copy of the OpenSSL libraries for CMake
-      run: |
-        dir ${{ github.workspace }}
-        dir ${{env.openssl_path}}\lib\VC
-        dir ${{env.openssl_path}}\lib\VC\x64\
-        dir ${{env.openssl_path}}\lib\VC\x64\MTd\
-        xcopy /s /y "${{env.openssl_path}}\lib\VC\x64\MTd" "${{env.openssl_path}}\lib"
-
-    - name: Configure
-      working-directory: build
-      run: cmake -DBoost_ROOT="${{env.boost_path}}" -DOPENSSL_ROOT_DIR="${{env.openssl_path}}" -DWITH_STATIC=ON .
-
-    - name: Build
-      working-directory: build
-      run: cmake --build . --config Debug -- -m
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-msvc
-        path: build/Debug/i2pd.*
-

.github/workflows/build-windows.yml

@@ -1,250 +0,0 @@
-name: Build on Windows
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build-windows.yml
-    - build/CMakeLists.txt
-    - build/cmake_modules/**
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Win32/**
-    - Makefile
-    - Makefile.mingw
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-defaults:
-  run:
-    shell: msys2 {0}
-
-jobs:
-  build:
-    name: ${{ matrix.arch }}
-    runs-on: windows-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include: [
-          { msystem: UCRT64, arch: ucrt-x86_64, arch_short: x64-ucrt, compiler: gcc },
-          { msystem: CLANG64, arch: clang-x86_64, arch_short: x64-clang, compiler: clang },
-          { msystem: MINGW64, arch: x86_64, arch_short: x64, compiler: gcc },
-          { msystem: MINGW32, arch: i686, arch_short: x86, compiler: gcc }
-        ]
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Setup MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.msystem }}
-        install: base-devel git mingw-w64-${{ matrix.arch }}-${{ matrix.compiler }} mingw-w64-${{ matrix.arch }}-boost mingw-w64-${{ matrix.arch }}-openssl mingw-w64-${{ matrix.arch }}-miniupnpc
-        update: true
-
-    - name: Install additional clang packages
-      if: ${{ matrix.msystem == 'CLANG64' }}
-      run: pacman --noconfirm -S mingw-w64-${{ matrix.arch }}-gcc-compat
-
-    - name: Build application
-      run: |
-        mkdir -p obj/Win32 obj/libi2pd obj/libi2pd_client obj/daemon
-        make USE_UPNP=yes DEBUG=no USE_GIT_VERSION=yes -j3
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-${{ matrix.arch_short }}.exe
-        path: i2pd.exe
-
-  build-cmake:
-    name: CMake ${{ matrix.arch }}
-    runs-on: windows-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include: [
-          { msystem: UCRT64, arch: ucrt-x86_64, arch_short: x64-ucrt, compiler: gcc },
-          { msystem: CLANG64, arch: clang-x86_64, arch_short: x64-clang, compiler: clang },
-          { msystem: MINGW64, arch: x86_64, arch_short: x64, compiler: gcc },
-          { msystem: MINGW32, arch: i686, arch_short: x86, compiler: gcc }
-        ]
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Setup MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.msystem }}
-        install: base-devel git mingw-w64-${{ matrix.arch }}-cmake mingw-w64-${{ matrix.arch }}-ninja mingw-w64-${{ matrix.arch }}-${{ matrix.compiler }} mingw-w64-${{ matrix.arch }}-boost mingw-w64-${{ matrix.arch }}-openssl mingw-w64-${{ matrix.arch }}-miniupnpc
-        update: true
-
-    - name: Build application
-      run: |
-        cd build
-        cmake -DWITH_GIT_VERSION=ON -DWITH_STATIC=ON -DWITH_UPNP=ON -DCMAKE_BUILD_TYPE=Release .
-        cmake --build . -- -j3
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-cmake-${{ matrix.arch_short }}.exe
-        path: build/i2pd.exe
-
-  build-xp:
-    name: XP
-    runs-on: windows-latest
-
-    strategy:
-        fail-fast: false
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Setup MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: MINGW32
-        install: base-devel git mingw-w64-i686-gcc mingw-w64-i686-boost mingw-w64-i686-openssl mingw-w64-i686-miniupnpc
-        cache: true
-        update: true
-
-    - name: Clone MinGW packages repository and revert boost to 1.85.0
-      run: |
-        git clone https://github.com/msys2/MINGW-packages
-        cd MINGW-packages
-        git checkout 4cbb366edf2f268ac3146174b40ce38604646fc5 mingw-w64-boost
-        cd mingw-w64-boost
-        sed -i 's/boostorg.jfrog.io\/artifactory\/main/archives.boost.io/' PKGBUILD
-
-    # headers
-    - name: Get headers package version
-      id:  version-headers
-      run: |
-        echo "version=$(pacman -Si mingw-w64-i686-headers-git | grep -Po '^Version\s*: \K.+')" >> $GITHUB_OUTPUT
-    - name: Cache headers package
-      uses: actions/cache@v4
-      id: cache-headers
-      with:
-        path: MINGW-packages/mingw-w64-headers-git/*.zst
-        key: winxp-headers-${{ steps.version-headers.outputs.version }}
-    - name: Build WinXP-capable headers package
-      if: steps.cache-headers.outputs.cache-hit != 'true'
-      run: |
-        cd MINGW-packages/mingw-w64-headers-git
-        sed -i 's/0x601/0x501/' PKGBUILD
-        MINGW_ARCH=mingw32 makepkg-mingw -sCLf --noconfirm --nocheck
-    - name: Install headers package
-      run: pacman --noconfirm -U MINGW-packages/mingw-w64-headers-git/mingw-w64-i686-*-any.pkg.tar.zst
-
-    # CRT
-    - name: Get crt package version
-      id:  version-crt
-      run: |
-        echo "version=$(pacman -Si mingw-w64-i686-crt-git | grep -Po '^Version\s*: \K.+')" >> $GITHUB_OUTPUT
-    - name: Cache crt package
-      uses: actions/cache@v4
-      id: cache-crt
-      with:
-        path: MINGW-packages/mingw-w64-crt-git/*.zst
-        key: winxp-crt-${{ steps.version-crt.outputs.version }}
-    - name: Build WinXP-capable crt package
-      if: steps.cache-crt.outputs.cache-hit != 'true'
-      run: |
-        cd MINGW-packages/mingw-w64-crt-git
-        MINGW_ARCH=mingw32 makepkg-mingw -sCLf --noconfirm --nocheck
-    - name: Install crt package
-      run: pacman --noconfirm -U MINGW-packages/mingw-w64-crt-git/mingw-w64-i686-*-any.pkg.tar.zst
-
-    # winpthreads
-    - name: Get winpthreads package version
-      id:  version-winpthreads
-      run: |
-        echo "version=$(pacman -Si mingw-w64-i686-winpthreads-git | grep -Po '^Version\s*: \K.+')" >> $GITHUB_OUTPUT
-    - name: Cache winpthreads package
-      uses: actions/cache@v4
-      id: cache-winpthreads
-      with:
-        path: MINGW-packages/mingw-w64-winpthreads-git/*.zst
-        key: winxp-winpthreads-${{ steps.version-winpthreads.outputs.version }}
-    - name: Build WinXP-capable winpthreads package
-      if: steps.cache-winpthreads.outputs.cache-hit != 'true'
-      run: |
-        cd MINGW-packages/mingw-w64-winpthreads-git
-        MINGW_ARCH=mingw32 makepkg-mingw -sCLf --noconfirm --nocheck
-    - name: Install winpthreads package
-      run: pacman --noconfirm -U MINGW-packages/mingw-w64-winpthreads-git/mingw-w64-i686-*-any.pkg.tar.zst
-
-    # OpenSSL
-    - name: Get openssl package version
-      id:  version-openssl
-      run: |
-        echo "version=$(pacman -Si mingw-w64-i686-openssl | grep -Po '^Version\s*: \K.+')" >> $GITHUB_OUTPUT
-    - name: Cache openssl package
-      uses: actions/cache@v4
-      id: cache-openssl
-      with:
-        path: MINGW-packages/mingw-w64-openssl/*.zst
-        key: winxp-openssl-${{ steps.version-openssl.outputs.version }}
-    - name: Build WinXP-capable openssl package
-      if: steps.cache-openssl.outputs.cache-hit != 'true'
-      run: |
-        cd MINGW-packages/mingw-w64-openssl
-        gpg --recv-keys D894E2CE8B3D79F5
-        gpg --recv-keys 216094DFD0CB81EF
-        MINGW_ARCH=mingw32 makepkg-mingw -sCLf --noconfirm --nocheck
-    - name: Install openssl package
-      run: pacman --noconfirm -U MINGW-packages/mingw-w64-openssl/mingw-w64-i686-*-any.pkg.tar.zst
-
-    # Boost
-    #- name: Get boost package version
-    #  id:  version-boost
-    #  run: |
-    #    echo "version=$(pacman -Si mingw-w64-i686-boost | grep -Po '^Version\s*: \K.+')" >> $GITHUB_OUTPUT
-    - name: Cache boost package
-      uses: actions/cache@v4
-      id: cache-boost
-      with:
-        path: MINGW-packages/mingw-w64-boost/*.zst
-        key: winxp-boost-1.85.0+crt-${{ steps.version-headers.outputs.version }}+ossl-${{ steps.version-openssl.outputs.version }}
-    # Rebuild package if packages above has changed
-    - name: Build WinXP-capable boost package
-      if: steps.cache-boost.outputs.cache-hit != 'true'
-      run: |
-        cd MINGW-packages/mingw-w64-boost
-        MINGW_ARCH=mingw32 makepkg-mingw -sCLf --noconfirm --nocheck
-    - name: Remove boost packages
-      run: pacman --noconfirm -R mingw-w64-i686-boost mingw-w64-i686-boost-libs
-    - name: Install boost package
-      run: pacman --noconfirm -U MINGW-packages/mingw-w64-boost/mingw-w64-i686-*-any.pkg.tar.zst
-
-    # Building i2pd
-    - name: Build application
-      run: |
-        mkdir -p obj/Win32 obj/libi2pd obj/libi2pd_client obj/daemon
-        make USE_UPNP=yes DEBUG=no USE_GIT_VERSION=yes USE_WINXP_FLAGS=yes -j3
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: i2pd-xp.exe
-        path: i2pd.exe

.github/workflows/build.yml

@@ -1,67 +0,0 @@
-name: Build on Ubuntu
-
-on:
-  push:
-    branches:
-    - '*'
-    paths:
-    - .github/workflows/build.yml
-    - build/CMakeLists.txt
-    - build/cmake_modules/**
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Makefile
-    - Makefile.linux
-    tags:
-    - '*'
-  pull_request:
-    branches:
-    - '*'
-
-jobs:
-  build-make:
-    name: Make with USE_UPNP=${{ matrix.with_upnp }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['yes', 'no']
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: install packages
-      run: |
-        sudo apt-get update
-        sudo apt-get install build-essential libboost-all-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-latest
-
-    strategy:
-      fail-fast: true
-      matrix:
-        with_upnp: ['ON', 'OFF']
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: install packages
-      run: |
-        sudo apt-get update
-        sudo apt-get install build-essential cmake libboost-all-dev libminiupnpc-dev libssl-dev zlib1g-dev
-
-    - name: build application
-      run: |
-        cd build
-        cmake -DWITH_UPNP=${{ matrix.with_upnp }} .
-        make -j3

.github/workflows/docker.yml

@@ -1,140 +0,0 @@
-name: Build containers
-
-on:
-  push:
-    branches:
-    - openssl
-    - docker
-    paths:
-    - .github/workflows/docker.yml
-    - contrib/docker/**
-    - contrib/certificates/**
-    - daemon/**
-    - i18n/**
-    - libi2pd/**
-    - libi2pd_client/**
-    - Makefile
-    - Makefile.linux
-    tags:
-    - '*'
-
-jobs:
-  build:
-    name: Building container for ${{ matrix.platform }}
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-
-    strategy:
-      matrix:
-        include: [
-          { platform: 'linux/amd64', archname: 'amd64' },
-          { platform: 'linux/386', archname: 'i386' },
-          { platform: 'linux/arm64', archname: 'arm64' },
-          { platform: 'linux/arm/v7', archname: 'armv7' },
-        ]
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v3
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-
-    - name: Login to DockerHub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-    - name: Login to GitHub Container registry
-      uses: docker/login-action@v3
-      with:
-        registry: ghcr.io
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-
-    - name: Build container for ${{ matrix.archname }}
-      uses: docker/build-push-action@v5
-      with:
-        context: ./contrib/docker
-        file: ./contrib/docker/Dockerfile
-        platforms: ${{ matrix.platform }}
-        push: true
-        tags: |
-          purplei2p/i2pd:latest-${{ matrix.archname }}
-          ghcr.io/purplei2p/i2pd:latest-${{ matrix.archname }}
-        provenance: false
-
-  push:
-    name: Pushing merged manifest
-    runs-on: ubuntu-latest
-
-    permissions:
-      packages: write
-      contents: read
-
-    needs: build
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v3
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-
-    - name: Login to DockerHub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-    - name: Login to GitHub Container registry
-      uses: docker/login-action@v3
-      with:
-        registry: ghcr.io
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-
-    - name: Create and push latest manifest image to Docker Hub
-      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
-      uses: Noelware/docker-manifest-action@master
-      with:
-        inputs: purplei2p/i2pd:latest
-        images: purplei2p/i2pd:latest-amd64,purplei2p/i2pd:latest-i386,purplei2p/i2pd:latest-arm64,purplei2p/i2pd:latest-armv7
-        push: true
-
-    - name: Create and push latest manifest image to GHCR
-      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
-      uses: Noelware/docker-manifest-action@master
-      with:
-        inputs: ghcr.io/purplei2p/i2pd:latest
-        images: ghcr.io/purplei2p/i2pd:latest-amd64,ghcr.io/purplei2p/i2pd:latest-i386,ghcr.io/purplei2p/i2pd:latest-arm64,ghcr.io/purplei2p/i2pd:latest-armv7
-        push: true
-
-    - name: Store release version to env
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      run: echo "RELEASE_VERSION=${GITHUB_REF:10}" >> $GITHUB_ENV
-
-    - name: Create and push release manifest to Docker Hub
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      uses: Noelware/docker-manifest-action@master
-      with:
-        inputs: purplei2p/i2pd:latest,purplei2p/i2pd:latest-release,purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}
-        images: purplei2p/i2pd:latest-amd64,purplei2p/i2pd:latest-i386,purplei2p/i2pd:latest-arm64,purplei2p/i2pd:latest-armv7
-        push: true
-
-    - name: Create and push release manifest to GHCR
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      uses: Noelware/docker-manifest-action@master
-      with:
-        inputs: ghcr.io/purplei2p/i2pd:latest,ghcr.io/purplei2p/i2pd:latest-release,ghcr.io/purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}
-        images: ghcr.io/purplei2p/i2pd:latest-amd64,ghcr.io/purplei2p/i2pd:latest-i386,ghcr.io/purplei2p/i2pd:latest-arm64,ghcr.io/purplei2p/i2pd:latest-armv7
-        push: true

.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,39 +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
-debian/i2pd.1.gz
-.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()

LICENSE

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

Makefile

@@ -1,189 +0,0 @@
-.DEFAULT_GOAL := all
-
-SYS := $(shell $(CXX) -dumpmachine)
-
-ifneq (, $(findstring darwin, $(SYS)))
-	SHARED_SUFFIX = dylib
-else ifneq (, $(findstring mingw, $(SYS))$(findstring windows-gnu, $(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_STATIC      := $(or $(USE_STATIC),no)
-USE_UPNP        := $(or $(USE_UPNP),no)
-DEBUG           := $(or $(DEBUG),yes)
-
-# for debugging purposes only, when commit hash needed in trunk builds in i2pd version string
-USE_GIT_VERSION := $(or $(USE_GIT_VERSION),no)
-
-# for MacOS only, waiting for "1", not "yes"
-HOMEBREW        := $(or $(HOMEBREW),0)
-
-ifeq ($(DEBUG),yes)
-	CXX_DEBUG = -g
-else
-	CXX_DEBUG = -Os
-	LD_DEBUG = -s
-endif
-
-ifneq (, $(DESTDIR))
-	PREFIX = $(DESTDIR)
-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 mingw, $(SYS))$(findstring windows-gnu, $(SYS))$(findstring cygwin, $(SYS)))
-	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32App.cpp Win32/Win32Service.cpp Win32/Win32NetState.cpp
-	include Makefile.mingw
-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 haiku, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
-	include Makefile.haiku
-else # not supported
-	$(error Not supported platform)
-endif
-
-INCFLAGS += -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR) -I$(LANG_SRC_DIR)
-DEFINES += -DOPENSSL_SUPPRESS_DEPRECATED
-NEEDED_CXXFLAGS += -MMD -MP
-
-ifeq ($(USE_GIT_VERSION),yes)
-	GIT_VERSION := $(shell git describe --tags)
-	DEFINES += -DGITVER=$(GIT_VERSION)
-endif
-
-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) $(DEFINES) $(INCFLAGS) -c -o $@ $<
-
-# '-' is 'ignore if missing' on first run
--include $(DEPS)
-
-$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG)
-	$(CXX) $(DEFINES) $(LDFLAGS) -o $@ $^ $(LDLIBS)
-
-$(SHLIB): $(LIB_OBJS)
-ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
-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,22 +0,0 @@
-CXX = clang++
-CXXFLAGS ?= ${CXX_DEBUG} -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-misleading-indentation
-DEFINES = -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 = -lssl -lcrypto -lz -lpthread -lboost_system -lboost_program_options
-
-## 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.
-CXXVER := $(shell $(CXX) -dumpversion|cut -c 1-2)
-ifeq (${CXXVER}, "4.") # older clang always returned 4.2.1
-	$(error Compiler too old)
-else ifeq (${CXXVER}, ${filter ${CXXVER},16 17 18 19})  # clang 16 - 19
-	NEEDED_CXXFLAGS = -std=c++20
-else
-	NEEDED_CXXFLAGS = -std=c++17
-endif
-

Makefile.haiku

@@ -1,10 +0,0 @@
-CXX = g++
-CXXFLAGS := -Wall -std=c++17
-INCFLAGS = -I/system/develop/headers
-DEFINES = -D_DEFAULT_SOURCE -D_GNU_SOURCE
-LDLIBS = -lbe -lbsd -lnetwork -lz -lssl -lcrypto -lboost_system -lboost_program_options -lpthread
-
-ifeq ($(USE_UPNP),yes)
-	DEFINES += -DUSE_UPNP
-	LDLIBS += -lminiupnpc
-endif

Makefile.homebrew

@@ -1,49 +0,0 @@
-# root directory holding homebrew
-BREWROOT = /opt/homebrew
-BOOSTROOT = ${BREWROOT}/opt/boost
-SSLROOT = ${BREWROOT}/opt/openssl@1.1
-UPNPROOT = ${BREWROOT}/opt/miniupnpc
-
-CXXFLAGS ?= ${CXX_DEBUG} -Wall -Wno-overloaded-virtual
-NEEDED_CXXFLAGS ?= -std=c++17
-INCFLAGS ?= -I${SSLROOT}/include -I${BOOSTROOT}/include
-LDFLAGS ?= ${LD_DEBUG}
-DEFINES += -DMAC_OSX
-
-ifeq ($(USE_STATIC),yes)
-	LDLIBS = -lz ${SSLROOT}/lib/libcrypto.a ${SSLROOT}/lib/libssl.a ${BOOSTROOT}/lib/libboost_system.a ${BOOSTROOT}/lib/libboost_filesystem.a ${BOOSTROOT}/lib/libboost_program_options.a
-ifeq ($(USE_UPNP),yes)
-	LDLIBS += ${UPNPROOT}/lib/libminiupnpc.a
-endif
-	LDLIBS +=  -lpthread -ldl
-else
-	LDFLAGS += -L${SSLROOT}/lib -L${BOOSTROOT}/lib
-	LDLIBS = -lz -lssl -lcrypto -lboost_system -lboost_filesystem -lboost_program_options -lpthread
-ifeq ($(USE_UPNP),yes)
-	LDFLAGS += -L${UPNPROOT}/lib
-	LDLIBS += -lminiupnpc
-endif
-endif
-
-ifeq ($(USE_UPNP),yes)
-	DEFINES += -DUSE_UPNP
-	INCFLAGS += -I${UPNPROOT}/include
-endif
-
-install: all
-	install -d ${PREFIX}/bin
-	install -m 755 ${I2PD} ${PREFIX}/bin
-	install -d ${PREFIX}/etc ${PREFIX}/etc/i2pd ${PREFIX}/etc/i2pd/tunnels.conf.d
-	install -m 644 contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/etc/i2pd
-	install -d ${PREFIX}/share ${PREFIX}/share/doc ${PREFIX}/share/doc/i2pd
-	install -m 644 ChangeLog LICENSE README.md contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/share/doc/i2pd
-	install -d ${PREFIX}/share/i2pd
-	@cp -R contrib/certificates ${PREFIX}/share/i2pd/
-	install -d ${PREFIX}/share/man ${PREFIX}/share/man/man1
-	@gzip -kf debian/i2pd.1 && install debian/i2pd.1.gz ${PREFIX}/share/man/man1
-	install -d ${PREFIX}/var ${PREFIX}/var/lib ${PREFIX}/var/lib/i2pd
-	@ln -sf ${PREFIX}/share/i2pd/certificates ${PREFIX}/var/lib/i2pd/certificates
-	@ln -sf ${PREFIX}/etc/i2pd/tunnels.conf.d ${PREFIX}/var/lib/i2pd/tunnels.d
-	@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,70 +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++17 support by compilers
-CXXVER := $(shell $(CXX) -dumpversion)
-ifeq ($(shell expr match $(CXX) 'clang'),5)
-	NEEDED_CXXFLAGS += -std=c++17
-else ifeq ($(shell expr match ${CXXVER} "[8-9]"),1) # gcc 8 - 9
-	NEEDED_CXXFLAGS += -std=c++17
-	LDLIBS = -lboost_system -lstdc++fs
-else ifeq ($(shell expr match ${CXXVER} "1[0-2]"),2) # gcc 10 - 12
-	NEEDED_CXXFLAGS += -std=c++17
-else ifeq ($(shell expr match ${CXXVER} "1[3-9]"),2) # gcc 13+
-	NEEDED_CXXFLAGS += -std=c++20
-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_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 += -lssl -lcrypto -lz -lboost_program_options -lpthread -latomic
-ifeq ($(USE_UPNP),yes)
-	LDLIBS += -lminiupnpc
-endif
-endif
-
-# UPNP Support (miniupnpc 1.5 and higher)
-ifeq ($(USE_UPNP),yes)
-	DEFINES += -DUSE_UPNP
-endif
-
-install: all
-	install -d ${PREFIX}/bin
-	install -m 755 ${I2PD} ${PREFIX}/bin
-	install -d ${PREFIX}/etc ${PREFIX}/etc/i2pd ${PREFIX}/etc/i2pd/tunnels.conf.d
-	install -m 644 contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/etc/i2pd
-	install -d ${PREFIX}/share ${PREFIX}/share/doc ${PREFIX}/share/doc/i2pd
-	install -m 644 ChangeLog LICENSE README.md contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/share/doc/i2pd
-	install -d ${PREFIX}/share/i2pd
-	@cp -R contrib/certificates ${PREFIX}/share/i2pd/
-	install -d ${PREFIX}/share/man ${PREFIX}/share/man/man1
-	@gzip -kf debian/i2pd.1 && install debian/i2pd.1.gz ${PREFIX}/share/man/man1
-	install -d ${PREFIX}/var ${PREFIX}/var/lib ${PREFIX}/var/lib/i2pd
-	@ln -sf ${PREFIX}/share/i2pd/certificates ${PREFIX}/var/lib/i2pd/certificates
-	@ln -sf ${PREFIX}/etc/i2pd/tunnels.conf.d ${PREFIX}/var/lib/i2pd/tunnels.d
-	@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.mingw

@@ -1,50 +0,0 @@
-# Build application with GUI (tray, main window)
-USE_WIN32_APP := yes
-
-WINDRES = windres
-
-CXXFLAGS := $(CXX_DEBUG) -fPIC -msse
-INCFLAGS := -I$(DAEMON_SRC_DIR) -IWin32
-LDFLAGS := ${LD_DEBUG} -static -fPIC -msse
-
-NEEDED_CXXFLAGS += -std=c++20
-DEFINES += -DWIN32_LEAN_AND_MEAN
-
-# UPNP Support
-ifeq ($(USE_UPNP),yes)
-	DEFINES += -DUSE_UPNP -DMINIUPNP_STATICLIB
-	LDLIBS = -lminiupnpc
-endif
-
-ifeq ($(USE_WINXP_FLAGS), yes)
-	DEFINES += -DWINVER=0x0501 -D_WIN32_WINNT=0x0501
-endif
-
-LDLIBS += \
-	$(MINGW_PREFIX)/lib/libboost_filesystem-mt.a \
-	$(MINGW_PREFIX)/lib/libboost_program_options-mt.a \
-	$(MINGW_PREFIX)/lib/libssl.a \
-	$(MINGW_PREFIX)/lib/libcrypto.a \
-	$(MINGW_PREFIX)/lib/libz.a \
-	-lwsock32 \
-	-lws2_32 \
-	-liphlpapi \
-	-lcrypt32 \
-	-lgdi32 \
-	-lole32 \
-	-luuid \
-	-lpthread
-
-ifeq ($(USE_WIN32_APP), yes)
-	DEFINES += -DWIN32_APP
-	LDFLAGS += -mwindows
-	DAEMON_RC += Win32/Resource.rc
-	DAEMON_OBJS += $(patsubst %.rc,obj/%.o,$(DAEMON_RC))
-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) $(DEFINES) $(INCFLAGS) --preprocessor-arg=-MMD --preprocessor-arg=-MP --preprocessor-arg=-MF$@.d -i $< -o $@

Makefile.osx

@@ -1,29 +0,0 @@
-CXX = clang++
-CXXFLAGS := ${CXX_DEBUG} -Wall -std=c++17
-INCFLAGS = -I/usr/local/include
-DEFINES := -DMAC_OSX
-LDFLAGS := -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-LDFLAGS += -Wl,-dead_strip
-LDFLAGS += -Wl,-dead_strip_dylibs
-
-ifeq ($(USE_STATIC),yes)
-	LDLIBS = -lz /usr/local/lib/libssl.a /usr/local/lib/libcrypto.a /usr/local/lib/libboost_system.a /usr/local/lib/libboost_filesystem.a /usr/local/lib/libboost_program_options.a -lpthread
-else
-	LDLIBS = -lz -lssl -lcrypto -lboost_system -lboost_filesystem -lboost_program_options -lpthread
-endif
-
-ifeq ($(USE_UPNP),yes)
-	LDFLAGS += -ldl
-	DEFINES += -DUSE_UPNP
-	ifeq ($(USE_STATIC),yes)
-		LDLIBS += /usr/local/lib/libminiupnpc.a
-	else
-		LDLIBS += -lminiupnpc
-	endif
-endif
-
-OSARCH = $(shell uname -p)
-
-ifneq ($(OSARCH),powerpc)
-	CXXFLAGS += -msse
-endif

README.md

@@ -1,124 +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 (Debian, Ubuntu, etc) - [![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, 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 - [![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 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
----------
-
-**E-Mail**: ```i2porignal at yandex.com```
-
-**BTC**: ```3MDoGJW9TLMTCDGrR9bLgWXfm6sjmgy86f```
-
-**LTC**: ```LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59```
-
-**ETH**: ```0x9e5bac70d20d1079ceaa111127f4fb3bccce379d```
-
-**GST**: ```GbD2JSQHBHCKLa9WTHmigJRpyFgmBj4woG```
-
-**DASH**: ```Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF```
-
-**ZEC**: ```t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ```
-
-**ANC**: ```AQJYweYYUqM1nVfLqfoSMpUMfzxvS4Xd7z```
-
-**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,103 +0,0 @@
-/*
-* Copyright (c) 2013-2023, 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
-#include "Win32Service.h"
-#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;
-
-		if (isDaemon)
-		{
-			LogPrint(eLogDebug, "Daemon: running as service");
-			I2PService service((PSTR)SERVICE_NAME);
-			if (!I2PService::Run(service))
-			{
-				LogPrint(eLogCritical, "Daemon: Service failed to run w/err 0x%08lx\n", GetLastError());
-				return false;
-			}
-			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 (isDaemon)) 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 "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-2023, 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,502 +0,0 @@
-/*
-* Copyright (c) 2013-2024, 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_DATADIR 2009
-
-#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;
-	bool g_isWinService;
-
-	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_DATADIR, "Open &datadir");
-		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, bool testing, RouterError error)
-	{
-		switch (status)
-		{
-			case eRouterStatusOK: s << "OK"; break;
-			case eRouterStatusFirewalled: s << "FW"; break;
-			case eRouterStatusUnknown: s << "Unk"; break;
-			case eRouterStatusProxy: s << "Proxy"; break;
-			case eRouterStatusMesh: s << "Mesh"; break;
-			default: s << "Unk";
-		};
-		if (testing)
-			s << " (Test)";
-		if (error != eRouterErrorNone)
-		{
-			switch (error)
-			{
-				case eRouterErrorClockSkew:
-					s << " - " << tr("Clock skew");
-				break;
-				case eRouterErrorOffline:
-					s << " - " << tr("Offline");
-				break;
-				case eRouterErrorSymmetricNAT:
-					s << " - " << tr("Symmetric NAT");
-				break;
-				case eRouterErrorFullConeNAT:
-					s << " - " << tr("Full cone NAT");
-				break;
-				case eRouterErrorNoDescriptors:
-					s << " - " << tr("No Descriptors");
-				break;
-				default: ;
-			}
-		}
-	}
-
-	static void PrintMainWindowText (std::stringstream& s)
-	{
-		s << "\n";
-		s << "Status: ";
-		ShowNetworkStatus (s, i2p::context.GetStatus (), i2p::context.GetTesting(), i2p::context.GetError ());
-		if (i2p::context.SupportsV6 ())
-		{
-			s << " / ";
-			ShowNetworkStatus (s, i2p::context.GetStatusV6 (), i2p::context.GetTestingV6(), i2p::context.GetErrorV6 ());
-		}
-		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;
-					}
-					case ID_DATADIR:
-					{
-						std::string datadir(i2p::fs::GetDataDir());
-						ShellExecute(NULL, "explore", datadir.c_str(), NULL, NULL, SW_SHOWNORMAL);
-						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;
-						}
-					}
-				}
-				[[fallthrough]];
-			}
-			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 (bool isWinService)
-	{
-		g_isWinService = isWinService;
-		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;
-		}
-		// COM requires message loop to work, which is not implemented in service mode
-		if (!g_isWinService)
-			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);
-		else if(!g_isWinService)
-			UnSubscribeFromEvents();
-		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 (bool isWinService);
-	void StopWin32App ();
-	int RunWin32App ();
-	bool GracefulShutdown ();
-	bool StopGracefulShutdown ();
-}
-}
-#endif // WIN32APP_H__

Win32/Win32NetState.cpp

@@ -1,103 +0,0 @@
-/*
-* Copyright (c) 2013-2024, 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;
-CNetworkListManagerEvent *pNetEvent = 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;
-#if defined(_MSC_VER)
-			Result = pNetworkListManager->get_IsConnectedToInternet(&IsConnect);
-#else
-			Result = pNetworkListManager->IsConnectedToInternet(&IsConnect);
-#endif
-			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))
-				{
-					pNetEvent = new CNetworkListManagerEvent;
-					Result = pConnectPoint->Advise((IUnknown *)pNetEvent, &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()
-{
-	LogPrint(eLogInfo, "NetState: Unsubscribing from NetworkListManagerEvents");
-	try
-	{
-		if (pConnectPoint) {
-			pConnectPoint->Unadvise(Cookie);
-			pConnectPoint->Release();
-		}
-
-		if (pNetEvent)
-		{
-			pNetEvent->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,92 +0,0 @@
-/*
-* Copyright (c) 2013-2024, 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 final : public INetworkListManagerEvents
-{
-public:
-	CNetworkListManagerEvent() : m_ref(1) { }
-	~CNetworkListManagerEvent() { }
-
-	HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
-	{
-		if (IsEqualIID(riid, IID_IUnknown)) {
-			*ppvObject = (IUnknown *)this;
-		} else if (IsEqualIID(riid ,IID_INetworkListManagerEvents)) {
-			*ppvObject = (INetworkListManagerEvents *)this;
-		} else {
-			return E_NOINTERFACE;
-		}
-		AddRef();
-		return S_OK;
-	}
-
-	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/Win32Service.cpp

@@ -1,283 +0,0 @@
-/*
-* Copyright (c) 2013-2022, 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 "Win32Service.h"
-#include <assert.h>
-#include <windows.h>
-
-#include "Daemon.h"
-#include "Log.h"
-
-I2PService *I2PService::s_service = NULL;
-
-BOOL I2PService::isService()
-{
-	BOOL bIsService = FALSE;
-	HWINSTA hWinStation = GetProcessWindowStation();
-	if (hWinStation != NULL)
-	{
-		USEROBJECTFLAGS uof = { FALSE, FALSE, 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) ? (PSTR)"" : 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(eLogCritical, "Win32Service: Start error: ", dwError);
-		SetServiceStatus(SERVICE_STOPPED, dwError);
-	}
-	catch (...)
-	{
-		LogPrint(eLogCritical, "Win32Service: failed to start: ", EVENTLOG_ERROR_TYPE);
-		SetServiceStatus(SERVICE_STOPPED);
-	}
-}
-
-void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
-{
-	LogPrint(eLogInfo, "Win32Service: in OnStart (", EVENTLOG_INFORMATION_TYPE, ")");
-	Daemon.start();
-	_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(eLogInfo, "Win32Service: Stop error: ", dwError);
-		SetServiceStatus(dwOriginalState);
-	}
-	catch (...)
-	{
-		LogPrint(eLogCritical, "Win32Service: Failed to stop: ", EVENTLOG_ERROR_TYPE);
-		SetServiceStatus(dwOriginalState);
-	}
-}
-
-void I2PService::OnStop()
-{
-	// Log a service stop message to the Application log.
-	LogPrint(eLogInfo, "Win32Service: in OnStop (", EVENTLOG_INFORMATION_TYPE, ")");
-	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(eLogCritical, "Win32Service: Pause error: ", dwError);
-		SetServiceStatus(SERVICE_RUNNING);
-	}
-	catch (...)
-	{
-		LogPrint(eLogCritical, "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(eLogCritical, "Win32Service: Continue error: ", dwError);
-		SetServiceStatus(SERVICE_PAUSED);
-	}
-	catch (...)
-	{
-		LogPrint(eLogCritical, "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(eLogCritical, "Win32Service: Shutdown error: ", dwError);
-	}
-	catch (...)
-	{
-		LogPrint(eLogCritical, "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;
-	}
-}

Win32/Win32Service.h

@@ -1,63 +0,0 @@
-/*
-* Copyright (c) 2013-2022, 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_SERVICE_H__
-#define WIN_32_SERVICE_H__
-
-#include <thread>
-#include <windows.h>
-
-#define SERVICE_NAME "i2pdService"
-
-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;
-};
-
-#endif // WIN_32_SERVICE_H__

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,27 +0,0 @@
-# Various generated files
-/CMakeFiles/
-/Testing/
-/tests/
-/.ninja_*
-/arch.c
-/build.ninja
-/i2pd
-/i2pd.exe
-/i2pd.exe.debug
-/libi2pd.a
-/libi2pdclient.a
-/libi2pdlang.a
-/cmake_install.cmake
-/CMakeCache.txt
-/CPackConfig.cmake
-/CPackSourceConfig.cmake
-/CTestTestfile.cmake
-/install_manifest.txt
-/Makefile
-# windows build script
-i2pd*.zip
-build*.log
-# MVS project files
-*.vcxproj
-*.vcxproj.filters
-*.sln

build/CMakeLists.txt

@@ -1,392 +0,0 @@
-cmake_minimum_required(VERSION 3.7)
-
-if(${CMAKE_VERSION} VERSION_LESS 3.22)
-  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-  cmake_policy(VERSION 3.22)
-endif()
-
-# for debugging
-#set(CMAKE_VERBOSE_MAKEFILE on)
-
-# paths
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
-set(CMAKE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/..")
-
-set(LIBI2PD_SRC_DIR ${CMAKE_SOURCE_DIR}/libi2pd)
-set(LIBI2PD_CLIENT_SRC_DIR ${CMAKE_SOURCE_DIR}/libi2pd_client)
-set(LANG_SRC_DIR ${CMAKE_SOURCE_DIR}/i18n)
-set(DAEMON_SRC_DIR ${CMAKE_SOURCE_DIR}/daemon)
-
-include(Version)
-set_version("${LIBI2PD_SRC_DIR}/version.h" PROJECT_VERSION)
-
-project(
-  i2pd
-  VERSION ${PROJECT_VERSION}
-  HOMEPAGE_URL "https://i2pd.website/"
-  LANGUAGES C CXX
-)
-
-# configurable options
-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_GIT_VERSION     "Use git commit info as version"          OFF)
-option(WITH_ADDRSANITIZER   "Build with address sanitizer unix only"  OFF)
-option(WITH_THREADSANITIZER "Build with thread sanitizer unix only"   OFF)
-option(BUILD_TESTING        "Build tests"                             OFF)
-
-IF(BUILD_TESTING)
-  enable_testing()
-ENDIF()
-
-# Handle paths nicely
-include(GNUInstallDirs)
-
-# Architecture
-include(TargetArch)
-target_architecture(ARCHITECTURE)
-
-include(CheckAtomic)
-
-if(WITH_STATIC)
-  if(MSVC)
-    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-  endif()
-endif()
-
-include_directories(${LIBI2PD_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)
-endif()
-
-include_directories(${LIBI2PD_CLIENT_SRC_DIR})
-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()
-
-include_directories(${LANG_SRC_DIR})
-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()
-
-include_directories(${DAEMON_SRC_DIR})
-
-set(DAEMON_SRC
-  "${DAEMON_SRC_DIR}/Daemon.cpp"
-  "${DAEMON_SRC_DIR}/HTTPServer.cpp"
-  "${DAEMON_SRC_DIR}/I2PControl.cpp"
-  "${DAEMON_SRC_DIR}/I2PControlHandlers.cpp"
-  "${DAEMON_SRC_DIR}/i2pd.cpp"
-  "${DAEMON_SRC_DIR}/UPnP.cpp"
-)
-
-if(WIN32)
-  set(WIN32_SRC_DIR ${CMAKE_SOURCE_DIR}/Win32)
-  include_directories(${WIN32_SRC_DIR})
-
-  list(APPEND DAEMON_SRC
-    "${WIN32_SRC_DIR}/DaemonWin32.cpp"
-    "${WIN32_SRC_DIR}/Win32App.cpp"
-    "${WIN32_SRC_DIR}/Win32Service.cpp"
-    "${WIN32_SRC_DIR}/Win32NetState.cpp"
-  )
-
-  file(GLOB WIN32_RC ${WIN32_SRC_DIR}/*.rc)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWIN32_APP -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
-
-endif()
-
-if(WITH_UPNP)
-  add_definitions(-DUSE_UPNP)
-endif()
-
-if(WITH_GIT_VERSION)
-  include(GetGitRevisionDescription)
-  git_describe(GIT_VERSION)
-  add_definitions(-DGITVER=${GIT_VERSION})
-endif()
-
-if(APPLE)
-  add_definitions(-DMAC_OSX)
-endif()
-
-if(HAIKU)
-  add_definitions(-D_DEFAULT_SOURCE -D_GNU_SOURCE)
-endif()
-
-if(MSVC)
-  add_definitions(-DWINVER=0x0600)
-  add_definitions(-D_WIN32_WINNT=0x0600)
-else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Winvalid-pch -Wno-unused-parameter -Wno-uninitialized")
-  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)
-  if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -flto -s")
-  endif()
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -ffunction-sections -fdata-sections")
-  set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "-Wl,--gc-sections") # -flto is added from above
-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()
-
-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()
-
-if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0) # gcc 8-9
-    list(APPEND CMAKE_REQUIRED_LIBRARIES "stdc++fs")
-endif()
-
-# Use std::atomic instead of GCC builtins on macOS PowerPC:
-# For more information refer to: https://github.com/PurpleI2P/i2pd/issues/1726#issuecomment-1306335111
-# This has been fixed in Boost 1.81, nevertheless we retain the setting for the sake of compatibility.
-if(APPLE AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc")
-  add_definitions(-DBOOST_SP_USE_STD_ATOMIC)
-endif()
-
-# libraries
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads REQUIRED)
-
-if(WITH_STATIC)
-  if(NOT MSVC)
-    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-  endif()
-
-  set(Boost_USE_STATIC_LIBS ON)
-  if(MSVC)
-    set(Boost_USE_STATIC_RUNTIME ON)
-  else()
-    set(Boost_USE_STATIC_RUNTIME OFF)
-  endif()
-
-  if(MSVC)
-    set(OPENSSL_MSVC_STATIC_RT ON)
-  endif()
-  set(OPENSSL_USE_STATIC_LIBS ON)
-
-  set(ZLIB_USE_STATIC_LIBS ON)
-  if(MSVC)
-    set(ZLIB_NAMES zlibstatic zlibstat)
-  else()
-    set(ZLIB_NAMES libz zlibstatic zlibstat zlib z)
-  endif()
-
-  if(WITH_UPNP)
-    set(MINIUPNPC_USE_STATIC_LIBS ON)
-    add_definitions(-DMINIUPNP_STATICLIB)
-  endif()
-
-  set(BUILD_SHARED_LIBS OFF)
-
-  if(${CMAKE_CXX_COMPILER} MATCHES ".*-openwrt-.*")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-    # set(CMAKE_THREAD_LIBS_INIT "gcc_eh -Wl,--whole-archive -lpthread -Wl,--no-whole-archive")
-    set(CMAKE_THREAD_LIBS_INIT "gcc_eh -Wl,-u,pthread_create,-u,pthread_once,-u,pthread_mutex_lock,-u,pthread_mutex_unlock,-u,pthread_join,-u,pthread_equal,-u,pthread_detach,-u,pthread_cond_wait,-u,pthread_cond_signal,-u,pthread_cond_destroy,-u,pthread_cond_broadcast,-u,pthread_cancel")
-  endif()
-else()
-  # 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
-  if(NOT MSVC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-  endif()
-  add_definitions(-DBOOST_ATOMIC_DYN_LINK -DBOOST_SYSTEM_DYN_LINK -DBOOST_FILESYSTEM_DYN_LINK -DBOOST_PROGRAM_OPTIONS_DYN_LINK)
-  if(WIN32)
-    set(Boost_USE_STATIC_LIBS OFF)
-    set(Boost_USE_STATIC_RUNTIME OFF)
-  endif()
-endif()
-
-find_package(Boost REQUIRED COMPONENTS system filesystem program_options)
-if(NOT DEFINED Boost_FOUND)
-  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_FOUND)
-  message(SEND_ERROR "Could not find OpenSSL. Please download and install it first!")
-endif()
-
-if(OPENSSL_VERSION VERSION_GREATER_EQUAL "3.0.0")
-  add_definitions(-DOPENSSL_SUPPRESS_DEPRECATED)
-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()
-
-# C++ standard to use, based on compiler and version of boost
-if(NOT MSVC)
-# check for c++20 & c++17 support
-  include(CheckCXXCompilerFlag)
-
-  if(Boost_VERSION VERSION_GREATER_EQUAL "1.83") # min boost version for c++20
-    CHECK_CXX_COMPILER_FLAG("-std=c++20" CXX20_SUPPORTED)
-  endif()
-  CHECK_CXX_COMPILER_FLAG("-std=c++17" CXX17_SUPPORTED)
- 
-
-  if(CXX20_SUPPORTED)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20")
-  elseif(CXX17_SUPPORTED)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-  else()
-    message(SEND_ERROR "C++20 nor C++17 standard not seems to be supported by compiler. Too old version?")
-  endif()
-endif()
-
-# load includes
-include_directories(SYSTEM ${Boost_INCLUDE_DIRS} ${OPENSSL_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
-
-# 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 "Compiler flags     : ${CMAKE_CXX_FLAGS}")
-message(STATUS "Install prefix:    : ${CMAKE_INSTALL_PREFIX}")
-message(STATUS "Options:")
-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}")
-if(WITH_GIT_VERSION)
-message(STATUS "  GIT VERSION      : ${WITH_GIT_VERSION} (${GIT_VERSION})")
-else()
-message(STATUS "  GIT VERSION      : ${WITH_GIT_VERSION}")
-endif()
-message(STATUS "  ADDRSANITIZER    : ${WITH_ADDRSANITIZER}")
-message(STATUS "  THREADSANITIZER  : ${WITH_THREADSANITIZER}")
-message(STATUS "---------------------------------------")
-
-if(WITH_BINARY)
-  if(WIN32)
-    add_executable("${PROJECT_NAME}" WIN32 ${DAEMON_SRC} ${WIN32_RC})
-  else()
-    add_executable("${PROJECT_NAME}" ${DAEMON_SRC})
-  endif()
-
-  if(WIN32)
-    list(APPEND MINGW_EXTRA "wsock32" "ws2_32" "iphlpapi")
-    # OpenSSL may require Crypt32 library on MSVC build, which is not added by CMake lesser than 3.21
-    if(MSVC AND ${CMAKE_VERSION} VERSION_LESS 3.21)
-      list(APPEND MINGW_EXTRA "crypt32")
-    endif()
-  endif()
-
-  if(WITH_STATIC)
-    if(NOT MSVC)
-      set_target_properties("${PROJECT_NAME}" PROPERTIES LINK_FLAGS "-static")
-    endif()
-  endif()
-
-  if(WITH_HARDENING AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set_target_properties("${PROJECT_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()
-
-  # synchronization library is incompatible with Windows 7
-  if(WIN32)
-    get_target_property(BOOSTFSLIBS Boost::filesystem INTERFACE_LINK_LIBRARIES)
-    list(REMOVE_ITEM BOOSTFSLIBS synchronization)
-    set_target_properties(Boost::filesystem PROPERTIES INTERFACE_LINK_LIBRARIES "${BOOSTFSLIBS}")
-  endif()
-
-  if(WITH_STATIC)
-    set(DL_LIB ${CMAKE_DL_LIBS})
-  endif()
-
-  target_link_libraries("${PROJECT_NAME}" libi2pd libi2pdclient libi2pdlang ${Boost_LIBRARIES} OpenSSL::SSL OpenSSL::Crypto ${MINIUPNPC_LIBRARY} ZLIB::ZLIB Threads::Threads ${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()
-
-if(BUILD_TESTING)
-  add_subdirectory(${CMAKE_SOURCE_DIR}/tests ${CMAKE_CURRENT_BINARY_DIR}/tests)
-endif()

build/build_mingw.cmd

@@ -1,149 +0,0 @@
-@echo off
-setlocal enableextensions enabledelayedexpansion
-title Building i2pd
-
-REM Copyright (c) 2013-2022, 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 UCRT64: mingw-w64-ucrt-x86_64-boost mingw-w64-ucrt-x86_64-openssl mingw-w64-ucrt-x86_64-gcc
-REM MINGW32: 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 MSYS2_PATH_TYPE=inherit
-set CHERE_INVOKING=enabled_from_arguments
-set MSYSTEM=MINGW32
-
-set "WD=C:\msys64\usr\bin\"
-set "xSH=%WD%bash -lc"
-
-set "FILELIST=i2pd.exe README.txt contrib/i2pd.conf contrib/tunnels.conf contrib/certificates contrib/tunnels.d contrib/webconsole"
-
-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
-
-REM set to variable current commit hash
-for /F "usebackq" %%a in (`%xSH% "git describe --tags"`) DO (
- set tag=%%a
-)
-
-REM set to variable latest released tag
-for /F "usebackq" %%b in (`%xSH% "git describe --abbrev=0"`) DO (
- set reltag=%%b
-)
-
-echo Preparing configuration files and README for packaging...
-
-%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 (make usable in Windows Notepad)
-%xSH% "unix2dos contrib/i2pd.conf contrib/tunnels.conf contrib/tunnels.d/* contrib/webconsole/style.css" >> build\build.log 2>&1
-
-REM Prepare binary signing command if signing key and password provided
-if defined SIGN (
-  echo Signing enabled
-
-  for %%X in (signtool.exe) do (set xSIGNTOOL=%%~$PATH:X)
-  if not defined xSIGNTOOL (
-    if not defined SIGNTOOL (
-      echo Error: Can't find signtool. Please provide path to binary using SIGNTOOL variable.
-      exit /b 1
-    ) else (
-      set "xSIGNTOOL=%SIGNTOOL%"
-    )
-  )
-
-  if defined SIGNKEY (
-    set "xSIGNKEYOPTS=/f ^"%SIGNKEY%^""
-  )
-
-  if defined SIGNPASS (
-    set "xSIGNPASSOPTS=/p ^"%SIGNPASS%^""
-  )
-
-  set "xSIGNOPTS=sign /tr http://timestamp.digicert.com /td sha256 /fd sha256 %xSIGNKEYOPTS% %xSIGNPASSOPTS%"
-)
-
-REM starting building
-set MSYSTEM=MINGW32
-set bitness=32
-call :BUILDING
-
-set MSYSTEM=UCRT64
-set bitness=64
-call :BUILDING
-
-REM build for Windows XP
-if exist C:\msys64-xp\ ( call :BUILDING_XP )
-
-echo.
-
-REM compile installer
-echo Building installer...
-C:\PROGRA~2\INNOSE~1\ISCC.exe /dI2Pd_TextVer="%tag%" /dI2Pd_Ver="%reltag%.0" build\win_installer.iss >> build\build.log 2>&1
-
-REM Sign binary
-if defined xSIGNOPTS (
-  "%xSIGNTOOL%" %xSIGNOPTS% build\setup_i2pd_v%tag%.exe
-)
-
-%xSH% "git checkout contrib/*" >> 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%...
-REM Build i2pd
-%xSH% "make DEBUG=no USE_UPNP=yes -j%threads%" > build\build_win%bitness%_%tag%.log 2>&1
-
-REM Sign binary
-if defined xSIGNOPTS (
-  "%xSIGNTOOL%" %xSIGNOPTS% i2pd.exe
-)
-
-REM Copy binary for installer and create distribution archive
-%xSH% "cp i2pd.exe i2pd_x%bitness%.exe && zip -r9 build/i2pd_%tag%_win%bitness%_mingw.zip %FILELIST%" >> build\build_win%bitness%_%tag%.log 2>&1
-
-REM Clean work directory
-%xSH% "make clean" >> build\build_win%bitness%_%tag%.log 2>&1
-goto EOF
-
-:BUILDING_XP
-set MSYSTEM=MINGW32
-set bitness=32
-set "WD=C:\msys64-xp\usr\bin\"
-set "xSH=%WD%bash -lc"
-
-%xSH% "make clean" >> nul
-echo Building i2pd %tag% for winxp...
-%xSH% "make DEBUG=no USE_UPNP=yes USE_WINXP_FLAGS=yes -j%threads%" > build\build_winxp_%tag%.log 2>&1
-
-REM Sign binary
-if defined xSIGNOPTS (
-  "%xSIGNTOOL%" %xSIGNOPTS% i2pd.exe
-)
-
-REM Copy binary for installer and create distribution archive
-%xSH% "cp i2pd.exe i2pd_xp.exe && zip -r9 build/i2pd_%tag%_winxp_mingw.zip %FILELIST%" >> build\build_winxp_%tag%.log 2>&1
-
-REM Clean work directory
-%xSH% "make clean" >> build\build_winxp_%tag%.log 2>&1
-goto EOF
-
-:EOF

build/cmake_modules/CheckAtomic.cmake

@@ -1,112 +0,0 @@
-# atomic builtins are required for threading support.
-
-INCLUDE(CheckCXXSourceCompiles)
-INCLUDE(CheckLibraryExists)
-
-# 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 "${CMAKE_REQUIRED_FLAGS} -std=c++17")
-  CHECK_CXX_SOURCE_COMPILES("
-#include <atomic>
-std::atomic<int> x;
-std::atomic<short> y;
-std::atomic<char> z;
-int main() {
-  ++z;
-  ++y;
-  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++17 ${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);
-  (void)i;
-  return 0;
-}
-" ${varname})
-  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
-endfunction(check_working_cxx_atomics64)
-
-
-# Check for (non-64-bit) atomic operations.
-if(MSVC)
-  set(HAVE_CXX_ATOMICS_WITHOUT_LIB True)
-else()
-  # 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()
-  # First check if atomics work without the library.
-  check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
-  # 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 64-bit std::atomic!")
-      endif()
-    else()
-      message(FATAL_ERROR "Host compiler appears to require libatomic for 64-bit operations, but cannot find it.")
-    endif()
-  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 <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/FindCheck.cmake

@@ -1,55 +0,0 @@
-# - Try to find the CHECK libraries
-#  Once done this will define
-#
-#  CHECK_FOUND - system has check
-#  CHECK_INCLUDE_DIRS - the check include directory
-#  CHECK_LIBRARIES - check library
-#
-#  Copyright (c) 2007 Daniel Gollub <gollub@b1-systems.de>
-#  Copyright (c) 2007-2009 Bjoern Ricks  <bjoern.ricks@gmail.com>
-#
-#  Redistribution and use is allowed according to the terms of the New
-#  BSD license.
-#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-
-INCLUDE( FindPkgConfig )
-
-IF ( Check_FIND_REQUIRED )
-	SET( _pkgconfig_REQUIRED "REQUIRED" )
-ELSE( Check_FIND_REQUIRED )
-	SET( _pkgconfig_REQUIRED "" )
-ENDIF ( Check_FIND_REQUIRED )
-
-IF ( CHECK_MIN_VERSION )
-	PKG_SEARCH_MODULE( CHECK ${_pkgconfig_REQUIRED} check>=${CHECK_MIN_VERSION} )
-ELSE ( CHECK_MIN_VERSION )
-	PKG_SEARCH_MODULE( CHECK ${_pkgconfig_REQUIRED} check )
-ENDIF ( CHECK_MIN_VERSION )
-
-# Look for CHECK include dir and libraries
-IF( NOT CHECK_FOUND AND NOT PKG_CONFIG_FOUND )
-
-	FIND_PATH( CHECK_INCLUDE_DIRS check.h )
-
-	FIND_LIBRARY( CHECK_LIBRARIES NAMES check )
-
-	IF ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
-		SET( CHECK_FOUND 1 )
-		IF ( NOT Check_FIND_QUIETLY )
-			MESSAGE ( STATUS "Found CHECK: ${CHECK_LIBRARIES}" )
-		ENDIF ( NOT Check_FIND_QUIETLY )
-	ELSE ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
-		IF ( Check_FIND_REQUIRED )
-			MESSAGE( FATAL_ERROR "Could NOT find CHECK" )
-		ELSE ( Check_FIND_REQUIRED )
-			IF ( NOT Check_FIND_QUIETLY )
-				MESSAGE( STATUS "Could NOT find CHECK" )
-			ENDIF ( NOT Check_FIND_QUIETLY )
-		ENDIF ( Check_FIND_REQUIRED )
-	ENDIF ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
-ENDIF( NOT CHECK_FOUND AND NOT PKG_CONFIG_FOUND )
-
-# Hide advanced variables from CMake GUIs
-MARK_AS_ADVANCED( CHECK_INCLUDE_DIRS CHECK_LIBRARIES )
-

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/GetGitRevisionDescription.cmake

@@ -1,284 +0,0 @@
-# - Returns a version string from Git
-#
-# These functions force a re-configure on each git commit so that you can
-# trust the values of the variables in your build system.
-#
-#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
-#
-# Returns the refspec and sha hash of the current head revision
-#
-#  git_describe(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the source tree, and adjusting
-# the output so that it tests false if an error occurs.
-#
-#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the working tree (--dirty option),
-# and adjusting the output so that it tests false if an error occurs.
-#
-#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe --exact-match on the source tree,
-# and adjusting the output so that it tests false if there was no exact
-# matching tag.
-#
-#  git_local_changes(<var>)
-#
-# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
-# Uses the return code of "git diff-index --quiet HEAD --".
-# Does not regard untracked files.
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-#
-# Copyright 2009-2013, Iowa State University.
-# Copyright 2013-2020, Ryan Pavlik
-# Copyright 2013-2020, Contributors
-# SPDX-License-Identifier: BSL-1.0
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__get_git_revision_description)
-    return()
-endif()
-set(__get_git_revision_description YES)
-
-# We must run the following at "include" time, not at function call time,
-# to find the path to this module rather than the path to a calling list file
-get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-# Function _git_find_closest_git_dir finds the next closest .git directory
-# that is part of any directory in the path defined by _start_dir.
-# The result is returned in the parent scope variable whose name is passed
-# as variable _git_dir_var. If no .git directory can be found, the
-# function returns an empty string via _git_dir_var.
-#
-# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
-# neither foo nor bar contain a file/directory .git. This will return
-# C:/bla/.git
-#
-function(_git_find_closest_git_dir _start_dir _git_dir_var)
-    set(cur_dir "${_start_dir}")
-    set(git_dir "${_start_dir}/.git")
-    while(NOT EXISTS "${git_dir}")
-        # .git dir not found, search parent directories
-        set(git_previous_parent "${cur_dir}")
-        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
-        if(cur_dir STREQUAL git_previous_parent)
-            # We have reached the root directory, we are not in git
-            set(${_git_dir_var}
-                ""
-                PARENT_SCOPE)
-            return()
-        endif()
-        set(git_dir "${cur_dir}/.git")
-    endwhile()
-    set(${_git_dir_var}
-        "${git_dir}"
-        PARENT_SCOPE)
-endfunction()
-
-function(get_git_head_revision _refspecvar _hashvar)
-    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
-
-    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
-        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
-    else()
-        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
-    endif()
-    if(NOT "${GIT_DIR}" STREQUAL "")
-        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
-             "${GIT_DIR}")
-        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
-            # We've gone above the CMake root dir.
-            set(GIT_DIR "")
-        endif()
-    endif()
-    if("${GIT_DIR}" STREQUAL "")
-        set(${_refspecvar}
-            "GITDIR-NOTFOUND"
-            PARENT_SCOPE)
-        set(${_hashvar}
-            "GITDIR-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    # Check if the current source dir is a git submodule or a worktree.
-    # In both cases .git is a file instead of a directory.
-    #
-    if(NOT IS_DIRECTORY ${GIT_DIR})
-        # The following git command will return a non empty string that
-        # points to the super project working tree if the current
-        # source dir is inside a git submodule.
-        # Otherwise the command will return an empty string.
-        #
-        execute_process(
-            COMMAND "${GIT_EXECUTABLE}" rev-parse
-                    --show-superproject-working-tree
-            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-            OUTPUT_VARIABLE out
-            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-        if(NOT "${out}" STREQUAL "")
-            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
-            file(READ ${GIT_DIR} submodule)
-            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
-                                 ${submodule})
-            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
-            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
-            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
-                                   ABSOLUTE)
-            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
-        else()
-            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
-            file(READ ${GIT_DIR} worktree_ref)
-            # The .git directory contains a path to the worktree information directory
-            # inside the parent git repo of the worktree.
-            #
-            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
-                                 ${worktree_ref})
-            string(STRIP ${git_worktree_dir} git_worktree_dir)
-            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
-            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
-        endif()
-    else()
-        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
-    endif()
-    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
-    if(NOT EXISTS "${GIT_DATA}")
-        file(MAKE_DIRECTORY "${GIT_DATA}")
-    endif()
-
-    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
-        return()
-    endif()
-    set(HEAD_FILE "${GIT_DATA}/HEAD")
-    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
-
-    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
-                   "${GIT_DATA}/grabRef.cmake" @ONLY)
-    include("${GIT_DATA}/grabRef.cmake")
-
-    set(${_refspecvar}
-        "${HEAD_REF}"
-        PARENT_SCOPE)
-    set(${_hashvar}
-        "${HEAD_HASH}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_describe _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    get_git_head_revision(refspec hash)
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-    if(NOT hash)
-        set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    # TODO sanitize
-    #if((${ARGN}" MATCHES "&&") OR
-    #	(ARGN MATCHES "||") OR
-    #	(ARGN MATCHES "\\;"))
-    #	message("Please report the following error to the project!")
-    #	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
-    #endif()
-
-    #message(STATUS "Arguments to execute_process: ${ARGN}")
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(NOT res EQUAL 0)
-        set(out "${out}-${res}-NOTFOUND")
-    endif()
-
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_describe_working_tree _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(NOT res EQUAL 0)
-        set(out "${out}-${res}-NOTFOUND")
-    endif()
-
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_get_exact_tag _var)
-    git_describe(out --exact-match ${ARGN})
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_local_changes _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    get_git_head_revision(refspec hash)
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-    if(NOT hash)
-        set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(res EQUAL 0)
-        set(${_var}
-            "CLEAN"
-            PARENT_SCOPE)
-    else()
-        set(${_var}
-            "DIRTY"
-            PARENT_SCOPE)
-    endif()
-endfunction()

build/cmake_modules/GetGitRevisionDescription.cmake.in

@@ -1,43 +0,0 @@
-#
-# Internal file for GetGitRevisionDescription.cmake
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright 2009-2012, Iowa State University
-# Copyright 2011-2015, Contributors
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-# SPDX-License-Identifier: BSL-1.0
-
-set(HEAD_HASH)
-
-file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
-
-string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
-if(HEAD_CONTENTS MATCHES "ref")
-	# named branch
-	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
-	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
-		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-	else()
-		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
-		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
-		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-			set(HEAD_HASH "${CMAKE_MATCH_1}")
-		endif()
-	endif()
-else()
-	# detached HEAD
-	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
-endif()
-
-if(NOT HEAD_HASH)
-	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-	string(STRIP "${HEAD_HASH}" HEAD_HASH)
-endif()

build/cmake_modules/TargetArch.cmake

@@ -1,167 +0,0 @@
-# Copyright (c) 2017-2023, 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
-
-# Based on the Qt 5 processor detection code, so should be very accurate
-# https://github.com/qt/qtbase/blob/dev/src/corelib/global/qprocessordetection.h
-# Currently handles arm (v5, v6, v7, v8), x86 (32/64), ia64, mips (32/64, mipsel, mips64el) 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)|| defined(_M_ARM) || defined(_M_ARM64) || defined(__aarch64__) || defined(__ARM64__)
-    #if defined(__ARM64_ARCH_8__) \\
-        || defined(__aarch64__) \\
-        || defined(__ARMv8__) \\
-        || defined(__ARMv8_A__) \\
-        || defined(_M_ARM64) \\
-        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 8)
-        #error cmake_ARCH arm64
-    #elif defined(__ARM_ARCH_7__) \\
-        || defined(__ARM_ARCH_7A__) \\
-        || defined(__ARM_ARCH_7R__) \\
-        || defined(__ARM_ARCH_7M__) \\
-        || defined(__ARM_ARCH_7S__) \\
-        || defined(_ARM_ARCH_7) \\
-        || defined(__CORE_CORTEXA__) \\
-        || (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(__ARM_ARCH_5TE__) \\
-        || (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(__mips) || defined(__mips__) || defined(_M_MRX000)
-    #if defined(_MIPS_ARCH_MIPS64) || defined(__mips64)
-        #if defined(__MIPSEL__)
-            #error cmake_ARCH mips64el
-        #else
-            #error cmake_ARCH mips64
-        #endif
-    #elif defined(__MIPSEL__)
-        #error cmake_ARCH mipsel
-    #else
-        #error cmake_ARCH mips
-    #endif
-#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) || 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 on 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.7 or later - you'll need 10.4/10.5/10.6 for that, so we
-        # disable it by default. Also, ppc64 is not supported in 10.6.
-        # 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; 10.6 also supports ppc.
-
-        foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
-            if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
-                set(osx_arch_ppc TRUE)
-            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
-                set(osx_arch_ppc64 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 "arm64")
-                set(osx_arch_arm64 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_ppc64)
-            list(APPEND ARCH ppc64)
-        endif()
-
-        if(osx_arch_i386)
-            list(APPEND ARCH i386)
-        endif()
-
-        if(osx_arch_x86_64)
-            list(APPEND ARCH x86_64)
-        endif()
-
-        if(osx_arch_arm64)
-            list(APPEND ARCH arm64)
-        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/cmake_modules/Version.cmake

@@ -1,16 +0,0 @@
-# read version
-
-function(set_version version_file output_var)
-    file(READ "${version_file}" version_data)
-
-    string(REGEX MATCH "I2PD_VERSION_MAJOR ([0-9]*)" _ ${version_data})
-    set(version_major ${CMAKE_MATCH_1})
-
-    string(REGEX MATCH "I2PD_VERSION_MINOR ([0-9]*)" _ ${version_data})
-    set(version_minor ${CMAKE_MATCH_1})
-
-    string(REGEX MATCH "I2PD_VERSION_MICRO ([0-9]*)" _ ${version_data})
-    set(version_micro ${CMAKE_MATCH_1})
-
-    set(${output_var} "${version_major}.${version_minor}.${version_micro}" PARENT_SCOPE)
-endfunction()

build/win_installer.iss

@@ -1,54 +0,0 @@
-#define I2Pd_AppName "i2pd"
-#define I2Pd_Publisher "PurpleI2P"
-
-[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-2024, 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
-Source: ..\contrib\webconsole\*; DestDir: {userappdata}\i2pd\webconsole; 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/apparmor/docker-i2pd

@@ -1,42 +0,0 @@
-# _________________________________________
-# /  Copy this file to the right location   \
-# | then load with:                         |
-# |                                         |
-# | apparmor_parser -r -W                   |
-# | /etc/apparmor.d/docker-i2pd             |
-# |                                         |
-# | docker run --security-opt               |
-# | "apparmor=docker-i2pd" ...              |
-# | purplei2p/i2pd                          |
-# |                                         |
-# \ And "aa-status" to verify it's loaded.  /
-#  -----------------------------------------
-#         \   ^__^
-#          \  (oo)\_______
-#             (__)\       )\/\
-#                 ||----w |
-#                 ||     ||
-
-#include <tunables/global>
-
-profile docker-i2pd flags=(attach_disconnected,mediate_deleted) {
-  #include <abstractions/base>
-  #include <abstractions/openssl>
-  #include <abstractions/nameservice>
-
-  /bin/busybox ix,
-  /usr/local/bin/i2pd ix,
-  /entrypoint.sh ixr,
-
-  /i2pd_certificates/** r,
-
-  /home/i2pd/data/** rw,
-
-  /home/i2pd/data/i2pd.pid k,
-
-  deny /home/i2pd/data/i2pd.conf w,
-  deny /home/i2pd/data/tunnels.conf w,
-  deny /home/i2pd/data/tunnels.d/** w,
-  deny /home/i2pd/data/certificates/** w,
-  deny /home/i2pd/data/i2pd.log r,
-}

contrib/apparmor/usr.bin.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/,}bin/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/,}bin/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.bin.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/stormycloud.crt

@@ -1,14 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICKDCCAc6gAwIBAgIUcPHZXtYSqGNRCD6z8gp79WUFtI0wCgYIKoZIzj0EAwIw
-gZMxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEPMA0GA1UEBwwGQXVzdGlu
-MRgwFgYDVQQKDA9TdG9ybXlDbG91ZCBJbmMxIzAhBgNVBAMMGnN0b3JteWNsb3Vk
-LmZhbWlseS5pMnAubmV0MSQwIgYJKoZIhvcNAQkBFhVhZG1pbkBzdG9ybXljbG91
-ZC5vcmcwHhcNMjIwMzE5MTU1MjU2WhcNMzIwMzE2MTU1MjU2WjCBkzELMAkGA1UE
-BhMCVVMxDjAMBgNVBAgMBVRleGFzMQ8wDQYDVQQHDAZBdXN0aW4xGDAWBgNVBAoM
-D1N0b3JteUNsb3VkIEluYzEjMCEGA1UEAwwac3Rvcm15Y2xvdWQuZmFtaWx5Lmky
-cC5uZXQxJDAiBgkqhkiG9w0BCQEWFWFkbWluQHN0b3JteWNsb3VkLm9yZzBZMBMG
-ByqGSM49AgEGCCqGSM49AwEHA0IABFUli0hvJEmowNjJVjbKEIWBJhqe973S4VdL
-cJuA5yY3dC4Y998abWEox7/Y1BhnBbpJuiodA341bXKkLMXQy/kwCgYIKoZIzj0E
-AwIDSAAwRQIgD12F/TfY3iV1/WDF7BSKgbD5g2MfELUIy1dtUlJQuJUCIQD69mZw
-V1Z9j2x0ZsuirS3i6AMfVyTDj0RFS3U1jeHzIQ==
------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/admin_at_stormycloud.org.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIF1zCCA7+gAwIBAgIRAMDqFR09Xuj8ZUu+oetSvAEwDQYJKoZIhvcNAQELBQAw
-dTELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwGA1UE
-ChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxHjAcBgNVBAMM
-FWFkbWluQHN0b3JteWNsb3VkLm9yZzAeFw0yNDAxMjUxNDE1MzBaFw0zNDAxMjUx
-NDE1MzBaMHUxCzAJBgNVBAYTAlhYMQswCQYDVQQHEwJYWDELMAkGA1UECRMCWFgx
-HjAcBgNVBAoTFUkyUCBBbm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMR4w
-HAYDVQQDDBVhZG1pbkBzdG9ybXljbG91ZC5vcmcwggIiMA0GCSqGSIb3DQEBAQUA
-A4ICDwAwggIKAoICAQDbGX+GikPzQXr9zvkrhfO9g0l49KHLNQhUKYqd6T+PfnGo
-Fm0d3ZZVVQZ045vWgroOXDGGZZWxUIlb2inRaR2DF1TxN3pPYt59RgY9ZQ9+TL7o
-isY91krCRygY8EcAmHIjlfZQ9dBVcL7CfyT0MYZA5Efee9+NDHSewTfQP9T2faIE
-83Fcyd93a2mIHYjKUbJnojng/wgsy8srbsEuuTok4MIQmDj+B5nz+za2FgI0/ydh
-srlMt4aGJF4/DIem9z9d0zBCOkwrmtFIzjNF1mOSA8ES4m5YnKA/y9rZlRidLPGu
-prbXhPVnqHeOnHMz2QCw1wbVo504kl0bMqyEz2tVWsO9ep7iZoQs2xkFAEaegYNT
-QLUpwVGlyuq3wXXwopFRffOSimGSazICwWI6j+K0pOtgefNJaWrqKYvtkj1SbK2L
-LBNUIENz6VnB7KPRckuX6zxC8PpOiBK9BcftfO+xAz/wC6qq3riBPw30KKSym0nC
-Zp5KciDn4Phtw9PGq8Bkl8SyWl0jtFnfTB1tzJkisf2qKcNHaFTEe2JW763YLbh/
-AU+8X8evFu40qLgvOgKoyy5DLy6i8zetX+3t9K0Fxt9+Vzzq6lm5V/RS8iIPPn+M
-q1/3Z5kD0KQBG9h/Gl8BH+lB71ZxPAOZ3SMu8DJZcxBLVmDWqQPCr5CKnoz0swID
-AQABo2IwYDAOBgNVHQ8BAf8EBAMCAoQwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsG
-AQUFBwMBMA8GA1UdEwEB/wQFMAMBAf8wHgYDVR0OBBcEFWFkbWluQHN0b3JteWNs
-b3VkLm9yZzANBgkqhkiG9w0BAQsFAAOCAgEARWOJ69vTHMneSXYscha+4Ytjg0RM
-faewJNEGj8qy/Qvh9si2bWYNPRK6BlbHFS7pRYBLAnhaeLBGVv1CCR6GUMMe74zQ
-UuMeAoWU6qMDmB3GfYoZJh8sIxpwHqyJeTdeccRbZ4sX4F6u3IHPXYiU/AgbYqH7
-pYXQg2lCjXZYaDFAlEf5SlYUDOhhXe5kR8Edhlrsu32/JzA1DQK0JjxKCBp+DQmA
-ltdOpQtAg03fHP4ssdj7VvjIDl28iIlATwBvHrdNm7T0tYWn6TWhvxbRqvfTxfaH
-MvxnPdIJwNP4/9TyQkwjwHb1h+ucho3CnxI/AxspdOvT1ElMhP6Ce6rcS9pk11Rl
-x0ChsqpWwDg7KYpg0qZFSKCTBp4zBq9xoMJ6BQcgMfyl736WbsCzFTEyfifp8beg
-NxUa/Qk7w7cuSPGyMIKNOmOR7FLlFbtocy8sXVsUQdqnp/edelufdNe39U9uNtY6
-yoXI9//Tc6NgOwy2Oyia0slZ5qHRkB7e4USXMRzJ3p4q9eCVKjAJs81Utp7O2U+9
-vhbhwWP8CAnNTT1E5WS6EKtfrdqF7wjkV+noPGLDGmrXi01J1fSMAjMfVO+7/LOL
-UN+G4ybKWnEhhOO27yidN8Xx6UrCS23DBlPPQAeA74dTsTExiOxf1o1EXzcQiMyO
-LAj3/Ojbi1xkWhI=
------END CERTIFICATE-----

contrib/certificates/reseed/arnavbhatt288_at_mail.i2p.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIF2TCCA8GgAwIBAgIQIHQPtSoFU+cUpYD8PZaWZjANBgkqhkiG9w0BAQsFADB2
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEfMB0GA1UEAwwW
-YXJuYXZiaGF0dDI4OEBtYWlsLmkycDAeFw0yMzAxMjUxODUzNDFaFw0zMzAxMjUx
-ODUzNDFaMHYxCzAJBgNVBAYTAlhYMQswCQYDVQQHEwJYWDELMAkGA1UECRMCWFgx
-HjAcBgNVBAoTFUkyUCBBbm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMR8w
-HQYDVQQDDBZhcm5hdmJoYXR0Mjg4QG1haWwuaTJwMIICIjANBgkqhkiG9w0BAQEF
-AAOCAg8AMIICCgKCAgEAtwG73sC0jYd3fgEzZh0SveAdUd5yD35nINJRrdPSrSwY
-n3i1qGe3fNLj877PvUDU+qiHH0fFZfyFkXTaq3TUp1u4YkmvaoPHy6FZlojB08lK
-FBm+iJ1hifQ7MFmvIKUGv+cjlN6xSoQ0U6B2QOy6iZnBgFZ/7jbRY4iZOIj7VJtY
-aodeHfy0bWe447VJovbkUi7NJPFZQS65LMcAIWcWTxrC0Gj8SmdxL3a5+hxpmmg0
-+KCQvWQDdxAQjsc16sgUCdUc6cWYO4yw9H6fgdq9GJX+LnXR9OB58GsAjjlLlFoI
-CZxdARDpoqcIj6AoKIanALf8yfbIyrqqJE47cuaqV9bht5MWKnXbwHplEkT4ZNkh
-PnRDia7B5HY3uwbt39CBm264PEWXvWG2sozTWKQqBjmMN2cj/NFDUEqKv6BggMY1
-HcqxWFKRcgKCtRvrmTmfp5l0/ou+OtUaFUg0a6Qhtb93Hj10vK6wZzidBqj0ggzB
-eJDI95b89u8JgzRoOBriuMKTc91WTkOvBLkB3dgUbUpx2p8KHjvf/pppBH9u0oxp
-qJFFK840DbnJydEvjKezeVe5Ax6YRSRxyEdKzRoWdvKVxb3qBBKMdCKTYEPxHPBu
-JMEQVUCXJMti++1KEiQGhcfWvLyT7OewbcIZNk9XWNrxlKcGrTp9AOwaaNC5m1kC
-AwEAAaNjMGEwDgYDVR0PAQH/BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggr
-BgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MB8GA1UdDgQYBBZhcm5hdmJoYXR0Mjg4
-QG1haWwuaTJwMA0GCSqGSIb3DQEBCwUAA4ICAQAHiK0ld/1PF9DIhutD660/bzBg
-mF2Z76hcBqDZ8tnQai/u/RXYrH9wso9BYyrVsvk3fr6tpGT49Ian0MVpPOxMoTU2
-oBEmQlYrfclQLFsOLmA0y2r1ggXzIrt69jB710Vhwdnz09oOE8rS4E2T5oDD8Wvy
-Kony+AarRceqtkOlzyquc42KjzdrbHsosF7G2iGhNI6t+T3BfWJ+Q+d5sj3OIh6e
-gSfvHL44E4vZt6dtofRN3MAZ60kNLF5YWyaUo3Snv9Lso1IwIz3AVr5ehv+8sFL/
-KxaXdkZ5Yn2YUX7p1t4VQd+eXVPYjf1befg4PvrwSkylu3Jpee3fllZSKXeSVx9x
-jpJiq5vIakqk22pnWb1Vn7xzSW1vtEG7QLjobOr1WrcGiwdv+HKiWcXJXDzKoWXs
-h3VEfr51Kap8cIJv+D6lJIG9IcIhiQ6CXWBmtjWJvbdVwFBy1/3Fhaou9liHi+gK
-4Yh5a5OGCzc7xjtpGaTmoLEz7NzDNOdd/r840qRDOh70izzmFZd5Gwq4hoVcPJcS
-EAySwtgqK0/4d0zDd2Wg9ASJV9DnDf8QuSmHZgZ9Efs47XcWz9TvkWUS1E66AJsN
-mmI1NDQ3mv3dv5+WPq+dqqYFsnx3xWL1g5Z3buk0opeuXMzoHwM7UfN8h7Q1M5+t
-+XBgkaYA4iEwYKqlCQ==
------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/echelon3_at_mail.i2p.crt

@@ -1,33 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFyzCCA7OgAwIBAgIRALWNWsnQ0Vmn/99iCNT7cdQwDQYJKoZIhvcNAQELBQAw
-cTELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwGA1UE
-ChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGjAYBgNVBAMM
-EWVjaGVsb24zQG1haWwuaTJwMB4XDTIxMTEyOTE5MzU1OVoXDTMxMTEyOTE5MzU1
-OVowcTELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwG
-A1UEChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGjAYBgNV
-BAMMEWVjaGVsb24zQG1haWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC
-CgKCAgEA3pccNiQWJUS1t3QHK7rBCNKAsM2dz4szN3+3SrDy1w+rOrK8Vt5aypPU
-QYUQwG+odjEPacuoRtO/W14KJl5yAI3eQS+X/cYDXmxvfm4zx5JRumYptXwJD57G
-rlPHnFvk8R+Hvh+/UyqgSAZ9ZaKjEzYK4AtbYEXtopaM4U2VYN8xKjvKyWlhPdxo
-kI3//qcTlSqGHHeHrkItLG1LubM1EnPu+9zI2WN2zBBRcm8ZtWqHoqFJ1zgJr/49
-nMK8Lnb3I54ctva8x5+gsSk4dbG/mMsOIZekFqYJJs3+u9w5fmOYI7v9GlQr7UhE
-G3MwjJ5Cj1LmLVlz/4LApZrDSd2JvwIUdGL3UW8+blaTeCPKIRvmsTeRxo1gORMF
-ZH0dg39722lK7ScwOlOUX9ggzRUlYCmvnjQJZGJEUoP68QxjlQfkXZyffmMfvm6K
-V6mcZ5aHMGO1lYAl40kWNJ0jGpmxJqTDhNFDEKr0TlRGVxXGWzObEOrcJ8ysRMc1
-x6oXQhh79HXZcKwhZaXLx23ZvVoTfhRm4JH0SSP6XqQm35j4NI1SllEsDns29wU3
-Re4wOWJCCYlPG3CtY32CinwQRoVgtiJk18W8+Pxw7sBFq8sL5L0Z+5bB6nTkBfV6
-7OrZGWL0i344zQE0e3yIsLih+5Wyqw6RSSMysenl3alnUB9EvE0CAwEAAaNeMFww
-DgYDVR0PAQH/BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAP
-BgNVHRMBAf8EBTADAQH/MBoGA1UdDgQTBBFlY2hlbG9uM0BtYWlsLmkycDANBgkq
-hkiG9w0BAQsFAAOCAgEAaUMnMYtNFBl9dFON6e4EjYo53Wknj61uIVO11dvLqjnh
-7X6guPML+GgNZsPQGLu7Bqw4hVgy/cV5AlFc7SXOhzpaYo1ycpjg3Ws1VK2wrk7+
-4bvUThNcS1KZVFDdRE62549rYNfYNfPxXvccOTW9meTCC1kLHerh65ySDr9J02O6
-o5Mf685PgBasBH6dlosOLTtee2gRLNFcAluQYKerawS1gDys5239UNHPCqTgO+Od
-FiKfl48OIOzPGLKEf4lXC+lkwZElewShrHhzd8aGueedTi0UHOtQuY7ocsofqXc8
-OnyT/y2X6wn/YkzviKgfxYDSI7FJiUgXCPcT0jUNmuwR168yL5BfzoQmrCvlOOQg
-P7ibdBJ6UkL8pRpv/SYpvaX/kf4agYtwh5IL9FzNCwNu54ZC6JilLUhYAU38Eolq
-OZ/cGiMoSFQIeBPvB3cdsqEud9W4P+MqN5A76fMzdVV77lGsIS1eCGMceR3CjOiF
-6SdAskcBZWhFiRNQweC0iv57/nPCeTCuNAqbZSHd7zC1AKhNmmsKSJUJQCGijcce
-P8Gl0AFfZneN2bVEFvJ/zd71pD8ll1Gkju16bfdWn0V4NRaxFiXNr2bL+ah9blud
-EXOomE3R6ow1QZk+Gnpy3wh9jfwlrJuFoANvHnv4WREbdjwr//71XjBri5p1wPE=
------END CERTIFICATE-----

contrib/certificates/reseed/echelon_at_mail.i2p.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFfzCCA2egAwIBAgIESg3kkzANBgkqhkiG9w0BAQ0FADBwMQswCQYDVQQGEwJY
+WDELMAkGA1UECBMCWFgxCzAJBgNVBAcTAlhYMR4wHAYDVQQKExVJMlAgQW5vbnlt
+b3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEZMBcGA1UEAwwQZWNoZWxvbkBtYWls
+LmkycDAeFw0xNDA3MzExNjQ3MDJaFw0yNDA3MzAxNjQ3MDJaMHAxCzAJBgNVBAYT
+AlhYMQswCQYDVQQIEwJYWDELMAkGA1UEBxMCWFgxHjAcBgNVBAoTFUkyUCBBbm9u
+eW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRkwFwYDVQQDDBBlY2hlbG9uQG1h
+aWwuaTJwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAmcEgLwwhzLNe
+XLOMSrhwB8hWpOhfjo4s6S/wjBtjjUc8nI3D0hSn3HY26p0rvcvNEWexPUpPULmC
+exGkU463nu7PiFONiORI1eJAiUFHibRiaA7Wboyo38pO73KirwjG07Y+Ua0jp+HS
++4FQ/I/9H/bPplReTOU/6hmRbgQ69U8nE68HzZHQxP68yVJ2rPHSXMPhF4R1h0G1
+1mCAT+TgTsnwHNGF77XHJnY4/M4e2cgycEZjZow36C3t2mNDVkMgF19QQeb9WmLR
+zREn3nq9BJqHpUkn9yWw0kKXTZSds+7UxESfzf3BzK0+hky2fh5H+qbYAo2lz4yj
+81MXTAu+4RRkg4DBLlF+2dkclhwQLxxzvkRC6tPkn5i33Yltg7EfzA9IoQ05potJ
+I+iOcF+aStfFgFj9u3B5UkcF4P0cH1QD3c6BK4hIezQYqRoPly1gHqg+XdwjG/dr
+4as7HA9FTz3p2E8nClpIC1x3hfgwAdfd29aeBxO1WW/z99iMF7TBAF+u5T86XEW1
+WpknqCbTli36yJ8a5fPWxZHrryBRJT5yLxejjFeadtutBSwljiVFq+Y38VqwFivq
+VLiBt7IxAsZ8iilgfnnnAvBH6chWfSKb4H7kB4TJvDiV96QmmvoEaWYNHZozMhyK
+tO3b5w+xqbJXyCLA3Q75jD0km76hjcECAwEAAaMhMB8wHQYDVR0OBBYEFAHQcAam
+QRS/EUhuCSr9pB4Ux0rYMA0GCSqGSIb3DQEBDQUAA4ICAQBq1+1QLmgLAjrTg3tb
+4XKgAVICQRoBDNUEobQg3pYeUX9eFNya2RxNljuvYpwT80ilGMPOXcjddmr5ngiK
+dbGRcuuJk9MPEHtPaPT3+JJlvKQ3B3g2wva2Wz2OAyLZUGQs389K4nTbwh4QF0n2
+aHFL8BHiD62hiKnCoNaW4ZovUNNvOxo9lMyAiaFU2gqQNcdad8hP9EAllbvbxDx9
+Tjww2UbwQUIHS9rna4Tlu+f0hDXTWIutc2A51W2fJCb7L3+lYO7Wv55ND/WtryLZ
+XpMp27+MpuEnN3kQmz/l9R0hIJsWc/x9GQkjm5wEaIZEyTtenqwRKGmVCtAj0Pgv
+jn1L3/lWmrNq+OZHb/QeyfKtA3nXfQKVmT98ewQiK/S5i1xIAXCJPytOD887b/o1
+cdurTmCiZMwgiQ+HLJqCg3MDa5mvKqRkRdZXfE6aQWEcSbpAhpV15R17q7L+Fg0W
+shLSNucxyGNU8PjiC/nOmqfqUiPiMltJjPmscxBLim8foyxjakC4+6N6m+Jzgznj
+PocBehFAfKYj66XEwzIBN7Z2uuXoYH9YptkocFjTzvchcryVulDWZ4FWxreUMhpM
+4oyjjhSB4tB9clXlwMqg577q3D6Ms0zLTqsztyPN3zr6jGev3jpVq7Q1GOlciHPv
+JNJOWTH/Vas1W6XlwGcOOAARTQ==
+-----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/i2p-reseed_at_mk16.de.crt

@@ -1,34 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFzTCCA7WgAwIBAgIQeUqFi0fHNQopg6BZlBLhVzANBgkqhkiG9w0BAQsFADBy
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEbMBkGA1UEAwwS
-aTJwLXJlc2VlZEBtazE2LmRlMB4XDTIyMDIwNTE3MzkzM1oXDTMyMDIwNTE3Mzkz
-M1owcjELMAkGA1UEBhMCWFgxCzAJBgNVBAcTAlhYMQswCQYDVQQJEwJYWDEeMBwG
-A1UEChMVSTJQIEFub255bW91cyBOZXR3b3JrMQwwCgYDVQQLEwNJMlAxGzAZBgNV
-BAMMEmkycC1yZXNlZWRAbWsxNi5kZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC
-AgoCggIBAMYxs2D2xpN/8blGawvAlU9DemHIxApOEwaLNfh8aAvqEdB41NTqcx4U
-H8VchSormCfkCvezuMHO+K2HX7ihEZ1v6tbr6aX6hY9UZUyDDYsKmJoB1oKEhddv
-5UYfcWPE2eSykdFsWgTQD6Z+cRQWHEoCzb7qc+Jrw6KcnHMD0VrmBrEQPzTBxMHW
-4HC97PVkSLJTDArnS6ZiX4IbWRPw/mbpJT6EoVZo8J/it0pdn/X4KodEXDcnEMSe
-VRulfZH/nSmOOvKhoHPckmgz/u66BlnuSYXEIB0KfDIcAlSYiPDxGnAemTozJYXA
-UVMeFMs+YE5wiPgzzu+vpC31xtZLq0gyaCfgEi1P9j2ES/8pH3Gw6W2OH4kBx+jO
-TBsfI+ph6qFZ3WWT23MRVyl3ATuI/GHdczTxD9JaOn74lLI+Hnu8wXnyztVWkTMB
-4sAnzjdeHkvNDyQ10vSaN0HnGfg6zuAuUSqFQujFF8Vg8ZCcsh8GouWfzYDvi9mj
-9pfxx8v6UCC719I4J9CgFjWnn2Hqez3fO8fFulY61VPyCCZp4gKWbI2SIQP/n5gz
-ecYJRrJoem+rYfEQ/fwxROsvm3fCO4D6dt7ILRuX286GDIw2qSvP1zZVAioMwSj3
-9CAjKLwD/BhTRiMOlpaVv6IWqjtevbiaIKvbHTnoxvkGsDqe3gJhAgMBAAGjXzBd
-MA4GA1UdDwEB/wQEAwIChDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEw
-DwYDVR0TAQH/BAUwAwEB/zAbBgNVHQ4EFAQSaTJwLXJlc2VlZEBtazE2LmRlMA0G
-CSqGSIb3DQEBCwUAA4ICAQAb+x6XpJdjpVYw2bvWIUbatQJwq0YaEW5W61xGLgIG
-a37oll3YZbSY9Vk+N1cE0f61L3ya4Ioz6zlH/MO2zUG/dEk8vqdgIPUYJvyF7wwF
-w3/G4VMaDKOJx4bAZNmaiRFGYNhCOhCnZx6uZGrLNIJ2Dc+mflrGmGwYphtXVV3e
-Iv+ki3gSRgfXuMfKi4B5bLPnz7XDe4TSmwZZSRac4ly4KqmZUyntqbilRxaGTej3
-VYJ1tac8yppyk5N3VopMQNmBarNZG16wSOTD7CtKgn382jgRW8cR7BMeqhORivp0
-ZnPJFhzh4uthdlPdXXo6lxfvZjfiwlDPytvEu2QBz3urTgopGqRLcTBnLucWg9li
-OSy9z7hNEnIN3iIJJAwI1wBdDa7K0h3PFBbIUa7X2ybn81VeNSfO25Lo8YTZEKsc
-wcThJrNV6qOQv8rM/7aXugi6+VzPlCR+18iKRbebCnlqGR2dT1zFtj3negtOkrjo
-LH4H6VUr3q2Ie56IubS2hUKiUkDm0ckP3Vum35GGntyEAzl6uyog0hJFOJb3aq30
-YQLzyVEOz8NnA+32oMRzJJdDxQ7pqG5fgq7EF4d++YSgEfdVXxvfgXQ6m3jAyC7Z
-p/gX4rlxNsjeGU3Ds51wkmhH4IB1aSQr52PE6RaBhhh3SmADEv6S/3eGvE4F4MN5
-2Q==
------END CERTIFICATE-----

contrib/certificates/reseed/igor_at_novg.net.crt

@@ -1,33 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFvjCCA6agAwIBAgIQBnsUOmOu2oZZIwHBmQc1BDANBgkqhkiG9w0BAQsFADBt
-MQswCQYDVQQGEwJYWDELMAkGA1UEBxMCWFgxCzAJBgNVBAkTAlhYMR4wHAYDVQQK
-ExVJMlAgQW5vbnltb3VzIE5ldHdvcmsxDDAKBgNVBAsTA0kyUDEWMBQGA1UEAwwN
-aWdvckBub3ZnLm5ldDAeFw0yMzAxMjgxNDM4MzFaFw0zMzAxMjgxNDM4MzFaMG0x
-CzAJBgNVBAYTAlhYMQswCQYDVQQHEwJYWDELMAkGA1UECRMCWFgxHjAcBgNVBAoT
-FUkyUCBBbm9ueW1vdXMgTmV0d29yazEMMAoGA1UECxMDSTJQMRYwFAYDVQQDDA1p
-Z29yQG5vdmcubmV0MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvLkf
-bM3uiYfp9m0vgdoftyXtk2/9bHf3u5iaM0WfoJIsw1iizo/mxJl+Iy7SxLC16nV0
-v5FpncVv+Z8x9dgoAYVuLq9zKfsAbpj6kuxAqw6vJMlD1TiIL3nSODV9BJLk47X5
-tmvoOSj9BgvemYThTE3nj+DbuJRW5q90KyBV/LdLrQJX3k5R3FFL5tTad2LKFNZ4
-vEOcYwwx6mvrkJ2lly6bAQUCtfc648Jyq+NO3Rba1fmn7gcP9zXXc5KYsj/ovyY2
-OaocSF5wMhzBuPxO+M2HqbYLMAkc6/GesGds8Rm8wofuhJoI5YtqJuLKZm6nQXSc
-fx6PKgbKcTIUWNFMsxyfghz9hpbg0rkvC7PtfAjtV0yaDtUum1eZeNEx1HbRWN2n
-TQNCVuv0yaKC41qxqzhEybkdjL9JlgUh7VuskaCelB0lz+kgYjGu8ezOa0ua2iKq
-4FC/1MbPulxN8NOt4pmbGqqoxmCdShp38wdnOBM3DsAS9f0JaQZd4CDyY4DCSfVn
-xPdWk31+VXVt3Ixh1EUqZWYTRSsZApkCyYzkiZ/qPGG6FR9Hq2SuhC5o4P44k7eo
-6wwBWD8a5RjsZhvr05E5yBrKXh/PjLwmtG73QC+ouR54/5xtedvdTwNS94FnNctX
-FT6QGZnRwCkhPaRe1oQMzP+88pGoCfO33GBAuwUCAwEAAaNaMFgwDgYDVR0PAQH/
-BAQDAgKEMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAPBgNVHRMBAf8E
-BTADAQH/MBYGA1UdDgQPBA1pZ29yQG5vdmcubmV0MA0GCSqGSIb3DQEBCwUAA4IC
-AQCteAb5/bqhHr/i5CJbDzlofprXFC826c19GxQ/9Hw0kA52l0J9Q8Vz8Vy7VQyP
-QNa8MCv6FeNy8a/wXp6cafyFsBtvehVQO8lFlpCgMEl2Bma43+GaCwkrM6bFNXeW
-iQ9h4e1KjsUZ8cQDNEcamiJ80+xbMhBrj5bAZwKmZs8MoGEMyXKEZmcmwA+/fy1c
-cx4izsOsmRXmEHXsvB9ydJHZZeKW8+r0DAtgPslwXuXHG6MuBQo7dKCqn+iMxHXV
-Jxriq3yvNffdGx4maSLJrjQ1ealt/UMzql7huVSItnVFWoYf7GAELXNJ/PmqVyaK
-q11LQ8W/Aud6s/bblaJrFJnK8PbPpaw4RvHoWVLYaZYmQnV2msWs5EuESBlEADbv
-UklQXLMc2f9HKWPA5678nvYPrmu8IL5pMkAxgGRqmd+7vCz4lU9M5z3HObU+WRBt
-qEMYyXywV8o3tbmnlDS5S5Xxf+tLZn1cxz3ZrmcHPHDbLBNdvszF3CTJH/R2sQvD
-bizvYJM+p5F+GWM5mt6w0HrOut5MRlpOws/NRrkbijuVA/A45nzTtKplIFYE3qe8
-q5SAbwYLc8cJcZCN3PxtWwbEv81V33abMt5QcjnWGLH5t2+1Z2KLCgKLSCQTxM8s
-zBPHtUe8qtSQaElnNLILYbtJ1w67dPnGYTphHihC+CXjBg==
------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-----