2.38.0

Signed-off-by: R4SAS <r4sas@i2pmail.org>

.dir-locals.el

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

.github/workflows/build-freebsd.yml

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

.github/workflows/build-osx.yml

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

.github/workflows/build-windows.yml

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

.github/workflows/build.yml

@@ -0,0 +1,21 @@
+name: Build on Ubuntu
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: With USE_UPNP=${{ matrix.with_upnp }}
+    runs-on: ubuntu-16.04
+    strategy:
+      fail-fast: true
+      matrix:
+        with_upnp: ['yes', 'no']
+    steps:
+    - uses: actions/checkout@v2
+    - name: install packages
+      run: |
+        sudo add-apt-repository ppa:mhier/libboost-latest
+        sudo apt-get update
+        sudo apt-get install build-essential libboost1.74-dev libminiupnpc-dev libssl-dev zlib1g-dev
+    - name: build application
+      run: make USE_UPNP=${{ matrix.with_upnp }} -j3

.gitignore

@@ -1,16 +1,22 @@
 # i2pd
-obj/*.o
+*.o
 router.info
 router.keys
 i2p
-libi2pd.so
 netDb
+/i2pd
+/libi2pd.a
+/libi2pdclient.a
+/libi2pd.so
+/libi2pdclient.so
+*.exe
+
 
 # Autotools
 autom4te.cache
 .deps
 stamp-h1
-Makefile
+#Makefile
 config.h
 config.h.in~
 config.log
@@ -233,3 +239,35 @@ pip-log.txt
 
 # Sphinx
 docs/_build
+/androidIdea/
+
+# Doxygen
+docs/generated
+
+# emacs files
+*~
+*\#*
+
+# gdb files
+.gdb_history
+
+# cmake makefile
+build/Makefile
+
+# debian stuff
+.pc/
+
+# qt 
+
+qt/i2pd_qt/*.autosave
+qt/i2pd_qt/*.ui.bk*
+qt/i2pd_qt/*.ui_*
+
+#unknown android stuff
+android/libs/
+
+#various logs
+*LOGS/
+
+qt/build-*.sh*
+

.travis.yml

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

AddressBook.cpp

@@ -1,582 +0,0 @@
-#include <string.h>
-#include <inttypes.h>
-#include <string>
-#include <map>
-#include <fstream>
-#include <chrono>
-#include <condition_variable>
-#include <boost/lexical_cast.hpp>
-#include "Base.h"
-#include "util.h"
-#include "Identity.h"
-#include "FS.h"
-#include "Log.h"
-#include "NetDb.h"
-#include "ClientContext.h"
-#include "AddressBook.h"
-
-namespace i2p
-{
-namespace client
-{
-	// TODO: this is actually proxy class
-	class AddressBookFilesystemStorage: public AddressBookStorage
-	{
-		private:
-			i2p::fs::HashedStorage storage;
-			std::string indexPath;
-
-		public:
-			AddressBookFilesystemStorage (): storage("addressbook", "b", "", "b32") {};
-			std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const;
-			void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address);
-			void RemoveAddress (const i2p::data::IdentHash& ident);
-
-			bool Init ();
-			int Load (std::map<std::string, i2p::data::IdentHash>& addresses);
-			int Save (const std::map<std::string, i2p::data::IdentHash>& addresses);
-	};
-
-	bool AddressBookFilesystemStorage::Init()
-	{
-		storage.SetPlace(i2p::fs::GetDataDir());
-		indexPath = storage.GetRoot() + i2p::fs::dirSep + "addresses.csv";
-		return storage.Init(i2p::data::GetBase32SubstitutionTable(), 32);
-	}
-
-	std::shared_ptr<const i2p::data::IdentityEx> AddressBookFilesystemStorage::GetAddress (const i2p::data::IdentHash& ident) const
-	{
-		std::string filename = storage.Path(ident.ToBase32());
-		std::ifstream f(filename, std::ifstream::binary);
-		if (!f.is_open ()) {
-			LogPrint(eLogDebug, "Addressbook: Requested, but not found: ", filename);
-			return nullptr;
-		}
-
-		f.seekg (0,std::ios::end);
-		size_t len = f.tellg ();
-		if (len < i2p::data::DEFAULT_IDENTITY_SIZE) {
-			LogPrint (eLogError, "Addresbook: File ", filename, " is too short: ", len);
-			return nullptr;
-		}
-		f.seekg(0, std::ios::beg);
-		uint8_t * buf = new uint8_t[len];
-		f.read((char *)buf, len);
-		auto address = std::make_shared<i2p::data::IdentityEx>(buf, len);
-		delete[] buf;
-		return address;
-	}
-
-	void AddressBookFilesystemStorage::AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address)
-	{
-		std::string path = storage.Path( address->GetIdentHash().ToBase32() );
-		std::ofstream f (path, std::ofstream::binary | std::ofstream::out);
-		if (!f.is_open ())	{
-			LogPrint (eLogError, "Addresbook: can't open file ", path);
-			return;
-		}
-		size_t len = address->GetFullLen ();
-		uint8_t * buf = new uint8_t[len];
-		address->ToBuffer (buf, len);
-		f.write ((char *)buf, len);
-		delete[] buf;
-	}	
-
-	void AddressBookFilesystemStorage::RemoveAddress (const i2p::data::IdentHash& ident)
-	{
-		storage.Remove( ident.ToBase32() );
-	}
-
-	int AddressBookFilesystemStorage::Load (std::map<std::string, i2p::data::IdentHash>& addresses)
-	{
-		int num = 0;	
-		std::string s;
-		std::ifstream f (indexPath, std::ifstream::in); // in text mode
-
-		if (f.is_open ()) {
-			LogPrint(eLogInfo, "Addressbook: using index file ", indexPath);
-		} else {
-			LogPrint(eLogWarning, "Addressbook: Can't open ", indexPath);
-			return 0;
-		}
-
-		addresses.clear ();
-		while (!f.eof ()) {
-			getline(f, s);
-			if (!s.length())
-				continue; // skip empty line
-
-			std::size_t pos = s.find(',');
-			if (pos != std::string::npos)
-			{
-				std::string name = s.substr(0, pos++);
-				std::string addr = s.substr(pos);
-
-				i2p::data::IdentHash ident;
-				ident.FromBase32 (addr);
-				addresses[name] = ident;
-				num++;
-			}		
-		}
-
-		LogPrint (eLogInfo, "Addressbook: ", num, " addresses loaded from storage");
-		return num;
-	}
-
-	int AddressBookFilesystemStorage::Save (const std::map<std::string, i2p::data::IdentHash>& addresses)
-	{
-		if (addresses.size() == 0) {
-			LogPrint(eLogWarning, "Addressbook: not saving empty addressbook");
-			return 0;
-		}
-
-		int num = 0;
-		std::ofstream f (indexPath, std::ofstream::out); // in text mode
-
-		if (!f.is_open ()) {
-			LogPrint (eLogWarning, "Addressbook: Can't open ", indexPath);
-			return 0;
-		}
-
-		for (auto it: addresses) {
-			f << it.first << "," << it.second.ToBase32 () << std::endl;
-			num++;
-		}
-		LogPrint (eLogInfo, "Addressbook: ", num, " addresses saved");
-		return num;	
-	}	
-
-//---------------------------------------------------------------------
-	AddressBook::AddressBook (): m_Storage(new AddressBookFilesystemStorage), m_IsLoaded (false), m_IsDownloading (false), 
-		m_DefaultSubscription (nullptr), m_SubscriptionsUpdateTimer (nullptr)
-	{
-	}
-
-	AddressBook::~AddressBook ()
-	{	
-		Stop ();
-	}
-
-	void AddressBook::Start ()
-	{
-		m_Storage->Init();
-		LoadHosts (); /* try storage, then hosts.txt, then download */
-		StartSubscriptions ();
-	}
-	
-	void AddressBook::Stop ()
-	{
-		StopSubscriptions ();
-		if (m_SubscriptionsUpdateTimer)
-		{	
-			delete m_SubscriptionsUpdateTimer;	
-			m_SubscriptionsUpdateTimer = nullptr;
-		}	
-		if (m_IsDownloading)
-		{
-			LogPrint (eLogInfo, "Addresbook: subscriptions is downloading, abort");
-			for (int i = 0; i < 30; i++)
-			{
-				if (!m_IsDownloading)
-				{
-					LogPrint (eLogInfo, "Addresbook: subscriptions download complete");
-					break;
-				}	
-				std::this_thread::sleep_for (std::chrono::seconds (1)); // wait for 1 seconds
-			}	
-			LogPrint (eLogError, "Addresbook: subscription download timeout");
-			m_IsDownloading = false;
-		}	
-		if (m_Storage)
-		{
-			m_Storage->Save (m_Addresses);
-			delete m_Storage;
-			m_Storage = nullptr;
-		}
-		m_DefaultSubscription = nullptr;	
-		for (auto it: m_Subscriptions)
-			delete it;
-		m_Subscriptions.clear ();	
-	}	
-	
-	bool AddressBook::GetIdentHash (const std::string& address, i2p::data::IdentHash& ident)
-	{
-		auto pos = address.find(".b32.i2p");
-		if (pos != std::string::npos)
-		{
-			Base32ToByteStream (address.c_str(), pos, ident, 32);
-			return true;
-		}
-		else
-		{	
-			pos = address.find (".i2p");
-			if (pos != std::string::npos)
-			{
-				auto identHash = FindAddress (address);	
-				if (identHash)
-				{
-					ident = *identHash;
-					return true;
-				}
-				else
-					return false;
-			}
-		}	
-		// if not .b32 we assume full base64 address
-		i2p::data::IdentityEx dest;
-		if (!dest.FromBase64 (address))
-			return false;
-		ident = dest.GetIdentHash ();
-		return true;
-	}
-	
-	const i2p::data::IdentHash * AddressBook::FindAddress (const std::string& address)
-	{
-		auto it = m_Addresses.find (address);
-		if (it != m_Addresses.end ())
-			return &it->second;
-		return nullptr;	
-	}
-
-	void AddressBook::InsertAddress (const std::string& address, const std::string& base64)
-	{
-		auto ident = std::make_shared<i2p::data::IdentityEx>();
-		ident->FromBase64 (base64);
-		m_Storage->AddAddress (ident);
-		m_Addresses[address] = ident->GetIdentHash ();
-		LogPrint (eLogInfo, "Addressbook: added ", address," -> ", ToAddress(ident->GetIdentHash ()));
-	}
-
-	void AddressBook::InsertAddress (std::shared_ptr<const i2p::data::IdentityEx> address)
-	{
-		m_Storage->AddAddress (address);
-	}
-
-	std::shared_ptr<const i2p::data::IdentityEx> AddressBook::GetAddress (const std::string& address)
-	{
-		i2p::data::IdentHash ident;
-		if (!GetIdentHash (address, ident)) return nullptr;
-		return m_Storage->GetAddress (ident);
-	}	
-
-	void AddressBook::LoadHosts ()
-	{
-		if (m_Storage->Load (m_Addresses) > 0)
-		{
-			m_IsLoaded = true;
-			return;
-		}
-	
-		// then try hosts.txt
-		std::ifstream f (i2p::fs::DataDirPath("hosts.txt"), std::ifstream::in); // in text mode
-		if (f.is_open ())	
-		{
-			LoadHostsFromStream (f);
-			m_IsLoaded = true;
-		}
-	}
-
-	void AddressBook::LoadHostsFromStream (std::istream& f)
-	{
-		std::unique_lock<std::mutex> l(m_AddressBookMutex);
-		int numAddresses = 0;
-		std::string s;
-		while (!f.eof ())
-		{
-			getline(f, s);
-
-			if (!s.length())
-				continue; // skip empty line
-
-			size_t pos = s.find('=');
-
-			if (pos != std::string::npos)
-			{
-				std::string name = s.substr(0, pos++);
-				std::string addr = s.substr(pos);
-
-				auto ident = std::make_shared<i2p::data::IdentityEx> ();
-				if (ident->FromBase64(addr))
-				{	
-					m_Addresses[name] = ident->GetIdentHash ();
-					m_Storage->AddAddress (ident);
-					numAddresses++;
-				}	
-				else
-					LogPrint (eLogError, "Addresbook: malformed address ", addr, " for ", name);
-			}		
-		}
-		LogPrint (eLogInfo, "Addresbook: ", numAddresses, " addresses processed");
-		if (numAddresses > 0)
-		{	
-			m_IsLoaded = true;
-			m_Storage->Save (m_Addresses);
-		}	
-	}	
-	
-	void AddressBook::LoadSubscriptions ()
-	{
-		if (!m_Subscriptions.size ())
-		{
-			std::ifstream f (i2p::fs::DataDirPath ("subscriptions.txt"), std::ifstream::in); // in text mode
-			if (f.is_open ())
-			{
-				std::string s;
-				while (!f.eof ())
-				{
-					getline(f, s);
-					if (!s.length()) continue; // skip empty line
-					m_Subscriptions.push_back (new AddressBookSubscription (*this, s));
-				}
-				LogPrint (eLogInfo, "Addressbook: ", m_Subscriptions.size (), " subscriptions urls loaded");
-			}
-			else
-				LogPrint (eLogWarning, "Addresbook: subscriptions.txt not found in datadir");
-		}
-		else
-			LogPrint (eLogError, "Addressbook: subscriptions already loaded");
-	}
-
-	void AddressBook::DownloadComplete (bool success)
-	{
-		m_IsDownloading = false;
-		if (success && m_DefaultSubscription)
-		{	
-			m_DefaultSubscription.reset (nullptr);
-			m_IsLoaded = true;
-		}	
-		if (m_SubscriptionsUpdateTimer)
-		{
-			m_SubscriptionsUpdateTimer->expires_from_now (boost::posix_time::minutes(
-				success ? CONTINIOUS_SUBSCRIPTION_UPDATE_TIMEOUT : CONTINIOUS_SUBSCRIPTION_RETRY_TIMEOUT));
-			m_SubscriptionsUpdateTimer->async_wait (std::bind (&AddressBook::HandleSubscriptionsUpdateTimer,
-				this, std::placeholders::_1));
-		}
-	}
-
-	void AddressBook::StartSubscriptions ()
-	{
-		LoadSubscriptions ();
-		if (m_IsLoaded && m_Subscriptions.empty ()) return;
-		
-		auto dest = i2p::client::context.GetSharedLocalDestination ();
-		if (dest)
-		{
-			m_SubscriptionsUpdateTimer = new boost::asio::deadline_timer (dest->GetService ());
-			m_SubscriptionsUpdateTimer->expires_from_now (boost::posix_time::minutes(INITIAL_SUBSCRIPTION_UPDATE_TIMEOUT));
-			m_SubscriptionsUpdateTimer->async_wait (std::bind (&AddressBook::HandleSubscriptionsUpdateTimer,
-				this, std::placeholders::_1));
-		}
-		else
-			LogPrint (eLogError, "Addresbook: can't start subscriptions: missing shared local destination");
-	}
-
-	void AddressBook::StopSubscriptions ()
-	{
-		if (m_SubscriptionsUpdateTimer)
-			m_SubscriptionsUpdateTimer->cancel ();
-	}
-
-	void AddressBook::HandleSubscriptionsUpdateTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			auto dest = i2p::client::context.GetSharedLocalDestination ();
-			if (!dest) {
-				LogPrint(eLogWarning, "Addressbook: missing local destination, skip subscription update");
-				return;
-			}
-			if (!m_IsDownloading && dest->IsReady ())
-			{
-				if (!m_IsLoaded)
-				{
-					// download it from http://i2p-projekt.i2p/hosts.txt 
-					LogPrint (eLogInfo, "Addressbook: trying to download it from default subscription.");
-					if (!m_DefaultSubscription)
-						m_DefaultSubscription.reset (new AddressBookSubscription (*this, DEFAULT_SUBSCRIPTION_ADDRESS));
-					m_IsDownloading = true;	
-					m_DefaultSubscription->CheckSubscription ();
-				}	
-				else if (!m_Subscriptions.empty ())
-				{	
-					// pick random subscription
-					auto ind = rand () % m_Subscriptions.size();	
-					m_IsDownloading = true;	
-					m_Subscriptions[ind]->CheckSubscription ();
-				}	
-			}
-			else
-			{
-				// try it again later
-				m_SubscriptionsUpdateTimer->expires_from_now (boost::posix_time::minutes(INITIAL_SUBSCRIPTION_RETRY_TIMEOUT));
-				m_SubscriptionsUpdateTimer->async_wait (std::bind (&AddressBook::HandleSubscriptionsUpdateTimer,
-					this, std::placeholders::_1));
-			}
-		}
-	}
-
-	AddressBookSubscription::AddressBookSubscription (AddressBook& book, const std::string& link):
-		m_Book (book), m_Link (link)
-	{
-	}
-
-	void AddressBookSubscription::CheckSubscription ()
-	{
-		std::thread load_hosts(&AddressBookSubscription::Request, this);
-		load_hosts.detach(); // TODO: use join
-	}
-
-	void AddressBookSubscription::Request ()
-	{
-		// must be run in separate thread	
-		LogPrint (eLogInfo, "Addresbook: Downloading hosts database from ", m_Link, " ETag: ", m_Etag, " Last-Modified: ", m_LastModified);
-		bool success = false;	
-		i2p::util::http::url u (m_Link);
-		i2p::data::IdentHash ident;
-		if (m_Book.GetIdentHash (u.host_, ident))
-		{
-			std::condition_variable newDataReceived;
-			std::mutex newDataReceivedMutex;
-			auto leaseSet = i2p::client::context.GetSharedLocalDestination ()->FindLeaseSet (ident);
-			if (!leaseSet)
-			{
-				std::unique_lock<std::mutex> l(newDataReceivedMutex);
-				i2p::client::context.GetSharedLocalDestination ()->RequestDestination (ident,
-					[&newDataReceived, &leaseSet](std::shared_ptr<i2p::data::LeaseSet> ls)
-				    {
-						leaseSet = ls;
-						newDataReceived.notify_all ();
-					});
-				if (newDataReceived.wait_for (l, std::chrono::seconds (SUBSCRIPTION_REQUEST_TIMEOUT)) == std::cv_status::timeout)
-				{	
-					LogPrint (eLogError, "Addressbook: Subscription LeaseSet request timeout expired");
-					i2p::client::context.GetSharedLocalDestination ()->CancelDestinationRequest (ident);
-				}	
-			}
-			if (leaseSet)
-			{
-				std::stringstream request, response;
-				// standard header
-				request << "GET "   << u.path_ << " HTTP/1.1\r\n"
-				        << "Host: " << u.host_ << "\r\n"
-				        << "Accept: */*\r\n"
-				        << "User-Agent: Wget/1.11.4\r\n"
-						//<< "Accept-Encoding: gzip\r\n"
-						<< "X-Accept-Encoding: x-i2p-gzip;q=1.0, identity;q=0.5, deflate;q=0, gzip;q=0, *;q=0\r\n"
-				        << "Connection: close\r\n";
-				if (m_Etag.length () > 0) // etag
-					request << i2p::util::http::IF_NONE_MATCH << ": \"" << m_Etag << "\"\r\n";
-				if (m_LastModified.length () > 0) // if-modfief-since
-					request << i2p::util::http::IF_MODIFIED_SINCE << ": " << m_LastModified << "\r\n";
-				request << "\r\n"; // end of header
-				auto stream = i2p::client::context.GetSharedLocalDestination ()->CreateStream (leaseSet, u.port_);
-				stream->Send ((uint8_t *)request.str ().c_str (), request.str ().length ());
-				
-				uint8_t buf[4096];
-				bool end = false;
-				while (!end)
-				{
-					stream->AsyncReceive (boost::asio::buffer (buf, 4096), 
-						[&](const boost::system::error_code& ecode, std::size_t bytes_transferred)
-						{
-							if (bytes_transferred)
-								response.write ((char *)buf, bytes_transferred);
-							if (ecode == boost::asio::error::timed_out || !stream->IsOpen ())
-								end = true;	
-							newDataReceived.notify_all ();
-						},
-						30); // wait for 30 seconds
-					std::unique_lock<std::mutex> l(newDataReceivedMutex);
-					if (newDataReceived.wait_for (l, std::chrono::seconds (SUBSCRIPTION_REQUEST_TIMEOUT)) == std::cv_status::timeout)
-						LogPrint (eLogError, "Addresbook: subscriptions request timeout expired");
-				}
-				// process remaining buffer
-				while (size_t len = stream->ReadSome (buf, 4096))
-					response.write ((char *)buf, len);
-				
-				// parse response
-				std::string version;
-				response >> version; // HTTP version
-				int status = 0;
-				response >> status; // status
-				if (status == 200) // OK
-				{
-					bool isChunked = false, isGzip = false;
-					std::string header, statusMessage;
-					std::getline (response, statusMessage);
-					// read until new line meaning end of header
-					while (!response.eof () && header != "\r")
-					{
-						std::getline (response, header);
-						auto colon = header.find (':');
-						if (colon != std::string::npos)
-						{
-							std::string field = header.substr (0, colon);
-							boost::to_lower (field); // field are not case-sensitive
-							colon++;
-							header.resize (header.length () - 1); // delete \r	
-							if (field == i2p::util::http::ETAG)
-								m_Etag = header.substr (colon + 1);
-							else if (field == i2p::util::http::LAST_MODIFIED)
-								m_LastModified = header.substr (colon + 1);
-							else if (field == i2p::util::http::TRANSFER_ENCODING)
-								isChunked = !header.compare (colon + 1, std::string::npos, "chunked");
-							else if (field == i2p::util::http::CONTENT_ENCODING)
-								isGzip = !header.compare (colon + 1, std::string::npos, "gzip") ||
-									!header.compare (colon + 1, std::string::npos, "x-i2p-gzip");
-						}	
-					}
-					LogPrint (eLogInfo, "Addressbook: ", m_Link, " ETag: ", m_Etag, " Last-Modified: ", m_LastModified);
-					if (!response.eof ())	
-					{
-						success = true;
-						if (!isChunked)
-							success = ProcessResponse (response, isGzip);
-						else
-						{
-							// merge chunks
-							std::stringstream merged;
-							i2p::util::http::MergeChunkedResponse (response, merged);
-							success = ProcessResponse (merged, isGzip);
-						}	
-					}	
-				}
-				else if (status == 304)
-				{	
-					success = true;
-					LogPrint (eLogInfo, "Addressbook: no updates from ", m_Link);
-				}	
-				else
-					LogPrint (eLogWarning, "Adressbook: HTTP response ", status);
-			}
-			else
-				LogPrint (eLogError, "Addressbook: address ", u.host_, " not found");
-		}
-		else
-			LogPrint (eLogError, "Addressbook: Can't resolve ", u.host_);
-
-		if (!success)
-			LogPrint (eLogError, "Addressbook: download hosts.txt from ", m_Link, " failed");
-
-		m_Book.DownloadComplete (success);
-	}
-
-	bool AddressBookSubscription::ProcessResponse (std::stringstream& s, bool isGzip)
-	{
-		if (isGzip)
-		{
-			std::stringstream uncompressed;
-			i2p::data::GzipInflator inflator;
-			inflator.Inflate (s, uncompressed);
-			if (!uncompressed.fail ())
-				m_Book.LoadHostsFromStream (uncompressed);
-			else
-				return false;
-		}	
-		else
-			m_Book.LoadHostsFromStream (s);
-		return true;	
-	}
-}
-}
-

AddressBook.h

@@ -1,106 +0,0 @@
-#ifndef ADDRESS_BOOK_H__
-#define ADDRESS_BOOK_H__
-
-#include <string.h>
-#include <string>
-#include <map>
-#include <vector>
-#include <iostream>
-#include <mutex>
-#include <memory>
-#include <boost/asio.hpp>
-#include "Base.h"
-#include "Identity.h"
-#include "Log.h"
-
-namespace i2p
-{
-namespace client
-{
-	const char DEFAULT_SUBSCRIPTION_ADDRESS[] = "http://udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p/hosts.txt";
-	const int INITIAL_SUBSCRIPTION_UPDATE_TIMEOUT = 3; // in minutes	
-	const int INITIAL_SUBSCRIPTION_RETRY_TIMEOUT = 1; // in minutes			
-	const int CONTINIOUS_SUBSCRIPTION_UPDATE_TIMEOUT = 720; // in minutes (12 hours)			
-	const int CONTINIOUS_SUBSCRIPTION_RETRY_TIMEOUT = 5; // in minutes	
-	const int SUBSCRIPTION_REQUEST_TIMEOUT = 60; //in second
-	
-	inline std::string GetB32Address(const i2p::data::IdentHash& ident) { return ident.ToBase32().append(".b32.i2p"); }
-
-	class AddressBookStorage // interface for storage
-	{
-		public:
-
-			virtual ~AddressBookStorage () {};
-			virtual std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const = 0;	
-			virtual void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address) = 0;
-			virtual void RemoveAddress (const i2p::data::IdentHash& ident) = 0;
-		
-			virtual bool Init () = 0;
-			virtual int Load (std::map<std::string, i2p::data::IdentHash>& addresses) = 0;
-			virtual int Save (const std::map<std::string, i2p::data::IdentHash>& addresses) = 0;
-	};			
-
-	class AddressBookSubscription;
-	class AddressBook
-	{
-		public:
-
-			AddressBook ();
-			~AddressBook ();
-			void Start ();
-			void Stop ();
-			bool GetIdentHash (const std::string& address, i2p::data::IdentHash& ident);
-			std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const std::string& address);
-			const i2p::data::IdentHash * FindAddress (const std::string& address);
-			void InsertAddress (const std::string& address, const std::string& base64); // for jump service
-			void InsertAddress (std::shared_ptr<const i2p::data::IdentityEx> address);
-
-			void LoadHostsFromStream (std::istream& f);
-			void DownloadComplete (bool success);
-			//This method returns the ".b32.i2p" address
-			std::string ToAddress(const i2p::data::IdentHash& ident) { return GetB32Address(ident); }
-			std::string ToAddress(std::shared_ptr<const i2p::data::IdentityEx> ident) { return ToAddress(ident->GetIdentHash ()); }
-		private:
-
-			void StartSubscriptions ();
-			void StopSubscriptions ();
-			
-			void LoadHosts ();
-			void LoadSubscriptions ();
-
-			void HandleSubscriptionsUpdateTimer (const boost::system::error_code& ecode);
-
-		private:	
-
-			std::mutex m_AddressBookMutex;
-			std::map<std::string, i2p::data::IdentHash>  m_Addresses;
-			AddressBookStorage * m_Storage;
-			volatile bool m_IsLoaded, m_IsDownloading;
-			std::vector<AddressBookSubscription *> m_Subscriptions;
-			std::unique_ptr<AddressBookSubscription> m_DefaultSubscription; // in case if we don't know any addresses yet
-			boost::asio::deadline_timer * m_SubscriptionsUpdateTimer;
-	};
-
-	class AddressBookSubscription
-	{
-		public:
-
-			AddressBookSubscription (AddressBook& book, const std::string& link);
-			void CheckSubscription ();
-
-		private:
-
-			void Request ();
-			bool ProcessResponse (std::stringstream& s, bool isGzip = false);
-		
-		private:
-
-			AddressBook& m_Book;
-			std::string m_Link, m_Etag, m_LastModified;
-	};
-}
-}
-
-#endif
-
-

BOB.cpp

@@ -1,643 +0,0 @@
-#include <string.h>
-#include <boost/lexical_cast.hpp>
-#include "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 (eLogError, "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 (eLogError, "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 (eLogError, "BOB: LeaseSet for inbound destination not found");
-	}	
-
-	void BOBI2PInboundTunnel::CreateConnection (std::shared_ptr<AddressReceiver> receiver, std::shared_ptr<const i2p::data::LeaseSet> leaseSet)
-	{
-		LogPrint (eLogDebug, "BOB: New 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 (eLogError, "BOB: 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 (eLogError, "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, "BOB: Malformed input of the 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 bytes_transferred)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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 * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: zap");
-		Terminate ();
-	}
-
-	void BOBCommandSession::QuitCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: quit");
-		m_IsOpen = false;
-		SendReplyOK ("Bye!");
-	}
-
-	void BOBCommandSession::StartCommandHandler (const char * operand, size_t len)
-	{
-		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 * operand, size_t len)
-	{
-		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 len)
-	{
-		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 len)
-	{
-		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 * operand, size_t len)
-	{
-		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 len)
-	{
-		LogPrint (eLogDebug, "BOB: setkeys ", operand);
-		m_Keys.FromBase64 (operand);
-		SendReplyOK (m_Keys.GetPublic ()->ToBase64 ().c_str ());
-	}
-		
-	void BOBCommandSession::GetkeysCommandHandler (const char * operand, size_t len)
-	{		
-		LogPrint (eLogDebug, "BOB: getkeys");
-		SendReplyOK (m_Keys.ToBase64 ().c_str ());
-	}	
-
-	void BOBCommandSession::GetdestCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: getdest");
-		SendReplyOK (m_Keys.GetPublic ()->ToBase64 ().c_str ());
-	}	
-		
-	void BOBCommandSession::OuthostCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: outhost ", operand);
-		m_Address = operand;
-		SendReplyOK ("outhost set");
-	}
-		
-	void BOBCommandSession::OutportCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: outport ", operand);
-		m_OutPort = boost::lexical_cast<int>(operand);
-		SendReplyOK ("outbound port set");
-	}	
-
-	void BOBCommandSession::InhostCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: inhost ", operand);
-		m_Address = operand;
-		SendReplyOK ("inhost set");
-	}
-		
-	void BOBCommandSession::InportCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: inport ", operand);
-		m_InPort = boost::lexical_cast<int>(operand);
-		SendReplyOK ("inbound port set");
-	}		
-
-	void BOBCommandSession::QuietCommandHandler (const char * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: quiet");
-		m_IsQuiet = true;
-		SendReplyOK ("quiet");
-	}	
-	
-	void BOBCommandSession::LookupCommandHandler (const char * operand, size_t len)
-	{
-		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 * operand, size_t len)
-	{
-		LogPrint (eLogDebug, "BOB: clear");
-		m_Owner.DeleteDestination (m_Nickname);
-		SendReplyOK ("cleared");
-	}	
-
-	void BOBCommandSession::ListCommandHandler (const char * operand, size_t len)
-	{
-		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 len)
-	{
-		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: runtime exception: ", 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, "BOB: New command connection from ", session->GetSocket ().remote_endpoint ());
-			session->SendVersion ();	
-		}
-		else
-			LogPrint (eLogError, "BOB: accept error: ",  ecode.message ());
-	}
-}
-}
-

Base.cpp

@@ -1,390 +0,0 @@
-#include <stdlib.h>
-#include "Log.h"
-#include "Base.h"
-
-namespace i2p
-{
-namespace data
-{
-	static const char T32[32] = {
-		'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-		'i', 'k', 'k', 'l', 'm', 'n', 'o', 'p',
-		'q', 'r', 't', 't', 'u', 'v', 'w', 'x',
-		'y', 'z', '2', '3', '4', '5', '6', '7',
-	};
-
-	const char * GetBase32SubstitutionTable ()
-	{
-		return T32;
-	}
-
-	static void iT64Build(void);
-
-	/*
-	*
-	* BASE64 Substitution Table
-	* -------------------------
-	*
-	* Direct Substitution Table
-	*/
-
-	static const char T64[64] = {
-		       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-		       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-		       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-		       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-		       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-		       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-		       'w', 'x', 'y', 'z', '0', '1', '2', '3',
-		       '4', '5', '6', '7', '8', '9', '-', '~'
-	};
-
-	const char * GetBase64SubstitutionTable ()
-	{
-		return T64;
-	}	
-	
-	/*
-	* Reverse Substitution Table (built in run time)
-	*/
-
-	static char iT64[256];
-	static int isFirstTime = 1;
-
-	/*
-	* Padding 
-	*/
-
-	static char P64 = '='; 
-
-	/*
-	*
-	* ByteStreamToBase64
-	* ------------------
-	*
-	* Converts binary encoded data to BASE64 format.
-	*
-	*/
-
-	size_t                                /* Number of bytes in the encoded buffer */
-	ByteStreamToBase64 ( 
-		    const uint8_t * InBuffer,           /* Input buffer, binary data */
-		    size_t    InCount,              /* Number of bytes in the input buffer */ 
-		    char  * OutBuffer,          /* output buffer */
-		size_t len			   /* length of output buffer */	             
-	)
-
-	{
-		unsigned char * ps;
-		unsigned char * pd;
-		unsigned char   acc_1;
-		unsigned char   acc_2;
-		int             i; 
-		int             n; 
-		int             m; 
-		size_t outCount;
-
-		ps = (unsigned char *)InBuffer;
-		n = InCount/3;
-		m = InCount%3;
-		if (!m)
-		     outCount = 4*n;
-		else
-		     outCount = 4*(n+1);
-		if (outCount > len) return 0;
-		pd = (unsigned char *)OutBuffer;
-		for ( i = 0; i<n; i++ ){
-		     acc_1 = *ps++;
-		     acc_2 = (acc_1<<4)&0x30; 
-		     acc_1 >>= 2;              /* base64 digit #1 */
-		     *pd++ = T64[acc_1];
-		     acc_1 = *ps++;
-		     acc_2 |= acc_1 >> 4;      /* base64 digit #2 */
-		     *pd++ = T64[acc_2];
-		     acc_1 &= 0x0f;
-		     acc_1 <<=2;
-		     acc_2 = *ps++;
-		     acc_1 |= acc_2>>6;        /* base64 digit #3 */
-		     *pd++ = T64[acc_1];
-		     acc_2 &= 0x3f;            /* base64 digit #4 */
-		     *pd++ = T64[acc_2];
-		} 
-		if ( m == 1 ){
-		     acc_1 = *ps++;
-		     acc_2 = (acc_1<<4)&0x3f;  /* base64 digit #2 */
-		     acc_1 >>= 2;              /* base64 digit #1 */
-		     *pd++ = T64[acc_1];
-		     *pd++ = T64[acc_2];
-		     *pd++ = P64;
-		     *pd++ = P64;
-
-		}
-		else if ( m == 2 ){
-		     acc_1 = *ps++;
-		     acc_2 = (acc_1<<4)&0x3f; 
-		     acc_1 >>= 2;              /* base64 digit #1 */
-		     *pd++ = T64[acc_1];
-		     acc_1 = *ps++;
-		     acc_2 |= acc_1 >> 4;      /* base64 digit #2 */
-		     *pd++ = T64[acc_2];
-		     acc_1 &= 0x0f;
-		     acc_1 <<=2;               /* base64 digit #3 */
-		     *pd++ = T64[acc_1];
-		     *pd++ = P64;
-		}
-		
-		return outCount;
-	}
-
-	/*
-	*
-	* Base64ToByteStream
-	* ------------------
-	*
-	* Converts BASE64 encoded data to binary format. If input buffer is
-	* not properly padded, buffer of negative length is returned
-	*
-	*/
-
-	size_t                              /* Number of output bytes */
-	Base64ToByteStream ( 
-		      const char * InBuffer,           /* BASE64 encoded buffer */
-		      size_t    InCount,          /* Number of input bytes */
-		      uint8_t  * OutBuffer,	/* output buffer length */ 	
-		  size_t len         	/* length of output buffer */
-	)
-	{
-		unsigned char * ps;
-		unsigned char * pd;
-		unsigned char   acc_1;
-		unsigned char   acc_2;
-		int             i; 
-		int             n; 
-		int             m; 
-		size_t outCount;
-
-		if (isFirstTime) iT64Build();
-		n = InCount/4;
-		m = InCount%4;
-		if (InCount && !m) 
-		     outCount = 3*n;
-		else {
-		     outCount = 0;
-		     return 0;
-		}
-		
-		ps = (unsigned char *)(InBuffer + InCount - 1);
-		while ( *ps-- == P64 ) outCount--;
-		ps = (unsigned char *)InBuffer;
-		
-		if (outCount > len) return -1;
-		pd = OutBuffer;
-		auto endOfOutBuffer = OutBuffer + outCount;		
-		for ( i = 0; i < n; i++ ){
-		     acc_1 = iT64[*ps++];
-		     acc_2 = iT64[*ps++];
-		     acc_1 <<= 2;
-		     acc_1 |= acc_2>>4;
-		     *pd++  = acc_1;
-			 if (pd >= endOfOutBuffer) break;
-
-		     acc_2 <<= 4;
-		     acc_1 = iT64[*ps++];
-		     acc_2 |= acc_1 >> 2;
-		     *pd++ = acc_2;
-			  if (pd >= endOfOutBuffer) break;	
-
-		     acc_2 = iT64[*ps++];
-		     acc_2 |= acc_1 << 6;
-		     *pd++ = acc_2;
-		}
-
-		return outCount;
-	}
-
-	size_t Base64EncodingBufferSize (const size_t input_size) 
-	{
-		auto d = div (input_size, 3);
-		if (d.rem) d.quot++;
-		return 4*d.quot;
-	}
-	
-	/*
-	*
-	* iT64
-	* ----
-	* Reverse table builder. P64 character is replaced with 0
-	*
-	*
-	*/
-
-	static void iT64Build()
-	{
-		int  i;
-		isFirstTime = 0;
-		for ( i=0; i<256; i++ ) iT64[i] = -1;
-		for ( i=0; i<64; i++ ) iT64[(int)T64[i]] = i;
-		iT64[(int)P64] = 0;
-	}
-
-	size_t Base32ToByteStream (const char * inBuf, size_t len, uint8_t * outBuf, size_t outLen) 
-	{
-		int tmp = 0, bits = 0;
-		size_t ret = 0;
-		for (size_t i = 0; i < len; i++)
-		{
-			char ch = inBuf[i];	
-			if (ch >= '2' && ch <= '7') // digit
-				ch = (ch - '2') + 26; // 26 means a-z
-			else if (ch >= 'a' && ch <= 'z')
-				ch = ch - 'a'; // a = 0
-			else
-				return 0; // unexpected character
-			
-			tmp |= ch;
-			bits += 5;
-			if (bits >= 8)
-			{
-				if (ret >= outLen) return ret;
-				outBuf[ret] = tmp >> (bits - 8);
-				bits -= 8;
-				ret++;
-			}
-			tmp <<= 5;
-		}
-		return ret;
-	}
-
-	size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char * outBuf, size_t outLen)
-	{
-		size_t ret = 0, pos = 1;
-		int bits = 8, tmp = inBuf[0];
-		while (ret < outLen && (bits > 0 || pos < len))
-		{ 	
-			if (bits < 5)
-			{
-				if (pos < len)
-				{
-					tmp <<= 8;
-		      		tmp |= inBuf[pos] & 0xFF;
-					pos++;
-		      		bits += 8;
-				}
-				else // last byte
-				{
-					tmp <<= (5 - bits);
-				  	bits = 5;
-				}
-			}	
-		
-			bits -= 5;
-			int ind = (tmp >> bits) & 0x1F;
-			outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2');
-			ret++;
-		}
-		return ret;
-	}
-
-	GzipInflator::GzipInflator (): m_IsDirty (false)
-	{
-		memset (&m_Inflator, 0, sizeof (m_Inflator));
-		inflateInit2 (&m_Inflator, MAX_WBITS + 16); // gzip
-	}
-	
-	GzipInflator::~GzipInflator ()
-	{
-		inflateEnd (&m_Inflator);
-	}	
-
-	size_t GzipInflator::Inflate (const uint8_t * in, size_t inLen, uint8_t * out, size_t outLen)
-	{
-		if (m_IsDirty) inflateReset (&m_Inflator);
-		m_IsDirty = true;
-		m_Inflator.next_in = const_cast<uint8_t *>(in);
-		m_Inflator.avail_in = inLen;
-		m_Inflator.next_out = out;
-		m_Inflator.avail_out = outLen;
-		int err;
-		if ((err = inflate (&m_Inflator, Z_NO_FLUSH)) == Z_STREAM_END)
-			return outLen - m_Inflator.avail_out;	
-		else
-		{
-			LogPrint (eLogError, "Decompression error ", err);
-			return 0;
-		}	
-	}	
-
-	bool GzipInflator::Inflate (const uint8_t * in, size_t inLen, std::ostream& s)
-	{
-		m_IsDirty = true;
-		uint8_t * out = new uint8_t[GZIP_CHUNK_SIZE];
-		m_Inflator.next_in = const_cast<uint8_t *>(in);
-		m_Inflator.avail_in = inLen;	
-		int ret;
-		do
-		{
-			m_Inflator.next_out = out;
-			m_Inflator.avail_out = GZIP_CHUNK_SIZE;
-			ret = inflate (&m_Inflator, Z_NO_FLUSH);
-			if (ret < 0)
-			{
-				LogPrint (eLogError, "Decompression error ", ret);
-				inflateEnd (&m_Inflator);
-				s.setstate(std::ios_base::failbit);
-				break;
-			}	
-			else
-				s.write ((char *)out, GZIP_CHUNK_SIZE - m_Inflator.avail_out);
-		}
-		while (!m_Inflator.avail_out); // more data to read
-		delete[] out;
-		return ret == Z_STREAM_END || ret < 0;
-	}
-
-	void GzipInflator::Inflate (std::istream& in, std::ostream& out)
-	{
-		uint8_t * buf = new uint8_t[GZIP_CHUNK_SIZE];
-		while (!in.eof ())
-		{
-			in.read ((char *)buf, GZIP_CHUNK_SIZE);
-			Inflate (buf, in.gcount (), out); 
-		}	
-		delete[] buf;
-	}
-
-	GzipDeflator::GzipDeflator (): m_IsDirty (false)
-	{
-		memset (&m_Deflator, 0, sizeof (m_Deflator));
-		deflateInit2 (&m_Deflator, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY); // 15 + 16 sets gzip
-	}
-	
-	GzipDeflator::~GzipDeflator ()
-	{
-		deflateEnd (&m_Deflator);
-	}	
-
-	void GzipDeflator::SetCompressionLevel (int level)
-	{
-		deflateParams (&m_Deflator, level, Z_DEFAULT_STRATEGY);
-	}	
-	
-	size_t GzipDeflator::Deflate (const uint8_t * in, size_t inLen, uint8_t * out, size_t outLen)
-	{
-		if (m_IsDirty) deflateReset (&m_Deflator);
-		m_IsDirty = true;
-		m_Deflator.next_in = const_cast<uint8_t *>(in);
-		m_Deflator.avail_in = inLen;
-		m_Deflator.next_out = out;
-		m_Deflator.avail_out = outLen;
-		int err;
-		if ((err = deflate (&m_Deflator, Z_FINISH)) == Z_STREAM_END) 
-			return outLen - m_Deflator.avail_out;	
-		else
-		{
-			LogPrint (eLogError, "Compression error ", err);
-			return 0;
-		}	
-	}
-}
-}
-

Base.h

@@ -1,134 +0,0 @@
-#ifndef BASE_H__
-#define BASE_H__
-
-#include <inttypes.h>
-#include <string.h>
-#include <string>
-#include <zlib.h>
-#include <iostream>
-
-namespace i2p
-{
-namespace data
-{
-	size_t ByteStreamToBase64 (const uint8_t * InBuffer, size_t InCount, char * OutBuffer, size_t len);
-	size_t Base64ToByteStream (const char * InBuffer, size_t InCount, uint8_t * OutBuffer, size_t len );
-	const char * GetBase32SubstitutionTable ();
-	const char * GetBase64SubstitutionTable ();	
-	
-	size_t Base32ToByteStream (const char * inBuf, size_t len, uint8_t * outBuf, size_t outLen);
-	size_t ByteStreamToBase32 (const uint8_t * InBuf, size_t len, char * outBuf, size_t outLen);
-
-  /**
-     Compute the size for a buffer to contain encoded base64 given that the size of the input is input_size bytes
-   */
-  size_t Base64EncodingBufferSize(const size_t input_size);
-  
-	template<int sz>
-	class Tag
-	{
-		public:
-
-			Tag (const uint8_t * buf) { memcpy (m_Buf, buf, sz); };
-			Tag (const Tag<sz>& ) = default;
-#ifndef _WIN32 // FIXME!!! msvs 2013 can't compile it
-			Tag (Tag<sz>&& ) = default;
-#endif
-			Tag () = default;
-			
-			Tag<sz>& operator= (const Tag<sz>& ) = default;
-#ifndef _WIN32
-			Tag<sz>& operator= (Tag<sz>&& ) = default;
-#endif
-			
-			uint8_t * operator()() { return m_Buf; };
-			const uint8_t * operator()() const { return m_Buf; };
-
-			operator uint8_t * () { return m_Buf; };
-			operator const uint8_t * () const { return m_Buf; };
-			
-			const uint64_t * GetLL () const { return ll; };
-
-			bool operator== (const Tag<sz>& other) const { return !memcmp (m_Buf, other.m_Buf, sz); };
-			bool operator< (const Tag<sz>& other) const { return memcmp (m_Buf, other.m_Buf, sz) < 0; };
-
-			bool IsZero () const
-			{
-				for (int i = 0; i < sz/8; i++)
-					if (ll[i]) return false;
-				return true;
-			}
-			
-			std::string ToBase64 () const
-			{
-				char str[sz*2];
-				int l = i2p::data::ByteStreamToBase64 (m_Buf, sz, str, sz*2);
-				str[l] = 0;
-				return std::string (str);
-			}
-
-			std::string ToBase32 () const
-			{
-				char str[sz*2];
-				int l = i2p::data::ByteStreamToBase32 (m_Buf, sz, str, sz*2);
-				str[l] = 0;
-				return std::string (str);
-			}	
-
-			void FromBase32 (const std::string& s)
-			{
-				i2p::data::Base32ToByteStream (s.c_str (), s.length (), m_Buf, sz);
-			}
-
-			void FromBase64 (const std::string& s)
-			{
-				i2p::data::Base64ToByteStream (s.c_str (), s.length (), m_Buf, sz);
-			}
-
-		private:
-
-			union // 8 bytes alignment
-			{	
-				uint8_t m_Buf[sz];
-				uint64_t ll[sz/8];
-			};		
-	};
-
-	const size_t GZIP_CHUNK_SIZE = 16384;
-	class GzipInflator
-	{
-		public:
-
-			GzipInflator ();
-			~GzipInflator ();
-
-			size_t Inflate (const uint8_t * in, size_t inLen, uint8_t * out, size_t outLen);
-			bool Inflate (const uint8_t * in, size_t inLen, std::ostream& s); 
-			// return true when finshed or error, s failbit will be set in case of error
-			void Inflate (std::istream& in, std::ostream& out); 			
-
-		private:
-
-			z_stream m_Inflator;
-			bool m_IsDirty;
-	};
-
-	class GzipDeflator
-	{
-		public:
-
-			GzipDeflator ();
-			~GzipDeflator ();
-
-			void SetCompressionLevel (int level);
-			size_t Deflate (const uint8_t * in, size_t inLen, uint8_t * out, size_t outLen);
-			
-		private:
-
-			z_stream m_Deflator;
-			bool m_IsDirty;
-	};
-}
-}
-
-#endif

ChangeLog

@@ -0,0 +1,665 @@
+# for this file format description,
+# see https://github.com/olivierlacan/keep-a-changelog
+
+## [2.38.0] - 2021-03-17
+### Added
+- Publish ipv6 introducers
+- Bind ipv6 or yggdrasil NTCP2 acceptor to specified address 
+- Support .b32.i2p addresses and hostnames for SAM STREAM CREATE
+- ipv6 peer tests
+- Publish iexp param for introducers
+- Show ipv6 network status on the webconsole
+- EdDSA signing keys can also be blinded
+- Show router version on the webconsole
+### Changed
+- Rekey of all routers but floodfills to ECIES
+- Increased number of precalculated x25519 keys to 15
+- Don't publish LeaseSet without inbound tunnels
+- Reseed from compatible address(ipv4 or ipv6)
+- Recongnize v4 and v6 SSU addresses without host
+- Inbound tunnel gateway must be ipv4 compatible
+- Don't select next introducers from existing sessions
+- Set X bandwidth for floodfill by default
+### Fixed
+- Incoming ECIES-x25519 session doesn't send updated LeaseSet
+- Unique local address for server tunnels
+- Race condition for LeaseSet creation in I2CP
+- Relay tag for ipv6 introducer
+- Already expired introducers
+- Find connected router for first peer in tunnel
+- Failed outgoing ECIES-x25519 session's tagset stays forever
+- Yggdrasil address disappears if router becomes unreachable through ipv6
+- Ignore SSU address/introducers if port is not specified
+- Check identity and signature length for SSU SessionConfirmed
+
+## [2.37.0] - 2021-03-15
+### Added
+- Address registration line for reg.i2p and stats.i2p through the web console
+- "4" and "6" caps for addresses without published IP address
+- Mesh and Proxy network statuses
+- Symmetric NAT network status error
+- Bind server tunnel connection to specified address
+- lookuplocal BOB extended command
+- address4 and address6 parameters to bind outgoing connections to 
+- Rekey of low-bandwidth routers to ECIES
+- Popup notification windows when unable to parse config for Windows
+### Changed
+- Floodfills with "U" cap are not ignored anymore
+- Check transports reachability between tunnel peers and between router and floodfill 
+- NTCP2 and reseed HTTP proxy support authorization now
+- Show actual IP addresses for proxy connections
+- Publish and handle SSU addreses without host
+- Outbound tunnel endpoint must be ipv4 compatible
+- Logging optimization
+- Removed Windows service
+### Fixed
+- Incoming SSU session terminates after 5 seconds
+- Outgoing NTCP2 ipv4 session even if ipv4 is disabled
+- No incoming Yggdrasil connection if connected through NTCP2 proxy
+- Race condition between tunnel build and floodfill requests decryption for ECIES routers
+- Numeric bandwidth limitation
+- Yggdrasil for Android
+
+## [2.36.0] - 2021-02-15
+### Added
+- Encrypted lookup and publications to ECIES-x25519 floodfiils
+- Yggdrasil transports and reseeds
+- Dump addressbook in hosts.txt format
+- Request RouterInfo through exploratory tunnels if direct connection to fllodfill is not possible
+- Threads naming
+- Check if public x25519 key is valid 
+- ECIES-X25519-AEAD-Ratchet for shared local destination
+- LeaseSet creation timeout for I2CP session
+- Resend RouterInfo after some interval for longer NTCP2 sessions
+- Select reachable router of inbound tunnel gateway
+- Reseed if no compatible routers in netdb 
+- Refresh on swipe in Android webconsole
+### Changed
+- reg.i2p for default addressbook instead inr.i2p
+- ECIES-x25519 (crypto type 4) for new routers
+- Try to connect to all compatible addresses from peer's RouterInfo
+- Replace LeaseSet completely if store type changes 
+- Try ECIES-X25519-AEAD-Ratchet tag before ElGamal
+- Don't detach ECIES-X25519-AEAD-Ratchet session from destination immediately
+- Viewport and styles on error in HTTP proxy
+- Don't create notification when Windows taskbar restarted 
+- Cumulative SSU ACK bitfields
+- limit tunnel length to 8 hops
+- Limit tunnels quantity to 16
+### Fixed
+- Handling chunked HTTP response in addressbook
+- Missing ECIES-X25519-AEAD-Ratchet tags for multiple streams with the same destination
+- Correct NAME for NAMING REPLY in SAM
+- SSU crash on termination
+- Offline signature length for stream close packet
+- Don't send updated LeaseSet through a terminated session
+- Decryption of follow-on ECIES-X25519-AEAD-Ratchet NSR messages
+- Non-confirmed LeaseSet is resent too late for ECIES-X25519-AEAD-Ratchet session
+
+## [2.35.0] - 2020-11-30
+### Added
+- ECIES-x25519 routers
+- Random intro keys for SSU
+- Graceful shutdown timer for windows
+- Send queue for I2CP messages
+- Update DSA router keys to EdDSA
+- TCP_QUICKACK for NTCP2 sockets on Linux
+### Changed
+- Exclude floodfills with DSA signatures and < 0.9.28
+- Random intervals between tunnel tests and manage for tunnel pools
+- Don't replace an addressbook record by one with DSA signature
+- Publish RouterInfo after update
+- Create paired inbound tunnels if no inbound tunnels yet
+- Reseed servers list
+### Fixed
+- Transient signature length, if different from identity
+- Terminate I2CP session if destroyed
+- RouterInfo publishing confirmation
+- Check if ECIES-X25519-AEAD-Ratchet session expired before generating more tags 
+- Correct block size for delivery type local for ECIES-X25519-AEAD-Ratchet
+
+## [2.34.0] - 2020-10-27
+### Added
+- Ping responses for streaming
+- STREAM FORWARD for SAM
+- Tunnels through ECIES-x25519 routers
+- Single thread for I2CP
+- Shared transient destination between proxies
+- Database lookups from ECIES destinations with ratchets response
+- Handle WebDAV HTTP methods 
+- Don't try to connect or build tunnels if offline
+- Validate IP when trying connect to remote peer
+- Handle ICMP responses and WinAPI errors for SSU
+### Changed
+- Removed NTCP
+- Dropped gcc 4.7 support
+- Encyption type 0,4 by default for client tunnels
+- Stripped out some HTTP header for HTTP server response
+- HTTP 1.1 addressbook requests
+- Set LeaseSet type to 3 for ratchets if not specified
+- Handle SSU v4 and v6 messages in one thread
+- Eliminate DH keys thread
+### Fixed
+- Random crashes on I2CP session disconnect
+- Stream through racthets hangs if first SYN was not acked
+- Check "Last-Modified" instead "If-Modified-Since" for addressbook reponse
+- Trim behind ECIESx25519 tags 
+- Few bugs with Android main activity
+- QT visual and layout issues
+
+## [2.33.0] - 2020-08-24
+### Added
+- Shared transient addresses
+- crypto.ratchet.inboundTags paramater
+- Multiple encryption keys through I2CP
+- Pre-calculated x25519 ephemeral keys
+- Change datagram routing path if nothing comes back in 10 seconds
+- Shared routing path for datagram session 
+### Changed
+- UDP tunnels send mix of repliable and raw datagrams in bulk
+- Encrypt SSU packet again upon resend
+- Start new tunnel message if remaining buffer is too small 
+- Use LeaseSet2 for ECIES-X25519-AEAD-Ratchet automatically
+- Save new ECIES-X25519-AEAD-Ratchet session with NSR tagset
+- Generate random padding lengths for ECIES-X25519-AEAD-Ratchet in bulk
+- Webconsole layout
+- Reseed servers list
+### Fixed
+- Don't connect through terminated SAM destination
+- Differentiate UDP server sessions by port 
+- ECIES-X25519-AEAD-Ratchet through I2CP
+- Don't save invalid address to AddressBook
+- ECDSA signatures names in SAM
+- AppArmor profile 
+
+## [2.32.1] - 2020-06-02
+### Added
+- Read explicit peers in tunnels config
+### Fixed
+- Generation of tags for detached sessions
+- Non-updating LeaseSet1
+- Start when deprecated websocket options present in i2pd.conf
+
+## [2.32.0] - 2020-05-25
+### Added
+- Multiple encryption types for local destinations
+- Next key and tagset for ECIES-X25519-AEAD-Ratchet
+- NTCP2 through SOCKS proxy
+- Throw error message if any port to bind is occupied
+- gzip parameter for UDP tunnels
+- Show ECIES-X25519-AEAD-Ratchet sessions and tags on the web console
+- Simplified implementation of gzip for no compression mode
+- Allow ECIES-X25519-AEAD-Ratchet session restart after 2 minutes
+- Added logrotate config for rpm package
+### Changed
+- Select peers for client tunnels among routers >= 0.9.36
+- Check ECIES flag for encrypted lookup reply
+- Streaming MTU size 1812 for ECIES-X25519-AEAD-Ratchet
+- Don't calculate checksum for Data message send through ECIES-X25519-AEAD-Ratchet
+- Catch network connectivity status for Windows
+- Stop as soon as no more transit tunnels during graceful shutdown for Android
+- RouterInfo gzip compression level depends on size
+- Send response to received datagram from ECIES-X25519-AEAD-Ratchet session
+- Update webconsole functional
+- Increased max transit tunnels limit
+- Reseeds list
+- Dropped windows support in cmake
+### Fixed
+- Correct timestamp check for LeaseSet2
+- Encrypted leaseset without authentication
+- Change SOCKS proxy connection response for clients without socks5h support (#1336)
+
+## [2.31.0] - 2020-04-10
+### Added
+- NTCP2 through HTTP proxy
+- Publish LeaseSet2 for I2CP destinations
+- Show status page on main activity for android
+- Handle ECIESFlag in DatabaseLookup at floodfill
+- C++17 features for eligible compilers
+### Changed
+- Droped Websockets and Lua support
+- Send DeliveryStatusMsg for LeaseSet for ECIES-X25519-AEAD-Ratchet
+- Keep sending new session reply until established for ECIES-X25519-AEAD-Ratchet
+- Updated SSU log messages
+- Reopen SSU socket on exception
+- Security hardening headers in web console
+- Various web console changes
+- Various QT changes
+### Fixed
+- NTCP2 socket descriptors leak
+- Race condition with router's identity in transport sessions
+- Not terminated streams remain forever
+
+## [2.30.0] - 2020-02-25
+### Added
+- Single threaded SAM
+- Experimental support of ECIES-X25519-AEAD-Ratchet crypto type
+### Changed
+- Minimal MTU size is 1280 for ipv6
+- Use unordered_map instead map for destination's sessions and tags list
+- Use std::shuffle instead std::random_shuffle
+- SAM is single threaded by default
+- Reseeds list
+### Fixed
+- Correct termination of streaming destination
+- Extra ',' in RouterInfo response in I2PControl
+- SAM crash on session termination
+- Storage for Android 10
+
+## [2.29.0] - 2019-10-21
+### Added
+- Client auth flag for b33 address
+### Changed
+- Remove incoming  NTCP2 session from pending list when established
+- Handle errors for NTCP2 SessionConfrimed send
+### Fixed
+- Failure to start on Windows XP
+- SAM crash if invalid lookup address
+- Possible crash when UPnP enabled on shutdown
+
+## [2.28.0] - 2019-08-27
+### Added
+- RAW datagrams in SAM
+- Publishing encrypted LeaseSet2 with DH or PSH authentication
+- Ability to disable battery optimization for Android
+- Transport Network ID Check
+### Changed
+- Set and handle published encrypted flag for LeaseSet2
+### Fixed
+- ReceiveID changes in the same stream
+- "\r\n" command terminator in SAM
+- Addressbook lines with signatures
+
+## [2.27.0] - 2019-07-03
+### Added
+- Support of PSK and DH authentication for encrypted LeaseSet2
+### Changed
+- Uptime is based on monotonic timer
+### Fixed
+- BOB status command response
+- Correct NTCP2 port if NTCP is disabled
+- Flood encrypted LeaseSet2 with store hash
+
+## [2.26.0] - 2019-06-07
+### Added
+- HTTP method "PROPFIND"
+- Detection of external ipv6 address through the SSU
+- NTCP2 publishing depends on network status
+### Changed
+- ntcp is disabled by default, ntcp2 is published by default
+- Response to BOB's "list" command
+- ipv6 address is not longer NTCP's local endpoint's address
+- Reseeds list
+- HTTP_REFERER stripping in httpproxy (#823)
+### Fixed
+- Check and handle incorrect BOB input
+- Ignore introducers for NTCP or NTCP2 addresses
+- RouterInfo check from NTCP2
+
+## [2.25.0] - 2019-05-09
+### Added
+- Create, publish and handle encrypted LeaseSet2
+- Support of b33 addresses
+- RedDSA key blinding
+- .b32.i2p addresses in jump links
+- ntcp2.addressv6 parameter
+### Changed
+- Allow HTTP headers without value
+- Set data directory from external storage path for Android
+- addresshelper support is configurable per tunnel
+- gradlew script for android build
+### Fixed
+- Deletion of expired encrypted LeaseSet2 on floodfills
+- ipv6 fallback address
+- SSU incoming packets routing
+
+## [2.24.0] - 2019-03-21
+### Added
+- Support of transient keys for LeaseSet2
+- Support of encrypted LeaseSet2
+- Recognize signature type 11 (RedDSA)
+- Support websocket connections over HTTP proxy
+- Ability to disable full addressbook persist
+### Changed
+- Don't load peer profiles if non-persistant
+- REUSE_ADDR for ipv6 acceptors
+- Reset eTags if addressbook can't be loaded
+### Fixed
+- Build with boost 1.70
+- Filter out unspecified addresses from RouterInfo
+- Check floodfill status change
+- Correct SAM response for invalid key
+- SAM crash on termination for Windows
+- Race condition for publishing
+
+## [2.23.0] - 2019-01-21
+### Added
+- Standard LeaseSet2 support
+- Ability to adjust timestamps through the NTP
+- Ability to disable peer profile persist
+- Request permission for android >= 6
+- Initial addressbook to android assets
+- Cancel graceful shutdown for android
+- Russian translation for android
+### Changed
+- Chacha20 and Poly1305 implementation
+- Eliminate extra copy of NTCP2 send buffers
+- Extract content of tunnel.d from assets on android
+- Removed name resolvers from transports
+- Update reseed certificates
+### Fixed
+- LeaseSet published content verification
+- Exclude invalid LeaseSets from the list on a floodfill
+- Build for OpenWrt with openssl 1.1.1
+
+## [2.22.0] - 2018-11-09
+### Added
+- Multiple tunnel config files from tunnels.d folder
+### Changed
+- Fetch own RouterInfo upon SessionRequest for NTCP2
+- Faster XOR between AES blocks for non AVX capable CPUs
+### Fixed
+- Fixed NTCP2 termination send
+
+## [2.21.1] - 2018-10-22
+### Changed
+- cost=13 for unpublished NTCP2 address
+### Fixed
+- Handle I2NP messages longer than 32K
+
+## [2.21.0] - 2018-10-04
+### Added
+- EdDSA, x25519 and SipHash from openssl 1.1.1
+- NTCP2 ipv6 incoming connections
+- Show total number of destination's outgoing tags in the web console
+### Changed
+- Android build with openssl 1.1.1/boost 1.64
+- Bandwidth classes 'P' and 'X' don't add 'O' anymore
+### Fixed
+- Update own RouterInfo if no SSU
+- Recognize 'P' and 'X' routers as high bandwidth without 'O'
+- NTCP address doesn't disappear if NTCP2 enabled
+- Android with api 26+
+
+## [2.20.0] - 2018-08-23
+### Added
+- Full implementation of NTCP2
+- Assets for android
+### Changed
+- armeabi-v7a and x86 in one apk for android
+- NTCP2 is enabled by default
+- Show lease's expiration time in readable format in the web console
+### Fixed
+- Correct names for transports in the web console
+
+## [2.19.0] - 2018-06-26
+### Added
+- ECIES support for RouterInfo
+- HTTP outproxy authorization
+- AVX/AESNI runtime detection
+- Initial implementation of NTCP2
+- I2CP session reconfigure
+- I2CP method ClientServicesInfo
+- Datagrams to websocks
+### Changed
+- RouterInfo uses EdDSA signature by default
+- Remove stream bans
+- Android build system changed to gradle
+- Multiple changes in QT GUI
+- Dockerfile
+### Fixed
+- zero tunnelID issue
+- tunnels reload
+- headers in webconsole
+- XSS in webconsole from SAM session name
+- build for gcc 8
+- cmake build scripts
+- systemd service files
+- some netbsd issues
+
+## [2.18.0] - 2018-01-30
+### Added
+- Show tunnel nicknames for I2CP destination in WebUI
+- Re-create HTTP and SOCKS proxy by tunnel reload
+- Graceful shutdown as soon as no more transit tunnels
+### Changed
+- Regenerate shared local destination by tunnel reload
+- Use transient local destination by default if not specified
+- Return correct code if pid file can't be created
+- Timing and number of attempts for adressbook requests
+- Certificates list
+### Fixed
+- Malformed addressbook subsctiption request
+- Build with boost 1.66
+- Few race conditions for SAM
+- Check LeaseSet's signature before update
+
+## [2.17.0] - 2017-12-04
+### Added
+- Reseed through HTTP and SOCKS proxy
+- Show status of client services through web console
+- Change log level through web connsole
+- transient keys for tunnels
+- i2p.streaming.initialAckDelay parameter
+- CRYPTO_TYPE for SAM destination
+- signature and crypto type for newkeys BOB command
+### Changed
+- Correct publication of ECIES destinations
+- Disable RSA signatures completely
+### Fixed
+- CVE-2017-17066
+- Possible buffer overflow for RSA-4096
+- Shutdown from web console for Windows
+- Web console page layout
+## [2.16.0] - 2017-11-13
+### Added
+- https and "Connect" method for HTTP proxy
+- outproxy for HTTP proxy
+- initial support of ECIES crypto
+- NTCP soft and hard descriptors limits
+- Support full timestamps in logs
+### Changed
+- Faster implementation of GOST R 34.11 hash
+- Reject routers with RSA signtures
+- Reload config and shudown from Windows GUI
+- Update tunnels address(destination) without restart
+### Fixed
+- BOB crashes if destination is not set
+- Correct SAM tunnel name
+- QT GUI issues
+
+## [2.15.0] - 2017-08-17
+### Added
+- QT GUI
+- Ability to add and remove I2P tunnels without restart
+- Ability to disable SOCKS outproxy option
+### Changed
+- Strip-out Accept-* hedaers in HTTP proxy
+- Don't run peer test if nat=false
+- Separate output of NTCP and SSU sessions in Transports tab
+### Fixed
+- Handle lines with comments in hosts.txt file for address book
+- Run router with empty netdb for testnet
+- Skip expired introducers by iexp
+
+## [2.14.0] - 2017-06-01
+### Added
+- Transit traffic bandwidth limitation
+- NTCP connections through HTTP and SOCKS proxies
+- Ability to disable address helper for HTTP proxy
+### Changed
+- Reseed servers list
+- Minimal required version is 4.0 for Android
+### Fixed
+- Ignore comments in addressbook feed
+
+## [2.13.0] - 2017-04-06
+### Added
+- Persist local destination's tags
+- GOST signature types 9 and 10
+- Exploratory tunnels configuration
+### Changed
+- Reseed servers list
+- Inactive NTCP sockets get closed faster
+- Some EdDSA speed up
+### Fixed
+- Multiple acceptors for SAM
+- Follow on data after STREAM CREATE for SAM
+- Memory leaks
+
+## [2.12.0] - 2017-02-14
+### Added
+- Additional HTTP and SOCKS proxy tunnels
+- Reseed from ZIP archive
+- Some stats in a main window for Windows version
+### Changed
+- Reseed servers list
+- MTU of 1488 for ipv6
+- Android and Mac OS X versions use OpenSSL 1.1
+- New logo for Android
+### Fixed
+- Multiple memory leaks
+- Incomptibility of some EdDSA private keys with Java
+- Clock skew for Windows XP
+- Occasional crashes with I2PSnark
+
+## [2.11.0] - 2016-12-18
+### Added
+- Websockets support
+- Reseed through a floodfill
+- Tunnel configuration for HTTP and SOCKS proxy
+- Zero-hops tunnels for destinations
+- Multiple acceptors for SAM
+### Changed
+- Reseed servers list
+- DHT uses AVX if applicable
+- New logo
+- LeaseSet lookups
+### Fixed
+- HTTP Proxy connection reset for Windows
+- Crash upon SAM session termination
+- Can't connect to a destination for a longer time after restart
+- Mass packet loss for UDP tunnels
+
+## [2.10.2] - 2016-12-04
+### Fixed
+- Fixes UPnP discovery bug, producing excessive CPU usage
+- Fixes sudden SSU thread stop for Windows.
+
+## [2.10.1] - 2016-11-07
+### Fixed
+- Fixed some performance issues for Windows and Android
+
+## [2.10.0] - 2016-10-17
+### Added
+- Datagram i2p tunnels
+- Unique local addresses for server tunnels
+- Configurable list of reseed servers  and initial addressbook
+- Configurable netid
+- Initial iOS support
+
+### Changed
+- Reduced file descriptors usage
+- Strict reseed checks enabled by default
+
+## Fixed
+- Multiple fixes in I2CP and BOB implementations
+
+## [2.9.0] - 2016-08-12
+### Changed
+- Proxy refactoring & speedup
+- Transmission-I2P support
+- Graceful shutdown for Windows
+- Android without QT
+- Reduced number of timers in SSU
+- ipv6 peer test support
+- Reseed from SU3 file
+
+## [2.8.0] - 2016-06-20
+### Added
+- Basic Android support
+- I2CP implementation
+- 'doxygen' target
+
+### Changed
+- I2PControl refactoring & fixes (proper jsonrpc responses on errors)
+- boost::regex no more needed
+
+### Fixed
+- initscripts: added openrc one, in sysv-ish make I2PD_PORT optional
+- properly close NTCP sessions (memleak)
+
+## [2.7.0] - 2016-05-18
+### Added
+- Precomputed El-Gamal/DH tables
+- Configurable limit of transit tunnels
+
+### Changed
+- Speed-up of asymmetric crypto for non-x64 platforms
+- Refactoring of web-console
+
+## [2.6.0] - 2016-03-31
+### Added
+- Graceful shutdown on SIGINT
+- Numeric bandwidth limits (was: by router class)
+- Jumpservices in web-console
+- Logging to syslog
+- Tray icon for windows application
+
+### Changed
+- Logs refactoring
+- Improved statistics in web-console
+
+### Deprecated:
+- Renamed main/tunnels config files (will use old, if found, but emits warning)
+
+## [2.5.1] - 2016-03-10
+### Fixed
+- Doesn't create ~/.i2pd dir if missing
+
+## [2.5.0] - 2016-03-04
+### Added
+- IRC server tunnels
+- SOCKS outproxy support
+- Support for gzipped addressbook updates
+- Support for router families
+
+### Changed
+- Shared RTT/RTO between streams
+- Filesystem work refactoring
+
+## [2.4.0] - 2016-02-03
+### Added
+- X-I2P-* headers for server http-tunnels
+- I2CP options for I2P tunnels
+- Show I2P tunnels in webconsole
+
+### Changed
+- Refactoring of cmdline/config parsing
+
+## [2.3.0] - 2016-01-12
+### Added
+- Support for new router bandwidth class codes (P and X)
+- I2PControl supports external webui
+- Added --pidfile and --notransit parameters
+- Ability to specify signature type for i2p tunnel
+
+### Changed
+- Fixed multiple floodfill-related bugs
+- New webconsole layout
+
+## [2.2.0] - 2015-12-22
+### Added
+- Ability to connect to router without ip via introducer
+
+### Changed
+- Persist temporary encryption keys for local destinations
+- Performance improvements for EdDSA
+- New addressbook structure
+
+## [2.1.0] - 2015-11-12
+### Added
+- Implementation of EdDSA
+
+### Changed
+- EdDSA is default signature type for new RouterInfos

ClientContext.cpp

@@ -1,380 +0,0 @@
-#include <fstream>
-#include <iostream>
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/ini_parser.hpp>
-#include "Config.h"
-#include "FS.h"
-#include "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)
-	{
-	}
-	
-	ClientContext::~ClientContext () 
-	{
-		delete m_HttpProxy;
-		delete m_SocksProxy;
-		delete m_SamBridge;
-		delete m_BOBCommandChannel;
-	}
-	
-	void ClientContext::Start ()
-	{
-		if (!m_SharedLocalDestination)
-		{	
-			m_SharedLocalDestination = CreateNewLocalDestination (); // non-public, DSA
-			m_Destinations[m_SharedLocalDestination->GetIdentity ()->GetIdentHash ()] = m_SharedLocalDestination;
-			m_SharedLocalDestination->Start ();
-		}
-
-		m_AddressBook.Start ();	
-		
-		std::shared_ptr<ClientDestination> localDestination;	
-		bool httproxy; i2p::config::GetOption("httpproxy.enabled", httproxy);
-		if (httproxy) {
-			std::string httpProxyKeys; i2p::config::GetOption("httpproxy.keys",    httpProxyKeys);
-			std::string httpProxyAddr; i2p::config::GetOption("httpproxy.address", httpProxyAddr);
-			uint16_t    httpProxyPort; i2p::config::GetOption("httpproxy.port",    httpProxyPort);
-			LogPrint(eLogInfo, "Clients: starting HTTP Proxy at ", httpProxyAddr, ":", httpProxyPort);
-			if (httpProxyKeys.length () > 0)
-			{
-				i2p::data::PrivateKeys keys;
-				LoadPrivateKeys (keys, httpProxyKeys);
-				localDestination = CreateNewLocalDestination (keys, false);
-			}
-			m_HttpProxy = new i2p::proxy::HTTPProxy(httpProxyAddr, httpProxyPort, localDestination);
-			m_HttpProxy->Start();
-		}
-
-		bool socksproxy; i2p::config::GetOption("socksproxy.enabled", socksproxy);
-		if (socksproxy) {
-			std::string socksProxyKeys; i2p::config::GetOption("socksproxy.keys",    socksProxyKeys);
-			std::string socksProxyAddr; i2p::config::GetOption("socksproxy.address", socksProxyAddr);
-			uint16_t    socksProxyPort; i2p::config::GetOption("socksproxy.port",    socksProxyPort);
-			std::string socksOutProxyAddr; i2p::config::GetOption("socksproxy.outproxy",     socksOutProxyAddr);
-			uint16_t    socksOutProxyPort; i2p::config::GetOption("socksproxy.outproxyport", socksOutProxyPort);
-			LogPrint(eLogInfo, "Clients: starting SOCKS Proxy at ", socksProxyAddr, ":", socksProxyPort);
-			if (socksProxyKeys.length () > 0)
-			{
-				i2p::data::PrivateKeys keys;
-				LoadPrivateKeys (keys, socksProxyKeys);
-				localDestination = CreateNewLocalDestination (keys, false);
-			}
-			m_SocksProxy = new i2p::proxy::SOCKSProxy(socksProxyAddr, socksProxyPort, socksOutProxyAddr, socksOutProxyPort, localDestination);
-			m_SocksProxy->Start();
-		}
-	
-		// I2P tunnels
-		ReadTunnels ();
-
-		// SAM
-		bool sam; i2p::config::GetOption("sam.enabled", sam);
-		if (sam) {
-			std::string samAddr; i2p::config::GetOption("sam.address", samAddr);
-			uint16_t    samPort; i2p::config::GetOption("sam.port",    samPort);
-			LogPrint(eLogInfo, "Clients: starting SAM bridge at ", samAddr, ":", samPort);
-			m_SamBridge = new SAMBridge (samAddr, samPort);
-			m_SamBridge->Start ();
-		} 
-
-		// BOB
-		bool bob; i2p::config::GetOption("bob.enabled", bob);
-		if (bob) {
-			std::string bobAddr; i2p::config::GetOption("bob.address", bobAddr);
-			uint16_t    bobPort; i2p::config::GetOption("bob.port",    bobPort);
-			LogPrint(eLogInfo, "Clients: starting BOB command channel at ", bobAddr, ":", bobPort);
-			m_BOBCommandChannel = new BOBCommandChannel (bobAddr, bobPort);
-			m_BOBCommandChannel->Start ();
-		} 
-	}
-		
-	void ClientContext::Stop ()
-	{
-		if (m_HttpProxy)
-		{
-			LogPrint(eLogInfo, "Clients: stopping HTTP Proxy");
-			m_HttpProxy->Stop();
-			delete m_HttpProxy;
-			m_HttpProxy = nullptr;
-		}
-
-		if (m_SocksProxy)
-		{
-			LogPrint(eLogInfo, "Clients: stopping SOCKS Proxy");
-			m_SocksProxy->Stop();
-			delete m_SocksProxy;
-			m_SocksProxy = nullptr;
-		}
-
-		for (auto& it: m_ClientTunnels)
-		{
-			LogPrint(eLogInfo, "Clients: stopping I2P client tunnel on port ", it.first);
-			it.second->Stop ();
-		}
-		m_ClientTunnels.clear ();	
-
-		for (auto& it: m_ServerTunnels)
-		{
-			LogPrint(eLogInfo, "Clients: stopping I2P server tunnel");
-			it.second->Stop ();
-		}
-		m_ServerTunnels.clear ();	
-
-		if (m_SamBridge)
-		{
-			LogPrint(eLogInfo, "Clients: stopping SAM bridge");
-			m_SamBridge->Stop ();
-			delete m_SamBridge; 
-			m_SamBridge = nullptr;
-		}		
-
-		if (m_BOBCommandChannel)
-		{
-			LogPrint(eLogInfo, "Clients: stopping BOB command channel");
-			m_BOBCommandChannel->Stop ();
-			delete m_BOBCommandChannel; 
-			m_BOBCommandChannel = nullptr;
-		}
-
-		LogPrint(eLogInfo, "Clients: stopping AddressBook");
-		m_AddressBook.Stop ();		
-		for (auto it: m_Destinations)
-			it.second->Stop ();
-		m_Destinations.clear ();
-		m_SharedLocalDestination = nullptr; 
-	}	
-	
-	void ClientContext::LoadPrivateKeys (i2p::data::PrivateKeys& keys, const std::string& filename, i2p::data::SigningKeyType sigType)
-	{
-		std::string fullPath = i2p::fs::DataDirPath (filename);
-		std::ifstream s(fullPath, 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 (eLogInfo, "Clients: Local address ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " loaded");
-		}	
-		else
-		{
-			LogPrint (eLogError, "Clients: can't open file ", fullPath, " Creating new one with signature type ", sigType);
-			keys = i2p::data::PrivateKeys::CreateRandomKeys (sigType); 
-			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 (eLogInfo, "Clients: New private keys file ", fullPath, " for ", m_AddressBook.ToAddress(keys.GetPublic ()->GetIdentHash ()), " created");
-		}	
-	}
-
-	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 (eLogWarning, "Clients: 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;
-	}	
-
-	template<typename Section, typename Type>
-	std::string ClientContext::GetI2CPOption (const Section& section, const std::string& name, const Type& value) const
-	{
-		return section.second.get (boost::property_tree::ptree::path_type (name, '/'), std::to_string (value));
-	}	
-
-	template<typename Section>
-	void ClientContext::ReadI2CPOptions (const Section& section, std::map<std::string, std::string>& options) const
-	{
-		options[I2CP_PARAM_INBOUND_TUNNEL_LENGTH] = GetI2CPOption (section, I2CP_PARAM_INBOUND_TUNNEL_LENGTH,  DEFAULT_INBOUND_TUNNEL_LENGTH);
-		options[I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH] = GetI2CPOption (section, I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH, DEFAULT_OUTBOUND_TUNNEL_LENGTH);
-		options[I2CP_PARAM_INBOUND_TUNNELS_QUANTITY] = GetI2CPOption (section, I2CP_PARAM_INBOUND_TUNNELS_QUANTITY, DEFAULT_INBOUND_TUNNELS_QUANTITY);
-		options[I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY] = GetI2CPOption (section, I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY, DEFAULT_OUTBOUND_TUNNELS_QUANTITY);
-		options[I2CP_PARAM_TAGS_TO_SEND] = GetI2CPOption (section, I2CP_PARAM_TAGS_TO_SEND, DEFAULT_TAGS_TO_SEND);
-	}	
-
-	void ClientContext::ReadTunnels ()
-	{
-		boost::property_tree::ptree pt;
-		std::string tunConf; i2p::config::GetOption("tunconf", tunConf);
-		if (tunConf == "")
-			tunConf = i2p::fs::DataDirPath ("tunnels.cfg");
-		LogPrint(eLogDebug, "FS: tunnels config file: ", tunConf);
-		try 
-		{
-			boost::property_tree::read_ini (tunConf, pt);
-		} 
-		catch (std::exception& ex) 
-		{
-			LogPrint (eLogWarning, "Clients: Can't read ", tunConf, ": ", 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 keys = section.second.get (I2P_CLIENT_TUNNEL_KEYS, "");
-					std::string address = section.second.get (I2P_CLIENT_TUNNEL_ADDRESS, "127.0.0.1");
-					int destinationPort = section.second.get (I2P_CLIENT_TUNNEL_DESTINATION_PORT, 0);
-					i2p::data::SigningKeyType sigType = section.second.get (I2P_CLIENT_TUNNEL_SIGNATURE_TYPE, i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
-					// I2CP
-					std::map<std::string, std::string> options;			
-					ReadI2CPOptions (section, options);	
-
-					std::shared_ptr<ClientDestination> localDestination = nullptr;
-					if (keys.length () > 0)
-					{
-						i2p::data::PrivateKeys k;
-						LoadPrivateKeys (k, keys, sigType);
-						localDestination = FindLocalDestination (k.GetPublic ()->GetIdentHash ());
-						if (!localDestination)
-							localDestination = CreateNewLocalDestination (k, false, &options);
-					}
-					auto clientTunnel = new I2PClientTunnel (name, dest, address, port, localDestination, destinationPort);
-					if (m_ClientTunnels.insert (std::make_pair (port, std::unique_ptr<I2PClientTunnel>(clientTunnel))).second)
-						clientTunnel->Start ();
-					else
-						LogPrint (eLogError, "Clients: I2P client tunnel with port ", port, " already exists");
-					numClientTunnels++;
-				}
-				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP || type == I2P_TUNNELS_SECTION_TYPE_IRC)
-				{	
-					// 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, "");
-					std::string hostOverride = section.second.get (I2P_SERVER_TUNNEL_HOST_OVERRIDE, "");
-					std::string webircpass = section.second.get<std::string> (I2P_SERVER_TUNNEL_WEBIRC_PASSWORD, "");
-					bool gzip = section.second.get (I2P_SERVER_TUNNEL_GZIP, true);
-					i2p::data::SigningKeyType sigType = section.second.get (I2P_SERVER_TUNNEL_SIGNATURE_TYPE, i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
-					// I2CP
-					std::map<std::string, std::string> options;							 
-					ReadI2CPOptions (section, options);				
-
-					std::shared_ptr<ClientDestination> localDestination = nullptr;
-					i2p::data::PrivateKeys k;
-					LoadPrivateKeys (k, keys, sigType);
-					localDestination = FindLocalDestination (k.GetPublic ()->GetIdentHash ());
-					if (!localDestination)		
-						localDestination = CreateNewLocalDestination (k, true, &options);
-
-					I2PServerTunnel * serverTunnel;
-					if (type == I2P_TUNNELS_SECTION_TYPE_HTTP)
-                    	serverTunnel = new I2PServerTunnelHTTP (name, host, port, localDestination, hostOverride, inPort, gzip);
-               		else if (type == I2P_TUNNELS_SECTION_TYPE_IRC)
-                    	serverTunnel = new I2PServerTunnelIRC (name, host, port, localDestination, webircpass, inPort, gzip);
-					else // regular server tunnel by default
-                   		serverTunnel = new I2PServerTunnel (name, host, port, localDestination, inPort, gzip);
-
-					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 (
-							std::make_tuple (localDestination->GetIdentHash (), inPort), 
-					        std::unique_ptr<I2PServerTunnel>(serverTunnel))).second)
-						serverTunnel->Start ();
-					else
-						LogPrint (eLogError, "Clients: I2P server tunnel for destination ",   m_AddressBook.ToAddress(localDestination->GetIdentHash ()), " already exists");
-					numServerTunnels++;
-				}
-				else
-					LogPrint (eLogWarning, "Clients: Unknown section type=", type, " of ", name, " in ", tunConf);
-				
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Clients: Can't read tunnel ", name, " params: ", ex.what ());
-			}
-		}	
-		LogPrint (eLogInfo, "Clients: ", numClientTunnels, " I2P client tunnels created");
-		LogPrint (eLogInfo, "Clients: ", numServerTunnels, " I2P server tunnels created");
-	}	
-}		
-}	

ClientContext.h

@@ -1,97 +0,0 @@
-#ifndef CLIENT_CONTEXT_H__
-#define CLIENT_CONTEXT_H__
-
-#include <map>
-#include <tuple>
-#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"
-
-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_TUNNELS_SECTION_TYPE_IRC[] = "irc";
-	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_SIGNATURE_TYPE[] = "signaturetype";
-	const char I2P_CLIENT_TUNNEL_DESTINATION_PORT[] = "destinationport";	
-	const char I2P_SERVER_TUNNEL_HOST[] = "host";	
-	const char I2P_SERVER_TUNNEL_HOST_OVERRIDE[] = "hostoverride";	
-	const char I2P_SERVER_TUNNEL_PORT[] = "port";
-	const char I2P_SERVER_TUNNEL_KEYS[] = "keys";
-	const char I2P_SERVER_TUNNEL_SIGNATURE_TYPE[] = "signaturetype";
-	const char I2P_SERVER_TUNNEL_INPORT[] = "inport";
-	const char I2P_SERVER_TUNNEL_ACCESS_LIST[] = "accesslist";		
-	const char I2P_SERVER_TUNNEL_GZIP[] = "gzip";
-	const char I2P_SERVER_TUNNEL_WEBIRC_PASSWORD[] = "webircpassword";
-
-	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;		
-			void LoadPrivateKeys (i2p::data::PrivateKeys& keys, const std::string& filename, i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
-
-			AddressBook& GetAddressBook () { return m_AddressBook; };
-			const SAMBridge * GetSAMBridge () const { return m_SamBridge; };
-		
-		private:
-
-			void ReadTunnels ();
-			template<typename Section, typename Type>
-			std::string GetI2CPOption (const Section& section, const std::string& name, const Type& value) const;
-			template<typename Section>
-			void ReadI2CPOptions (const Section& section, std::map<std::string, std::string>& options) const;	
-
-		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<std::tuple<i2p::data::IdentHash, int>, std::unique_ptr<I2PServerTunnel> > m_ServerTunnels; // <destination,port>->tunnel
-			SAMBridge * m_SamBridge;
-			BOBCommandChannel * m_BOBCommandChannel;
-
-		public:
-			// for HTTP
-			const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
-			const decltype(m_ClientTunnels)& GetClientTunnels () const { return m_ClientTunnels; };
-			const decltype(m_ServerTunnels)& GetServerTunnels () const { return m_ServerTunnels; };
-	};
-	
-	extern ClientContext context;	
-}		
-}	
-
-#endif

Config.cpp

@@ -1,244 +0,0 @@
-/*
-* Copyright (c) 2013-2016, 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 <cstdlib>
-#include <iostream>
-#include <fstream>
-#include <map>
-#include <string>
-#include <boost/program_options/cmdline.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/parsers.hpp>
-#include <boost/program_options/variables_map.hpp>
-
-#include "Config.h"
-#include "version.h"
-
-using namespace boost::program_options;
-
-namespace i2p {
-namespace config {
-  options_description m_OptionsDesc;
-  variables_map       m_Options;
-
-  /* list of renamed options */
-  std::map<std::string, std::string> remapped_options = {
-    { "tunnelscfg",          "tunconf" },
-    { "v6",                  "ipv6" },
-    { "httpaddress",         "http.address" },
-    { "httpport",            "http.port"    },
-    { "httpproxyaddress",    "httpproxy.address"  },
-    { "httpproxyport",       "httpproxy.port"     },
-    { "socksproxyaddress",   "socksproxy.address" },
-    { "socksproxyport",      "socksproxy.port"    },
-    { "samaddress",          "sam.address" },
-    { "samport",             "sam.port"    },
-    { "bobaddress",          "bob.address" },
-    { "bobport",             "bob.port"    },
-    { "i2pcontroladdress",   "i2pcontrol.address" },
-    { "i2pcontroladdress",   "i2pcontrol.port"    },
-    { "proxykeys",           "httpproxy.keys" },
-  };
-  /* list of options, that loose their argument and become simple switch */
-  std::set<std::string> boolean_options = {
-    "daemon", "floodfill", "notransit", "service", "ipv6"
-  };
-
-  /* this function is a solid piece of shit, remove it after 2.6.0 */
-  std::pair<std::string, std::string> old_syntax_parser(const std::string& s) {
-    std::string name  = "";
-    std::string value = "";
-    std::size_t pos = 0;
-    /* shortcuts -- -h */
-    if (s.length() == 2 && s.at(0) == '-' && s.at(1) != '-')
-      return make_pair(s.substr(1), "");
-    /* old-style -- -log, /log, etc */
-    if (s.at(0) == '/' || (s.at(0) == '-' && s.at(1) != '-')) {
-      if ((pos = s.find_first_of("= ")) != std::string::npos) {
-        name  = s.substr(1, pos - 1);
-        value = s.substr(pos + 1);
-      } else {
-        name  = s.substr(1, pos);
-        value = "";
-      }
-      if (boolean_options.count(name) > 0 && value != "")
-        std::cerr << "args: don't give an argument to switch option: " << s << std::endl;
-      if (m_OptionsDesc.find_nothrow(name, false)) {
-        std::cerr << "args: option " << s << " style is DEPRECATED, use --" << name << " instead" << std::endl;
-        return std::make_pair(name, value);
-      }
-      if (remapped_options.count(name) > 0) {
-        name = remapped_options[name];
-        std::cerr << "args: option " << s << " is DEPRECATED, use --" << name << " instead" << std::endl;
-        return std::make_pair(name, value);
-      } /* else */
-    }
-    /* long options -- --help */
-    if (s.substr(0, 2) == "--") {
-      if ((pos = s.find_first_of("= ")) != std::string::npos) {
-        name  = s.substr(2, pos - 2);
-        value = s.substr(pos + 1);
-      } else {
-        name  = s.substr(2, pos);
-        value = "";
-      }
-      if (boolean_options.count(name) > 0 && value != "") {
-        std::cerr << "args: don't give an argument to switch option: " << s << std::endl;
-        value = "";
-      }
-      if (m_OptionsDesc.find_nothrow(name, false))
-        return std::make_pair(name, value);
-      if (remapped_options.count(name) > 0) {
-        name = remapped_options[name];
-        std::cerr << "args: option " << s << " is DEPRECATED, use --" << name << " instead" << std::endl;
-        return std::make_pair(name, value);
-      } /* else */
-    }
-    std::cerr << "args: unknown option -- " << s << std::endl;
-    return std::make_pair("", "");
-  }
-
-  void Init() {
-    options_description general("General options");
-    general.add_options()
-      ("help",     "Show this message")
-      ("conf",      value<std::string>()->default_value(""),     "Path to main i2pd config file (default: try ~/.i2pd/i2p.conf or /var/lib/i2pd/i2p.conf)")
-      ("tunconf",   value<std::string>()->default_value(""),     "Path to config with tunnels list and options (default: try ~/.i2pd/tunnels.cfg or /var/lib/i2pd/tunnels.cfg)")
-      ("pidfile",   value<std::string>()->default_value(""),     "Path to pidfile (default: ~/i2pd/i2pd.pid or /var/lib/i2pd/i2pd.pid)")
-      ("log",       value<std::string>()->default_value(""),     "Logs destination: stdout, file (stdout if not set, file - otherwise, for compatibility)")
-      ("logfile",   value<std::string>()->default_value(""),     "Path to logfile (stdout if not set, autodetect if daemon)")
-      ("loglevel",  value<std::string>()->default_value("info"), "Set the minimal level of log messages (debug, info, warn, error)")
-	  ("family",    value<std::string>()->default_value(""),     "Specify a family, router belongs to")
-	  ("datadir",   value<std::string>()->default_value(""),     "Path to storage of i2pd data (RI, keys, peer profiles, ...)")
-      ("host",      value<std::string>()->default_value("0.0.0.0"),     "External IP")
-      ("port",      value<uint16_t>()->default_value(0),                "Port to listen for incoming connections (default: auto)")
-      ("ipv6",      value<bool>()->zero_tokens()->default_value(false), "Enable communication through ipv6")
-      ("daemon",    value<bool>()->zero_tokens()->default_value(false), "Router will go to background after start")
-      ("service",   value<bool>()->zero_tokens()->default_value(false), "Router will use system folders like '/var/lib/i2pd'")
-      ("notransit", value<bool>()->zero_tokens()->default_value(false), "Router will not accept transit tunnels at startup")
-      ("floodfill", value<bool>()->zero_tokens()->default_value(false), "Router will be floodfill")
-      ("bandwidth", value<char>()->default_value('-'), "Bandwidth limiting: L - 32kbps, O - 256Kbps, P - unlimited")
-#ifdef _WIN32
-      ("svcctl",    value<std::string>()->default_value(""),     "Windows service management ('install' or 'remove')")
-#endif
-      ;
-
-    options_description httpserver("HTTP Server options");
-    httpserver.add_options()
-      ("http.enabled",        value<bool>()->default_value(true),               "Enable or disable webconsole")
-      ("http.address",        value<std::string>()->default_value("127.0.0.1"), "Webconsole listen address")
-      ("http.port",           value<uint16_t>()->default_value(7070),           "Webconsole listen port")
-      ;
-
-    options_description httpproxy("HTTP Proxy options");
-    httpproxy.add_options()
-      ("httpproxy.enabled",   value<bool>()->default_value(true),                         "Enable or disable HTTP Proxy")
-      ("httpproxy.address",   value<std::string>()->default_value("127.0.0.1"),           "HTTP Proxy listen address")
-      ("httpproxy.port",      value<uint16_t>()->default_value(4444),                     "HTTP Proxy listen port")
-      ("httpproxy.keys",      value<std::string>()->default_value(""),  "File to persist HTTP Proxy keys")
-      ;
-
-    options_description socksproxy("SOCKS Proxy options");
-    socksproxy.add_options()
-      ("socksproxy.enabled",  value<bool>()->default_value(true),                         "Enable or disable SOCKS Proxy")
-      ("socksproxy.address",  value<std::string>()->default_value("127.0.0.1"),           "SOCKS Proxy listen address")
-      ("socksproxy.port",     value<uint16_t>()->default_value(4447),                     "SOCKS Proxy listen port")
-      ("socksproxy.keys",     value<std::string>()->default_value(""), "File to persist SOCKS Proxy keys")
-      ("socksproxy.outproxy", value<std::string>()->default_value("127.0.0.1"), "Upstream outproxy address for SOCKS Proxy")
-      ("socksproxy.outproxyport", value<uint16_t>()->default_value(9050), "Upstream outproxy port for SOCKS Proxy")
-      ;
-
-    options_description sam("SAM bridge options");
-    sam.add_options()
-      ("sam.enabled",         value<bool>()->default_value(false),                        "Enable or disable SAM Application bridge")
-      ("sam.address",         value<std::string>()->default_value("127.0.0.1"),           "SAM listen address")
-      ("sam.port",            value<uint16_t>()->default_value(7656),                     "SAM listen port")
-      ;
-
-    options_description bob("BOB options");
-    bob.add_options()
-      ("bob.enabled",         value<bool>()->default_value(false),                        "Enable or disable BOB command channel")
-      ("bob.address",         value<std::string>()->default_value("127.0.0.1"),           "BOB listen address")
-      ("bob.port",            value<uint16_t>()->default_value(2827),                     "BOB listen port")
-      ;
-
-    options_description i2pcontrol("I2PControl options");
-    i2pcontrol.add_options()
-      ("i2pcontrol.enabled",  value<bool>()->default_value(false),                        "Enable or disable I2P Control Protocol")
-      ("i2pcontrol.address",  value<std::string>()->default_value("127.0.0.1"),           "I2PCP listen address")
-      ("i2pcontrol.port",     value<uint16_t>()->default_value(7650),                     "I2PCP listen port")
-      ("i2pcontrol.password", value<std::string>()->default_value("itoopie"),             "I2PCP access password")
-      ("i2pcontrol.cert",     value<std::string>()->default_value("i2pcontrol.crt.pem"),  "I2PCP connection cerificate")
-      ("i2pcontrol.key",      value<std::string>()->default_value("i2pcontrol.key.pem"),  "I2PCP connection cerificate key")
-      ;
-
-    m_OptionsDesc
-      .add(general)
-      .add(httpserver)
-      .add(httpproxy)
-      .add(socksproxy)
-      .add(sam)
-      .add(bob)
-      .add(i2pcontrol)
-      ;
-  }
-
-  void ParseCmdline(int argc, char* argv[]) {
-    try {
-      auto style = boost::program_options::command_line_style::unix_style
-                 | boost::program_options::command_line_style::allow_long_disguise;
-      style &=   ~ boost::program_options::command_line_style::allow_guessing;
-      store(parse_command_line(argc, argv, m_OptionsDesc, style, old_syntax_parser), m_Options);
-    } catch (boost::program_options::error& e) {
-      std::cerr << "args: " << e.what() << std::endl;
-      exit(EXIT_FAILURE);
-    }
-
-    if (m_Options.count("help") || m_Options.count("h")) {
-      std::cout << "i2pd version " << I2PD_VERSION << " (" << I2P_VERSION << ")" << std::endl;
-      std::cout << m_OptionsDesc;
-      exit(EXIT_SUCCESS);
-    }
-  }
-
-  void ParseConfig(const std::string& path) {
-    if (path == "") return;
-
-    std::ifstream config(path, std::ios::in);
-
-    if (!config.is_open()) 
-	{
-      std::cerr << "missing/unreadable config file: " << path << std::endl;
-      exit(EXIT_FAILURE);
-    }
-
-    try 
-	{
-		store(boost::program_options::parse_config_file(config, m_OptionsDesc), m_Options);
-    } 
-	catch (boost::program_options::error& e) 
-	{
-      std::cerr << e.what() << std::endl;
-      exit(EXIT_FAILURE);
-    };
-  }
-
-  void Finalize() {
-    notify(m_Options);
-  }
-
-  bool IsDefault(const char *name) {
-    if (!m_Options.count(name))
-      throw "try to check non-existent option";
-
-    if (m_Options[name].defaulted())
-      return true;
-    return false;
-  }
-} // namespace config
-} // namespace i2p

Config.h

@@ -1,107 +0,0 @@
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include <string>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/variables_map.hpp>
-
-/**
- * Functions to parse and store i2pd parameters
- *
- * General usage flow:
- *   Init() -- early as possible
- *   ParseCmdline() -- somewhere close to main()
- *   ParseConfig()  -- after detecting path to config
- *   Finalize()     -- right after all Parse*() functions called
- *   GetOption()    -- may be called after Finalize()
- */
-
-namespace i2p {
-namespace config {
-  extern boost::program_options::variables_map m_Options;
-
-  /**
-   * @brief  Initialize list of acceptable parameters
-   *
-   * Should be called before any Parse* functions.
-   */
-  void Init();
-
-  /**
-   * @brief  Parse cmdline parameters, and show help if requested
-   * @param  argc  Cmdline arguments count, should be passed from main().
-   * @param  argv  Cmdline parameters array, should be passed from main() 
-   *
-   * If --help is given in parameters, shows it's list with description
-   * terminates the program with exitcode 0.
-   *
-   * In case of parameter misuse boost throws an exception.
-   * We internally handle type boost::program_options::unknown_option,
-   * and then terminate program with exitcode 1.
-   *
-   * Other exceptions will be passed to higher level.
-   */
-  void ParseCmdline(int argc, char* argv[]);
-
-  /**
-   * @brief  Load and parse given config file
-   * @param  path  Path to config file
-   *
-   * If error occured when opening file path is points to,
-   * we show the error message and terminate program.
-   *
-   * In case of parameter misuse boost throws an exception.
-   * We internally handle type boost::program_options::unknown_option,
-   * and then terminate program with exitcode 1.
-   *
-   * Other exceptions will be passed to higher level.
-   */
-  void ParseConfig(const std::string& path);
-
-  /**
-   * @brief  Used to combine options from cmdline, config and default values
-   */
-  void Finalize();
-
-  /* @brief  Accessor to parameters by name
-   * @param  name  Name of the requested parameter
-   * @param  value Variable where to store option
-   * @return this function returns false if parameter not found
-   *
-   * @example  uint16_t port; GetOption("sam.port", port);
-   */
-  template<typename T>
-  bool GetOption(const char *name, T& value) {
-    if (!m_Options.count(name))
-      return false;
-    value = m_Options[name].as<T>();
-    return true;
-  }
-
-  /**
-   * @brief  Set value of given parameter
-   * @param  name  Name of settable parameter
-   * @param  value New parameter value
-   * @return true if value set up successful, false otherwise
-   *
-   * @example uint16_t port = 2827; SetOption("bob.port", port);
-   */
-  template<typename T>
-  bool SetOption(const char *name, const T& value) {
-    if (!m_Options.count(name))
-      return false;
-    m_Options[name] = value;
-    notify(m_Options);
-    return true;
-  }
-
-  /**
-   * @brief  Check is value explicitly given or default
-   * @param  name  Name of checked parameter
-   * @return true if value set to default, false othervise
-   */
-  bool IsDefault(const char *name);
-}
-}
-
-#endif // CONFIG_H

Crypto.cpp

@@ -1,714 +0,0 @@
-#include <string.h>
-#include <string>
-#include <vector>
-#include <mutex>
-#include <memory>
-#include <openssl/sha.h>
-#include <openssl/dh.h>
-#include <openssl/md5.h>
-#include <openssl/rand.h>
-#include <openssl/crypto.h>
-#include "TunnelBase.h"
-#include <openssl/ssl.h>
-#include "Log.h"
-#include "Crypto.h"
-
-namespace i2p
-{
-namespace crypto
-{	
-	const uint8_t elgp_[256]=
-	{
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34, 
-		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 
-		0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-		0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
-		0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45, 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
- 		0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-		0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
-		0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D, 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 
-		0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
-		0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
-		0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D, 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 
-		0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
-		0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F,
-		0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9, 0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18,
-		0x39, 0x95, 0x49, 0x7C, 0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
-		0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAC, 0xAA, 0x68, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-	};
-
-	const int elgg_ = 2;
-	
-	const uint8_t dsap_[128]=
-	{
-		0x9c, 0x05, 0xb2, 0xaa, 0x96, 0x0d, 0x9b, 0x97, 0xb8, 0x93, 0x19, 0x63, 0xc9, 0xcc, 0x9e, 0x8c,
-		0x30, 0x26, 0xe9, 0xb8, 0xed, 0x92, 0xfa, 0xd0, 0xa6, 0x9c, 0xc8, 0x86, 0xd5, 0xbf, 0x80, 0x15,
-		0xfc, 0xad, 0xae, 0x31, 0xa0, 0xad, 0x18, 0xfa, 0xb3, 0xf0, 0x1b, 0x00, 0xa3, 0x58, 0xde, 0x23,
-		0x76, 0x55, 0xc4, 0x96, 0x4a, 0xfa, 0xa2, 0xb3, 0x37, 0xe9, 0x6a, 0xd3, 0x16, 0xb9, 0xfb, 0x1c,
-		0xc5, 0x64, 0xb5, 0xae, 0xc5, 0xb6, 0x9a, 0x9f, 0xf6, 0xc3, 0xe4, 0x54, 0x87, 0x07, 0xfe, 0xf8,
-		0x50, 0x3d, 0x91, 0xdd, 0x86, 0x02, 0xe8, 0x67, 0xe6, 0xd3, 0x5d, 0x22, 0x35, 0xc1, 0x86, 0x9c,
-		0xe2, 0x47, 0x9c, 0x3b, 0x9d, 0x54, 0x01, 0xde, 0x04, 0xe0, 0x72, 0x7f, 0xb3, 0x3d, 0x65, 0x11, 
-		0x28, 0x5d, 0x4c, 0xf2, 0x95, 0x38, 0xd9, 0xe3, 0xb6, 0x05, 0x1f, 0x5b, 0x22, 0xcc, 0x1c, 0x93
-	};
-
-	const uint8_t dsaq_[20]=
-	{
-		0xa5, 0xdf, 0xc2, 0x8f, 0xef, 0x4c, 0xa1, 0xe2, 0x86, 0x74, 0x4c, 0xd8, 0xee, 0xd9, 0xd2, 0x9d,
-		0x68, 0x40, 0x46, 0xb7
-	};
-
-	const uint8_t dsag_[128]=
-	{
-		0x0c, 0x1f, 0x4d, 0x27, 0xd4, 0x00, 0x93, 0xb4, 0x29, 0xe9, 0x62, 0xd7, 0x22, 0x38, 0x24, 0xe0,
-		0xbb, 0xc4, 0x7e, 0x7c, 0x83, 0x2a, 0x39, 0x23, 0x6f, 0xc6, 0x83, 0xaf, 0x84, 0x88, 0x95, 0x81,
-		0x07, 0x5f, 0xf9, 0x08, 0x2e, 0xd3, 0x23, 0x53, 0xd4, 0x37, 0x4d, 0x73, 0x01, 0xcd, 0xa1, 0xd2,
-		0x3c, 0x43, 0x1f, 0x46, 0x98, 0x59, 0x9d, 0xda, 0x02, 0x45, 0x18, 0x24, 0xff, 0x36, 0x97, 0x52,
-		0x59, 0x36, 0x47, 0xcc, 0x3d, 0xdc, 0x19, 0x7d, 0xe9, 0x85, 0xe4, 0x3d, 0x13, 0x6c, 0xdc, 0xfc,
-		0x6b, 0xd5, 0x40, 0x9c, 0xd2, 0xf4, 0x50, 0x82, 0x11, 0x42, 0xa5, 0xe6, 0xf8, 0xeb, 0x1c, 0x3a,
-		0xb5, 0xd0, 0x48, 0x4b, 0x81, 0x29, 0xfc, 0xf1, 0x7b, 0xce, 0x4f, 0x7f, 0x33, 0x32, 0x1c, 0x3c, 
-		0xb3, 0xdb, 0xb1, 0x4a, 0x90, 0x5e, 0x7b, 0x2b, 0x3e, 0x93, 0xbe, 0x47, 0x08, 0xcb, 0xcc, 0x82  
-	};
-
-	const int rsae_ = 65537;	
-	
-	struct CryptoConstants
-	{
-		// DH/ElGamal
-		BIGNUM * elgp;
-		BIGNUM * elgg; 
-
-		// DSA
-		BIGNUM * dsap;		
-		BIGNUM * dsaq;
-		BIGNUM * dsag;
-
-		// RSA
-		BIGNUM * rsae;
-		
-		CryptoConstants (const uint8_t * elgp_, int elgg_, const uint8_t * dsap_, 
-			const uint8_t * dsaq_, const uint8_t * dsag_, int rsae_)
-		{
-			elgp = BN_new ();
-			BN_bin2bn (elgp_, 256, elgp);
-			elgg = BN_new ();
-			BN_set_word (elgg, elgg_);
-			dsap = BN_new ();
-			BN_bin2bn (dsap_, 128, dsap);
-			dsaq = BN_new ();
-			BN_bin2bn (dsaq_, 20, dsaq);
-			dsag = BN_new ();
-			BN_bin2bn (dsag_, 128, dsag);
-			rsae = BN_new ();
-			BN_set_word (rsae, rsae_);
-		}
-		
-		~CryptoConstants ()
-		{
-			BN_free (elgp);  BN_free (elgg); BN_free (dsap); BN_free (dsaq); BN_free (dsag); BN_free (rsae);
-		}	
-	};	
-
-	static const CryptoConstants& GetCryptoConstants ()
-	{
-		static CryptoConstants cryptoConstants (elgp_, elgg_, dsap_, dsaq_, dsag_, rsae_);		                                        
-		return cryptoConstants;
-	}	
-
-	bool bn2buf (const BIGNUM * bn, uint8_t * buf, size_t len)
-	{
-		int offset = len - BN_num_bytes (bn);
-		if (offset < 0) return false;
-		BN_bn2bin (bn, buf + offset);
-		memset (buf, 0, offset);
-		return true;
-	}	
-
-// RSA
-	#define rsae GetCryptoConstants ().rsae		
-	const BIGNUM * GetRSAE ()
-	{
-		return rsae;
-	}	
-
-// DSA
-	#define dsap GetCryptoConstants ().dsap	
-	#define dsaq GetCryptoConstants ().dsaq
-	#define dsag GetCryptoConstants ().dsag	
-	DSA * CreateDSA ()
-	{
-		DSA * dsa = DSA_new ();
-		dsa->p = BN_dup (dsap);
-		dsa->q = BN_dup (dsaq);
-		dsa->g = BN_dup (dsag);
-		dsa->priv_key = NULL;
-		dsa->pub_key = NULL;
-		return dsa;
-	}
-
-// DH/ElGamal	
-	#define elgp GetCryptoConstants ().elgp
-	#define elgg GetCryptoConstants ().elgg
-
-// DH
-	
-	DHKeys::DHKeys (): m_IsUpdated (true)
-	{
-		m_DH = DH_new ();
-		m_DH->p = BN_dup (elgp);
-		m_DH->g = BN_dup (elgg);
-		m_DH->priv_key = NULL;
-		m_DH->pub_key = NULL;
-	}
-	
-	DHKeys::~DHKeys ()
-	{
-		DH_free (m_DH);
-	}	
-
-	void DHKeys::GenerateKeys (uint8_t * priv, uint8_t * pub)
-	{
-		if (m_DH->priv_key)  { BN_free (m_DH->priv_key); m_DH->priv_key = NULL; };
-		if (m_DH->pub_key)  { BN_free (m_DH->pub_key); m_DH->pub_key = NULL; };
-		DH_generate_key (m_DH);
-		if (priv) bn2buf (m_DH->priv_key, priv, 256);
-		if (pub) bn2buf (m_DH->pub_key, pub, 256);
-		m_IsUpdated = true;
-	}	
-
-	const uint8_t * DHKeys::GetPublicKey () 
-	{
-		if (m_IsUpdated)
-		{	
-			bn2buf (m_DH->pub_key, m_PublicKey, 256);
-			BN_free (m_DH->pub_key); m_DH->pub_key = NULL;
-			m_IsUpdated= false;
-		}	
-		return m_PublicKey;
-	}	
-	
-	void DHKeys::Agree (const uint8_t * pub, uint8_t * shared)
-	{
-		BIGNUM * pk = BN_bin2bn (pub, 256, NULL);
-		DH_compute_key (shared, pk, m_DH);
-		BN_free (pk);
-	}	
-	
-// ElGamal
-
-	ElGamalEncryption::ElGamalEncryption (const uint8_t * key)
-	{
-		ctx = BN_CTX_new ();
-		// select random k
-		BIGNUM * k = BN_new ();
-		BN_rand_range (k, elgp);
-		if (BN_is_zero (k)) BN_one (k);
-		// caulculate a
-		a = BN_new ();
-		BN_mod_exp (a, elgg, k, elgp, ctx);
-		BIGNUM * y = BN_new ();
-		BN_bin2bn (key, 256, y);
-		// calculate b1
-		b1 = BN_new ();
-		BN_mod_exp (b1, y, k, elgp, ctx);
-		BN_free (y);
-		BN_free (k);
-	}
-
-	ElGamalEncryption::~ElGamalEncryption ()
-	{
-		BN_CTX_free (ctx);
-		BN_free (a);
-		BN_free (b1);
-	}
-			
-	void ElGamalEncryption::Encrypt (const uint8_t * data, int len, uint8_t * encrypted, bool zeroPadding) const
-	{
-		// create m
-		uint8_t m[255];
-		m[0] = 0xFF;
-		memcpy (m+33, data, len);
-		SHA256 (m+33, 222, m+1);
-		// calculate b = b1*m mod p
-		BIGNUM * b = BN_new ();
-		BN_bin2bn (m, 255, b);
-		BN_mod_mul (b, b1, b, elgp, ctx);
-		// copy a and b
-		if (zeroPadding)
-		{
-			encrypted[0] = 0;
-			bn2buf (a, encrypted + 1, 256);
-			encrypted[257] = 0;
-			bn2buf (b, encrypted + 258, 256);
-		}	
-		else
-		{
-			bn2buf (a, encrypted, 256);
-			bn2buf (b, encrypted + 256, 256);
-		}		
-		BN_free (b);
-	}
-	
-	bool ElGamalDecrypt (const uint8_t * key, const uint8_t * encrypted, 
-		uint8_t * data, bool zeroPadding)
-	{
-		BN_CTX * ctx = BN_CTX_new ();
-		BIGNUM * x = BN_new (), * a = BN_new (), * b = BN_new ();
-		BN_bin2bn (key, 256, x);
-		BN_sub (x, elgp, x); BN_sub_word (x, 1); // x = elgp - x- 1
-		BN_bin2bn (zeroPadding ? encrypted + 1 : encrypted, 256, a);
-		BN_bin2bn (zeroPadding ? encrypted + 258 : encrypted + 256, 256, b);
-		// m = b*(a^x mod p) mod p		
-		BN_mod_exp (x, a, x, elgp, ctx);
-		BN_mod_mul (b, b, x, elgp, ctx);	
-		uint8_t m[255];
-		bn2buf (b, m, 255); 
-		BN_free (x); BN_free (a); BN_free (b); 
-		BN_CTX_free (ctx);
-		uint8_t hash[32];
-		SHA256 (m + 33, 222, hash);
-		if (memcmp (m + 1, hash, 32))
-		{
-			LogPrint (eLogError, "ElGamal decrypt hash doesn't match");
-			return false;
-		}	
-		memcpy (data, m + 33, 222);
-		return true;
-	}	
-
-	void GenerateElGamalKeyPair (uint8_t * priv, uint8_t * pub)
-	{
-#if defined(__x86_64__) || defined(__i386__) || defined(_MSC_VER)	
-		RAND_bytes (priv, 256);
-		BN_CTX * ctx = BN_CTX_new ();
-		BIGNUM * p = BN_new ();	
-		BN_bin2bn (priv, 256, p);
-		BN_mod_exp (p, elgg, p, elgp, ctx);
-		bn2buf (p, pub, 256); 
-		BN_free (p);
-		BN_CTX_free (ctx);
-#else
-		DHKeys dh;
-		dh.GenerateKeys (priv, pub);
-		
-#endif		
-	}
-
-// HMAC
-	const uint64_t IPAD = 0x3636363636363636;
-	const uint64_t OPAD = 0x5C5C5C5C5C5C5C5C; 			
-		
-	void HMACMD5Digest (uint8_t * msg, size_t len, const MACKey& key, uint8_t * digest)
-	// key is 32 bytes
-	// digest is 16 bytes
-	// block size is 64 bytes	
-	{
-		uint64_t buf[256];
-		// ikeypad
-		buf[0] = key.GetLL ()[0] ^ IPAD; 
-		buf[1] = key.GetLL ()[1] ^ IPAD; 
-		buf[2] = key.GetLL ()[2] ^ IPAD; 
-		buf[3] = key.GetLL ()[3] ^ IPAD; 
-		buf[4] = IPAD; 
-		buf[5] = IPAD; 
-		buf[6] = IPAD; 
-		buf[7] = IPAD; 		
-		// concatenate with msg
-		memcpy (buf + 8, msg, len);
-		// calculate first hash
-		uint8_t hash[16]; // MD5
-		MD5((uint8_t *)buf, len + 64, hash);
-		
-		// okeypad			
-		buf[0] = key.GetLL ()[0] ^ OPAD; 
-		buf[1] = key.GetLL ()[1] ^ OPAD; 
-		buf[2] = key.GetLL ()[2] ^ OPAD; 
-		buf[3] = key.GetLL ()[3] ^ OPAD; 
-		buf[4] = OPAD; 
-		buf[5] = OPAD; 
-		buf[6] = OPAD; 
-		buf[7] = OPAD; 
-		// copy first hash after okeypad		
-		memcpy (buf + 8, hash, 16);
-		// fill next 16 bytes with zeros (first hash size assumed 32 bytes in I2P)
-		memset (buf + 10, 0, 16);			
-		
-		// calculate digest
-		MD5((uint8_t *)buf, 96, digest);
-	}
-
-// AES
-	#ifdef AESNI
-	
-	#define KeyExpansion256(round0,round1) \
-		"pshufd	$0xff, %%xmm2, %%xmm2 \n" \
-		"movaps	%%xmm1, %%xmm4 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm1 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm1 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm1 \n" \
-		"pxor %%xmm2, %%xmm1 \n" \
-		"movaps	%%xmm1, "#round0"(%[sched]) \n" \
-		"aeskeygenassist $0, %%xmm1, %%xmm4 \n" \
-		"pshufd	$0xaa, %%xmm4, %%xmm2 \n" \
-		"movaps	%%xmm3, %%xmm4 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm3 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm3 \n" \
-		"pslldq	$4, %%xmm4 \n" \
-		"pxor %%xmm4, %%xmm3 \n" \
-		"pxor %%xmm2, %%xmm3 \n" \
-		"movaps	%%xmm3, "#round1"(%[sched]) \n" 
-
-	void ECBCryptoAESNI::ExpandKey (const AESKey& key)
-	{
-		__asm__
-		(
-			"movups (%[key]), %%xmm1 \n"
-			"movups 16(%[key]), %%xmm3 \n"
-			"movaps %%xmm1, (%[sched]) \n"
-			"movaps %%xmm3, 16(%[sched]) \n"
-			"aeskeygenassist $1, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(32,48)
-			"aeskeygenassist $2, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(64,80)
-			"aeskeygenassist $4, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(96,112)
-			"aeskeygenassist $8, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(128,144)
-			"aeskeygenassist $16, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(160,176)
-			"aeskeygenassist $32, %%xmm3, %%xmm2 \n"
-			KeyExpansion256(192,208)
-			"aeskeygenassist $64, %%xmm3, %%xmm2 \n"
-			// key expansion final
-			"pshufd	$0xff, %%xmm2, %%xmm2 \n"
-			"movaps	%%xmm1, %%xmm4 \n" 
-			"pslldq	$4, %%xmm4 \n"
-			"pxor %%xmm4, %%xmm1 \n"
-			"pslldq	$4, %%xmm4 \n"
-			"pxor %%xmm4, %%xmm1 \n"
-			"pslldq	$4, %%xmm4 \n"
-			"pxor %%xmm4, %%xmm1 \n"
-			"pxor %%xmm2, %%xmm1 \n"
-			"movups	%%xmm1, 224(%[sched]) \n"
-			: // output
-			: [key]"r"((const uint8_t *)key), [sched]"r"(GetKeySchedule ()) // input
-			: "%xmm1", "%xmm2", "%xmm3", "%xmm4", "memory" // clogged
-		);
-	}
-
-	#define EncryptAES256(sched) \
-		"pxor (%["#sched"]), %%xmm0 \n" \
-		"aesenc	16(%["#sched"]), %%xmm0 \n" \
-		"aesenc	32(%["#sched"]), %%xmm0 \n" \
-		"aesenc	48(%["#sched"]), %%xmm0 \n" \
-		"aesenc	64(%["#sched"]), %%xmm0 \n" \
-		"aesenc	80(%["#sched"]), %%xmm0 \n" \
-		"aesenc	96(%["#sched"]), %%xmm0 \n" \
-		"aesenc	112(%["#sched"]), %%xmm0 \n" \
-		"aesenc	128(%["#sched"]), %%xmm0 \n" \
-		"aesenc	144(%["#sched"]), %%xmm0 \n" \
-		"aesenc	160(%["#sched"]), %%xmm0 \n" \
-		"aesenc	176(%["#sched"]), %%xmm0 \n" \
-		"aesenc	192(%["#sched"]), %%xmm0 \n" \
-		"aesenc	208(%["#sched"]), %%xmm0 \n" \
-		"aesenclast	224(%["#sched"]), %%xmm0 \n"
-		
-	void ECBEncryptionAESNI::Encrypt (const ChipherBlock * in, ChipherBlock * out)
-	{
-		__asm__
-		(
-			"movups	(%[in]), %%xmm0 \n"
-			EncryptAES256(sched)
-			"movups	%%xmm0, (%[out]) \n"	
-			: : [sched]"r"(GetKeySchedule ()), [in]"r"(in), [out]"r"(out) : "%xmm0", "memory"
-		);
-	}		
-
-	#define DecryptAES256(sched) \
-		"pxor 224(%["#sched"]), %%xmm0 \n" \
-		"aesdec	208(%["#sched"]), %%xmm0 \n" \
-		"aesdec	192(%["#sched"]), %%xmm0 \n" \
-		"aesdec	176(%["#sched"]), %%xmm0 \n" \
-		"aesdec	160(%["#sched"]), %%xmm0 \n" \
-		"aesdec	144(%["#sched"]), %%xmm0 \n" \
-		"aesdec	128(%["#sched"]), %%xmm0 \n" \
-		"aesdec	112(%["#sched"]), %%xmm0 \n" \
-		"aesdec	96(%["#sched"]), %%xmm0 \n" \
-		"aesdec	80(%["#sched"]), %%xmm0 \n" \
-		"aesdec	64(%["#sched"]), %%xmm0 \n" \
-		"aesdec	48(%["#sched"]), %%xmm0 \n" \
-		"aesdec	32(%["#sched"]), %%xmm0 \n" \
-		"aesdec	16(%["#sched"]), %%xmm0 \n" \
-		"aesdeclast (%["#sched"]), %%xmm0 \n"
-	
-	void ECBDecryptionAESNI::Decrypt (const ChipherBlock * in, ChipherBlock * out)
-	{
-		__asm__
-		(
-			"movups	(%[in]), %%xmm0 \n"
-			DecryptAES256(sched)
-			"movups	%%xmm0, (%[out]) \n"	
-			: : [sched]"r"(GetKeySchedule ()), [in]"r"(in), [out]"r"(out) : "%xmm0", "memory"
-		);		
-	}
-
-	#define CallAESIMC(offset) \
-		"movaps "#offset"(%[shed]), %%xmm0 \n"	\
-		"aesimc %%xmm0, %%xmm0 \n" \
-		"movaps %%xmm0, "#offset"(%[shed]) \n" 
-
-	void ECBDecryptionAESNI::SetKey (const AESKey& key)
-	{
-		ExpandKey (key); // expand encryption key first
-		// then  invert it using aesimc
-		__asm__
-		(
-			CallAESIMC(16)
-			CallAESIMC(32)
-			CallAESIMC(48)
-			CallAESIMC(64)
-			CallAESIMC(80)
-			CallAESIMC(96)
-			CallAESIMC(112)
-			CallAESIMC(128)
-			CallAESIMC(144)
-			CallAESIMC(160)
-			CallAESIMC(176)
-			CallAESIMC(192)
-			CallAESIMC(208)
-			: : [shed]"r"(GetKeySchedule ()) : "%xmm0", "memory"
-		);
-	}
-
-#endif		
-
-
-	void CBCEncryption::Encrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-		 	"movups	(%[iv]), %%xmm1 \n"
-		 	"1: \n"
-		 	"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched)
-		 	"movaps	%%xmm0, %%xmm1 \n"	
-		 	"movups	%%xmm0, (%[out]) \n"
-		 	"add $16, %[in] \n"
-		 	"add $16, %[out] \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-		 	"movups	%%xmm1, (%[iv]) \n"
-			: 
-			: [iv]"r"(&m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out), [num]"r"(numBlocks)
-			: "%xmm0", "%xmm1", "cc", "memory"
-		); 
-#else		
-		for (int i = 0; i < numBlocks; i++)
-		{
-			m_LastBlock ^= in[i];
-			m_ECBEncryption.Encrypt (&m_LastBlock, &m_LastBlock);
-			out[i] = m_LastBlock;
-		}
-#endif		
-	}
-
-	void CBCEncryption::Encrypt (const uint8_t * in, std::size_t len, uint8_t * out)
-	{
-		// len/16
-		int numBlocks = len >> 4;
-		if (numBlocks > 0)
-			Encrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out); 
-	}
-
-	void CBCEncryption::Encrypt (const uint8_t * in, uint8_t * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-			"movups	(%[iv]), %%xmm1 \n"
-			"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched)
-			"movups	%%xmm0, (%[out]) \n"
-			"movups	%%xmm0, (%[iv]) \n"
-			: 
-			: [iv]"r"(&m_LastBlock), [sched]"r"(m_ECBEncryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out)
-			: "%xmm0", "%xmm1", "memory"
-		);		
-#else
-		Encrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out); 
-#endif
-	}
-
-	void CBCDecryption::Decrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-			"movups	(%[iv]), %%xmm1 \n"
-		 	"1: \n"
-		 	"movups	(%[in]), %%xmm0 \n"
-			"movaps %%xmm0, %%xmm2 \n"
-		 	DecryptAES256(sched)
-			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
-			"movaps %%xmm2, %%xmm1 \n"
-		 	"add $16, %[in] \n"
-		 	"add $16, %[out] \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-		 	"movups	%%xmm1, (%[iv]) \n"
-			: 
-			: [iv]"r"(&m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out), [num]"r"(numBlocks)
-			: "%xmm0", "%xmm1", "%xmm2", "cc", "memory"
-		); 
-#else
-		for (int i = 0; i < numBlocks; i++)
-		{
-			ChipherBlock tmp = in[i];
-			m_ECBDecryption.Decrypt (in + i, out + i);
-			out[i] ^= m_IV;
-			m_IV = tmp;
-		}
-#endif
-	}
-
-	void CBCDecryption::Decrypt (const uint8_t * in, std::size_t len, uint8_t * out)
-	{
-		int numBlocks = len >> 4;
-		if (numBlocks > 0)
-			Decrypt (numBlocks, (const ChipherBlock *)in, (ChipherBlock *)out); 
-	}
-
-	void CBCDecryption::Decrypt (const uint8_t * in, uint8_t * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-			"movups	(%[iv]), %%xmm1 \n"
-		 	"movups	(%[in]), %%xmm0 \n"
-			"movups	%%xmm0, (%[iv]) \n"
-		 	DecryptAES256(sched)
-			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"	
-			: 
-			: [iv]"r"(&m_IV), [sched]"r"(m_ECBDecryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out)
-			: "%xmm0", "%xmm1", "memory"
-		);
-#else
-		Decrypt (1, (const ChipherBlock *)in, (ChipherBlock *)out); 
-#endif
-	}
-
-	void TunnelEncryption::Encrypt (const uint8_t * in, uint8_t * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-            // encrypt IV 
-			"movups	(%[in]), %%xmm0 \n"
-			EncryptAES256(sched_iv)
-			"movaps %%xmm0, %%xmm1 \n"
-			// double IV encryption
-			EncryptAES256(sched_iv)
-			"movups %%xmm0, (%[out]) \n"
-			// encrypt data, IV is xmm1
-			"1: \n"
-			"add $16, %[in] \n"
-		    "add $16, %[out] \n"
-		 	"movups	(%[in]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched_l)
-		 	"movaps	%%xmm0, %%xmm1 \n"	
-		 	"movups	%%xmm0, (%[out]) \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-			: 
-			: [sched_iv]"r"(m_IVEncryption.GetKeySchedule ()), [sched_l]"r"(m_LayerEncryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out), [num]"r"(63) // 63 blocks = 1008 bytes
-			: "%xmm0", "%xmm1", "cc", "memory"
-		);
-#else
-		m_IVEncryption.Encrypt ((const ChipherBlock *)in, (ChipherBlock *)out); // iv
-		m_LayerEncryption.SetIV (out);
-		m_LayerEncryption.Encrypt (in + 16, i2p::tunnel::TUNNEL_DATA_ENCRYPTED_SIZE, out + 16); // data
-		m_IVEncryption.Encrypt ((ChipherBlock *)out, (ChipherBlock *)out); // double iv
-#endif
-	}
-
-	void TunnelDecryption::Decrypt (const uint8_t * in, uint8_t * out)
-	{
-#ifdef AESNI
-		__asm__
-		(
-            // decrypt IV 
-			"movups	(%[in]), %%xmm0 \n"
-			DecryptAES256(sched_iv)
-			"movaps %%xmm0, %%xmm1 \n"
-			// double IV encryption
-			DecryptAES256(sched_iv)
-			"movups %%xmm0, (%[out]) \n"
-			// decrypt data, IV is xmm1
-			"1: \n"
-			"add $16, %[in] \n"
-		    "add $16, %[out] \n"
-			"movups	(%[in]), %%xmm0 \n"
-			"movaps %%xmm0, %%xmm2 \n"
-		 	DecryptAES256(sched_l)
-			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[out]) \n"
-			"movaps %%xmm2, %%xmm1 \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-			: 
-			: [sched_iv]"r"(m_IVDecryption.GetKeySchedule ()), [sched_l]"r"(m_LayerDecryption.GetKeySchedule ()), 
-			  [in]"r"(in), [out]"r"(out), [num]"r"(63) // 63 blocks = 1008 bytes
-			: "%xmm0", "%xmm1", "%xmm2", "cc", "memory"
-		);
-#else
-		m_IVDecryption.Decrypt ((const ChipherBlock *)in, (ChipherBlock *)out); // iv
-		m_LayerDecryption.SetIV (out);	
-		m_LayerDecryption.Decrypt (in + 16, i2p::tunnel::TUNNEL_DATA_ENCRYPTED_SIZE, out + 16); // data
-		m_IVDecryption.Decrypt ((ChipherBlock *)out, (ChipherBlock *)out); // double iv
-#endif
-	}	
-
-/*	std::vector <std::unique_ptr<std::mutex> >  m_OpenSSLMutexes;
-	static void OpensslLockingCallback(int mode, int type, const char * file, int line)
-	{
-		if (type > 0 && (size_t)type < m_OpenSSLMutexes.size ())
-		{
-			if (mode & CRYPTO_LOCK)
-				m_OpenSSLMutexes[type]->lock ();
-			else
-				m_OpenSSLMutexes[type]->unlock ();
-		}	
-	}*/
-	
-	void InitCrypto ()
-	{
-		SSL_library_init ();
-/*		auto numLocks = CRYPTO_num_locks();
-		for (int i = 0; i < numLocks; i++)
-		     m_OpenSSLMutexes.emplace_back (new std::mutex);
-		CRYPTO_set_locking_callback (OpensslLockingCallback);*/
-	}
-	
-	void TerminateCrypto ()
-	{
-/*		CRYPTO_set_locking_callback (nullptr);
-		m_OpenSSLMutexes.clear ();*/
-	}	
-}
-}
-

Crypto.h

@@ -1,281 +0,0 @@
-#ifndef CRYPTO_H__
-#define CRYPTO_H__
-
-#include <inttypes.h>
-#include <string>
-#include <openssl/bn.h>
-#include <openssl/dh.h>
-#include <openssl/aes.h>
-#include <openssl/dsa.h>
-#include "Base.h"
-
-namespace i2p
-{
-namespace crypto
-{
-	bool bn2buf (const BIGNUM * bn, uint8_t * buf, size_t len);
-
-	// DSA
-	DSA * CreateDSA ();	
-
-	// RSA
-	const BIGNUM * GetRSAE ();
-
-	// DH
-	class DHKeys
-	{
-		public:
-			
-			DHKeys ();
-			~DHKeys ();
-
-			void GenerateKeys (uint8_t * priv = nullptr, uint8_t * pub = nullptr);
-			const uint8_t * GetPublicKey ();
-			void Agree (const uint8_t * pub, uint8_t * shared);
-			
-		private:
-
-			DH * m_DH;
-			uint8_t m_PublicKey[256];
-			bool m_IsUpdated;
-	};	
-	
-	// ElGamal
-	class ElGamalEncryption
-	{
-		public:
-
-			ElGamalEncryption (const uint8_t * key);
-			~ElGamalEncryption ();
-			
-			void Encrypt (const uint8_t * data, int len, uint8_t * encrypted, bool zeroPadding = false) const;
-
-		private:
-
-			BN_CTX * ctx;
-			BIGNUM * a, * b1;
-	};
-
-	bool ElGamalDecrypt (const uint8_t * key, const uint8_t * encrypted, uint8_t * data, bool zeroPadding = false);
-	void GenerateElGamalKeyPair (uint8_t * priv, uint8_t * pub);
-
-	// HMAC
-	typedef i2p::data::Tag<32> MACKey;		
-	void HMACMD5Digest (uint8_t * msg, size_t len, const MACKey& key, uint8_t * digest);
-
-	// AES
-	struct ChipherBlock	
-	{
-		uint8_t buf[16];
-
-		void operator^=(const ChipherBlock& other) // XOR
-		{
-#if defined(__x86_64__) || defined(__SSE__) // for Intel x84 or with SSE
-			__asm__
-			(
-				"movups	(%[buf]), %%xmm0 \n"	
-				"movups	(%[other]), %%xmm1 \n"	
-				"pxor %%xmm1, %%xmm0 \n"
-				"movups	%%xmm0, (%[buf]) \n"
-				: 
-				: [buf]"r"(buf), [other]"r"(other.buf) 
-				: "%xmm0", "%xmm1", "memory"
-			);			
-#else
-			// TODO: implement it better
-			for (int i = 0; i < 16; i++)
-				buf[i] ^= other.buf[i];
-#endif
-		}	 
-	};
-
-	typedef i2p::data::Tag<32> AESKey;
-	
-	template<size_t sz>
-	class AESAlignedBuffer // 16 bytes alignment
-	{
-		public:
-		
-			AESAlignedBuffer ()
-			{
-				m_Buf = m_UnalignedBuffer;
-				uint8_t rem = ((size_t)m_Buf) & 0x0f;
-				if (rem)
-					m_Buf += (16 - rem);
-			}
-		
-			operator uint8_t * () { return m_Buf; };
-			operator const uint8_t * () const { return m_Buf; };
-
-		private:
-
-			uint8_t m_UnalignedBuffer[sz + 15]; // up to 15 bytes alignment
-			uint8_t * m_Buf;
-	};			
-
-
-#ifdef AESNI
-	class ECBCryptoAESNI
-	{	
-		public:
-
-			uint8_t * GetKeySchedule () { return m_KeySchedule; };
-
-		protected:
-
-			void ExpandKey (const AESKey& key);
-		
-		private:
-
-			AESAlignedBuffer<240> m_KeySchedule;  // 14 rounds for AES-256, 240 bytes
-	};	
-
-	class ECBEncryptionAESNI: public ECBCryptoAESNI
-	{
-		public:
-		
-			void SetKey (const AESKey& key) { ExpandKey (key); };
-			void Encrypt (const ChipherBlock * in, ChipherBlock * out);	
-	};	
-
-	class ECBDecryptionAESNI: public ECBCryptoAESNI
-	{
-		public:
-		
-			void SetKey (const AESKey& key);
-			void Decrypt (const ChipherBlock * in, ChipherBlock * out);		
-	};	
-
-	typedef ECBEncryptionAESNI ECBEncryption;
-	typedef ECBDecryptionAESNI ECBDecryption;
-
-#else // use openssl
-
-	class ECBEncryption
-	{
-		public:
-		
-			void SetKey (const AESKey& key) 
-			{ 
-				AES_set_encrypt_key (key, 256, &m_Key);
-			}
-			void Encrypt (const ChipherBlock * in, ChipherBlock * out)
-			{
-				AES_encrypt (in->buf, out->buf, &m_Key);
-			}	
-
-		private:
-
-			AES_KEY m_Key;
-	};	
-
-	class ECBDecryption
-	{
-		public:
-		
-			void SetKey (const AESKey& key) 
-			{ 
-				AES_set_decrypt_key (key, 256, &m_Key); 
-			}
-			void Decrypt (const ChipherBlock * in, ChipherBlock * out)
-			{
-				AES_decrypt (in->buf, out->buf, &m_Key);
-			}	
-
-		private:
-
-			AES_KEY m_Key;
-	};		
-
-
-#endif			
-
-	class CBCEncryption
-	{
-		public:
-	
-			CBCEncryption () { memset (m_LastBlock.buf, 0, 16); };
-
-			void SetKey (const AESKey& key) { m_ECBEncryption.SetKey (key); }; // 32 bytes
-			void SetIV (const uint8_t * iv) { memcpy (m_LastBlock.buf, iv, 16); }; // 16 bytes
-
-			void Encrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out);
-			void Encrypt (const uint8_t * in, std::size_t len, uint8_t * out);
-			void Encrypt (const uint8_t * in, uint8_t * out); // one block
-
-		private:
-
-			ChipherBlock m_LastBlock;
-			
-			ECBEncryption m_ECBEncryption;
-	};
-
-	class CBCDecryption
-	{
-		public:
-	
-			CBCDecryption () { memset (m_IV.buf, 0, 16); };
-
-			void SetKey (const AESKey& key) { m_ECBDecryption.SetKey (key); }; // 32 bytes
-			void SetIV (const uint8_t * iv) { memcpy (m_IV.buf, iv, 16); }; // 16 bytes
-
-			void Decrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out);
-			void Decrypt (const uint8_t * in, std::size_t len, uint8_t * out);
-			void Decrypt (const uint8_t * in, uint8_t * out); // one block
-
-		private:
-
-			ChipherBlock m_IV;
-			ECBDecryption m_ECBDecryption;
-	};	
-
-	class TunnelEncryption // with double IV encryption
-	{
-		public:
-
-			void SetKeys (const AESKey& layerKey, const AESKey& ivKey)
-			{
-				m_LayerEncryption.SetKey (layerKey);
-				m_IVEncryption.SetKey (ivKey);
-			}	
-
-			void Encrypt (const uint8_t * in, uint8_t * out); // 1024 bytes (16 IV + 1008 data)		
-
-		private:
-
-			ECBEncryption m_IVEncryption;
-#ifdef AESNI
-			ECBEncryption m_LayerEncryption;
-#else
-			CBCEncryption m_LayerEncryption;
-#endif
-	};
-
-	class TunnelDecryption // with double IV encryption
-	{
-		public:
-
-			void SetKeys (const AESKey& layerKey, const AESKey& ivKey)
-			{
-				m_LayerDecryption.SetKey (layerKey);
-				m_IVDecryption.SetKey (ivKey);
-			}			
-
-			void Decrypt (const uint8_t * in, uint8_t * out); // 1024 bytes (16 IV + 1008 data)	
-
-		private:
-
-			ECBDecryption m_IVDecryption;
-#ifdef AESNI
-			ECBDecryption m_LayerDecryption;
-#else
-			CBCDecryption m_LayerDecryption;
-#endif
-	};	
-
-	void InitCrypto ();
-	void TerminateCrypto ();
-}		
-}	
-
-#endif

CryptoConst.cpp

@@ -1,73 +0,0 @@
-#include <inttypes.h>
-#include "CryptoConst.h"
-
-namespace i2p
-{
-namespace crypto
-{
-	const uint8_t elgp_[256]=
-	{
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34, 
-		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 
-		0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-		0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
-		0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45, 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
- 		0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-		0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
-		0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D, 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 
-		0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
-		0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
-		0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D, 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 
-		0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
-		0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F,
-		0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9, 0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18,
-		0x39, 0x95, 0x49, 0x7C, 0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
-		0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAC, 0xAA, 0x68, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-	};
-	
-	const uint8_t dsap_[128]=
-	{
-		0x9c, 0x05, 0xb2, 0xaa, 0x96, 0x0d, 0x9b, 0x97, 0xb8, 0x93, 0x19, 0x63, 0xc9, 0xcc, 0x9e, 0x8c,
-		0x30, 0x26, 0xe9, 0xb8, 0xed, 0x92, 0xfa, 0xd0, 0xa6, 0x9c, 0xc8, 0x86, 0xd5, 0xbf, 0x80, 0x15,
-		0xfc, 0xad, 0xae, 0x31, 0xa0, 0xad, 0x18, 0xfa, 0xb3, 0xf0, 0x1b, 0x00, 0xa3, 0x58, 0xde, 0x23,
-		0x76, 0x55, 0xc4, 0x96, 0x4a, 0xfa, 0xa2, 0xb3, 0x37, 0xe9, 0x6a, 0xd3, 0x16, 0xb9, 0xfb, 0x1c,
-		0xc5, 0x64, 0xb5, 0xae, 0xc5, 0xb6, 0x9a, 0x9f, 0xf6, 0xc3, 0xe4, 0x54, 0x87, 0x07, 0xfe, 0xf8,
-		0x50, 0x3d, 0x91, 0xdd, 0x86, 0x02, 0xe8, 0x67, 0xe6, 0xd3, 0x5d, 0x22, 0x35, 0xc1, 0x86, 0x9c,
-		0xe2, 0x47, 0x9c, 0x3b, 0x9d, 0x54, 0x01, 0xde, 0x04, 0xe0, 0x72, 0x7f, 0xb3, 0x3d, 0x65, 0x11, 
-		0x28, 0x5d, 0x4c, 0xf2, 0x95, 0x38, 0xd9, 0xe3, 0xb6, 0x05, 0x1f, 0x5b, 0x22, 0xcc, 0x1c, 0x93
-	};
-
-	const uint8_t dsaq_[20]=
-	{
-		0xa5, 0xdf, 0xc2, 0x8f, 0xef, 0x4c, 0xa1, 0xe2, 0x86, 0x74, 0x4c, 0xd8, 0xee, 0xd9, 0xd2, 0x9d,
-		0x68, 0x40, 0x46, 0xb7
-	};
-
-	const uint8_t dsag_[128]=
-	{
-		0x0c, 0x1f, 0x4d, 0x27, 0xd4, 0x00, 0x93, 0xb4, 0x29, 0xe9, 0x62, 0xd7, 0x22, 0x38, 0x24, 0xe0,
-		0xbb, 0xc4, 0x7e, 0x7c, 0x83, 0x2a, 0x39, 0x23, 0x6f, 0xc6, 0x83, 0xaf, 0x84, 0x88, 0x95, 0x81,
-		0x07, 0x5f, 0xf9, 0x08, 0x2e, 0xd3, 0x23, 0x53, 0xd4, 0x37, 0x4d, 0x73, 0x01, 0xcd, 0xa1, 0xd2,
-		0x3c, 0x43, 0x1f, 0x46, 0x98, 0x59, 0x9d, 0xda, 0x02, 0x45, 0x18, 0x24, 0xff, 0x36, 0x97, 0x52,
-		0x59, 0x36, 0x47, 0xcc, 0x3d, 0xdc, 0x19, 0x7d, 0xe9, 0x85, 0xe4, 0x3d, 0x13, 0x6c, 0xdc, 0xfc,
-		0x6b, 0xd5, 0x40, 0x9c, 0xd2, 0xf4, 0x50, 0x82, 0x11, 0x42, 0xa5, 0xe6, 0xf8, 0xeb, 0x1c, 0x3a,
-		0xb5, 0xd0, 0x48, 0x4b, 0x81, 0x29, 0xfc, 0xf1, 0x7b, 0xce, 0x4f, 0x7f, 0x33, 0x32, 0x1c, 0x3c, 
-		0xb3, 0xdb, 0xb1, 0x4a, 0x90, 0x5e, 0x7b, 0x2b, 0x3e, 0x93, 0xbe, 0x47, 0x08, 0xcb, 0xcc, 0x82  
-	};
-
-	const CryptoConstants& GetCryptoConstants ()
-	{
-		static CryptoConstants cryptoConstants = 
-		{
-			{elgp_, 256},	// elgp
-			{2},			// elgg	
-			{dsap_, 128},	// dsap
-			{dsaq_, 20},	// dsaq
-			{dsag_, 128}	// dsag
-		};	
-		return cryptoConstants;
-	}	
-	
-}
-}
-

CryptoConst.h

@@ -1,38 +0,0 @@
-#ifndef CRYPTO_CONST_H__
-#define CRYPTO_CONST_H__
-
-#include <cryptopp/integer.h>
-
-namespace i2p
-{
-namespace crypto
-{
-	struct CryptoConstants
-	{
-		// DH/ElGamal
-		const CryptoPP::Integer elgp;
-		const CryptoPP::Integer elgg; 
-
-		// DSA
-		const CryptoPP::Integer dsap;		
-		const CryptoPP::Integer dsaq;
-		const CryptoPP::Integer dsag;			
-	};	
-	
-	const CryptoConstants& GetCryptoConstants ();
-	
-	// DH/ElGamal	
-	#define elgp GetCryptoConstants ().elgp
-	#define elgg GetCryptoConstants ().elgg
-
-	// DSA
-	#define dsap GetCryptoConstants ().dsap	
-	#define dsaq GetCryptoConstants ().dsaq
-	#define dsag GetCryptoConstants ().dsag	
-
-	// RSA
-	const int rsae = 65537;	
-}		
-}	
-
-#endif

Daemon.cpp

@@ -1,239 +0,0 @@
-#include <thread>
-#include <memory>
-
-#include "Daemon.h"
-
-#include "Config.h"
-#include "Log.h"
-#include "FS.h"
-#include "Base.h"
-#include "version.h"
-#include "Transports.h"
-#include "NTCPSession.h"
-#include "RouterInfo.h"
-#include "RouterContext.h"
-#include "Tunnel.h"
-#include "NetDb.h"
-#include "Garlic.h"
-#include "Streaming.h"
-#include "Destination.h"
-#include "HTTPServer.h"
-#include "I2PControl.h"
-#include "ClientContext.h"
-#include "Crypto.h"
-
-#ifdef USE_UPNP
-#include "UPnP.h"
-#endif
-
-namespace i2p
-{
-	namespace util
-	{
-		class Daemon_Singleton::Daemon_Singleton_Private
-		{
-		public:
-			Daemon_Singleton_Private() {};
-			~Daemon_Singleton_Private() {};
-
-			std::unique_ptr<i2p::util::HTTPServer> httpServer;
-			std::unique_ptr<i2p::client::I2PControlService> m_I2PControlService;
-
-#ifdef USE_UPNP
-			i2p::transport::UPnP m_UPnP;
-#endif	
-		};
-
-		Daemon_Singleton::Daemon_Singleton() : running(1), d(*new Daemon_Singleton_Private()) {};
-		Daemon_Singleton::~Daemon_Singleton() {
-			delete &d;
-		};
-
-		bool Daemon_Singleton::IsService () const
-		{
-			bool service = false;
-#ifndef _WIN32
-			i2p::config::GetOption("service", service);
-#endif
-			return service;
-		}
-
-		bool Daemon_Singleton::init(int argc, char* argv[])
-		{
-			i2p::config::Init();
-			i2p::config::ParseCmdline(argc, argv);
-
-			std::string config;  i2p::config::GetOption("conf",    config);
-			std::string datadir; i2p::config::GetOption("datadir", datadir);
-			i2p::fs::DetectDataDir(datadir, IsService());
-			i2p::fs::Init();
-
-			datadir = i2p::fs::GetDataDir();
-			if (config  == "")
-			{
-				config = i2p::fs::DataDirPath("i2p.conf");
-				// use i2p.cong only if exists
-				if (!i2p::fs::Exists (config)) config = ""; /* reset */
-			}
-
-			i2p::config::ParseConfig(config);
-			i2p::config::Finalize();
-
-			i2p::crypto::InitCrypto ();
-			i2p::context.Init ();
-
-			i2p::config::GetOption("daemon", isDaemon);
-
-			// TODO: move log init here
-
-			LogPrint(eLogInfo,  "i2pd v", VERSION, " starting");
-			LogPrint(eLogDebug, "FS: main config file: ", config);
-			LogPrint(eLogDebug, "FS: data directory: ", datadir);
-
-			uint16_t port; i2p::config::GetOption("port", port);
-			if (!i2p::config::IsDefault("port"))
-			{	
-				LogPrint(eLogInfo, "Daemon: accepting incoming connections at port ", port);
-				i2p::context.UpdatePort (port);
-			}	
-
-			std::string host; i2p::config::GetOption("host", host);
-			if (!i2p::config::IsDefault("host"))
-			{
-				LogPrint(eLogInfo, "Daemon: setting address for incoming connections to ", host);
-				i2p::context.UpdateAddress (boost::asio::ip::address::from_string (host));	
-			}
-
-			bool ipv6;    i2p::config::GetOption("ipv6", ipv6);
-			bool transit; i2p::config::GetOption("notransit", transit);
-			i2p::context.SetSupportsV6     (ipv6);
-			i2p::context.SetAcceptsTunnels (!transit);
-
-			bool isFloodfill; i2p::config::GetOption("floodfill", isFloodfill);
-			char bandwidth;   i2p::config::GetOption("bandwidth", bandwidth);
-
-			if (isFloodfill) 
-			{
-				LogPrint(eLogInfo, "Daemon: router will be floodfill");
-				i2p::context.SetFloodfill (true);
-			}	
-			else
-				i2p::context.SetFloodfill (false);
-			if (bandwidth != '-')
-			{
-				LogPrint(eLogInfo, "Daemon: bandwidth set to ", bandwidth);
-				if (bandwidth > 'O') 
-					i2p::context.SetExtraBandwidth (); 
-				else if (bandwidth > 'L')
-					i2p::context.SetHighBandwidth (); 
-				else 
-					i2p::context.SetLowBandwidth ();
-			}
-			else if (isFloodfill) 
-			{
-				LogPrint(eLogInfo, "Daemon: floodfill bandwidth set to 'extra'");
-				i2p::context.SetExtraBandwidth ();
-			} 
-			else
-			{
-				LogPrint(eLogInfo, "Daemon: bandwidth set to 'low'");
-				i2p::context.SetLowBandwidth ();
-			}
-
-			std::string family; i2p::config::GetOption("family", family);
-			i2p::context.SetFamily (family);
-			if (family.length () > 0)
-				LogPrint(eLogInfo, "Daemon: family set to ", family);	
-			
-			return true;
-		}
-			
-		bool Daemon_Singleton::start()
-		{
-			std::string logs     = ""; i2p::config::GetOption("log",      logs);
-			std::string logfile  = ""; i2p::config::GetOption("logfile",  logfile);
-			std::string loglevel = ""; i2p::config::GetOption("loglevel", loglevel);
-
-			if (isDaemon && (logs == "" || logs == "stdout"))
-				logs = "file";
-
-			if (logs == "file") {
-				if (logfile == "")
-					logfile = i2p::fs::DataDirPath("i2pd.log");
-				StartLog (logfile);
-			} else {
-				// use stdout
-				StartLog ("");
-			}
-			SetLogLevel(loglevel);
-			
-			bool http; i2p::config::GetOption("http.enabled", http);
-			if (http) {
-				std::string httpAddr; i2p::config::GetOption("http.address", httpAddr);
-				uint16_t    httpPort; i2p::config::GetOption("http.port",    httpPort);
-				LogPrint(eLogInfo, "Daemon: starting HTTP Server at ", httpAddr, ":", httpPort);
-				d.httpServer = std::unique_ptr<i2p::util::HTTPServer>(new i2p::util::HTTPServer(httpAddr, httpPort));
-				d.httpServer->Start();
-			}
-
-			LogPrint(eLogInfo, "Daemon: starting NetDB");
-			i2p::data::netdb.Start();
-
-#ifdef USE_UPNP
-			LogPrint(eLogInfo, "Daemon: starting UPnP");
-			d.m_UPnP.Start ();
-#endif			
-			LogPrint(eLogInfo, "Daemon: starting Transports");
-			i2p::transport::transports.Start();
-
-			LogPrint(eLogInfo, "Daemon: starting Tunnels");
-			i2p::tunnel::tunnels.Start();
-
-			LogPrint(eLogInfo, "Daemon: starting Client");
-			i2p::client::context.Start ();
-
-			// I2P Control Protocol
-			bool i2pcontrol; i2p::config::GetOption("i2pcontrol.enabled", i2pcontrol);
-			if (i2pcontrol) {
-				std::string i2pcpAddr; i2p::config::GetOption("i2pcontrol.address", i2pcpAddr);
-				uint16_t    i2pcpPort; i2p::config::GetOption("i2pcontrol.port",    i2pcpPort);
-				LogPrint(eLogInfo, "Daemon: starting I2PControl at ", i2pcpAddr, ":", i2pcpPort);
-				d.m_I2PControlService = std::unique_ptr<i2p::client::I2PControlService>(new i2p::client::I2PControlService (i2pcpAddr, i2pcpPort));
-				d.m_I2PControlService->Start ();
-			}
-			return true;
-		}
-
-		bool Daemon_Singleton::stop()
-		{
-			LogPrint(eLogInfo, "Daemon: shutting down");
-			LogPrint(eLogInfo, "Daemon: stopping Client");
-			i2p::client::context.Stop();
-			LogPrint(eLogInfo, "Daemon: stopping Tunnels");
-			i2p::tunnel::tunnels.Stop();
-#ifdef USE_UPNP
-			LogPrint(eLogInfo, "Daemon: stopping UPnP");
-			d.m_UPnP.Stop ();
-#endif			
-			LogPrint(eLogInfo, "Daemon: stopping Transports");
-			i2p::transport::transports.Stop();
-			LogPrint(eLogInfo, "Daemon: stopping NetDB");
-			i2p::data::netdb.Stop();
-			if (d.httpServer) {
-				LogPrint(eLogInfo, "Daemon: stopping HTTP Server");
-				d.httpServer->Stop();
-				d.httpServer = nullptr;
-			}
-			if (d.m_I2PControlService)
-			{
-				LogPrint(eLogInfo, "Daemon: stopping I2PControl");
-				d.m_I2PControlService->Stop ();
-				d.m_I2PControlService = nullptr;
-			}	
-			i2p::crypto::TerminateCrypto ();
-			StopLog ();
-
-			return true;
-		}
-	}
-}

Daemon.h

@@ -1,75 +0,0 @@
-#ifndef DAEMON_H__
-#define DAEMON_H__
-
-#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();
-
-			bool isLogging;
-			bool isDaemon;
-			
-			bool 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:
-			static DaemonLinux& Instance()
-			{
-				static DaemonLinux instance;
-				return instance;
-			}
-
-			virtual bool start();
-			virtual bool stop();
-                private:
-                       std::string pidfile;
-                       int pidFH;
-
-		};
-#endif
-	}
-}
-
-#endif // DAEMON_H__

DaemonLinux.cpp

@@ -1,124 +0,0 @@
-#include "Daemon.h"
-
-#ifndef _WIN32
-
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-
-#include "Config.h"
-#include "FS.h"
-#include "Log.h"
-
-void handle_signal(int sig)
-{
-	switch (sig)
-	{
-	case SIGHUP:
-		LogPrint(eLogInfo, "Daemon: Got SIGHUP, reopening log...");
-		ReopenLogFile ();
-	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
-				{
-					LogPrint(eLogError, "Daemon: could not fork: ", strerror(errno));
-					return false;
-				}
-
-				// child
-				umask(S_IWGRP | S_IRWXO); // 0027
-				int sid = setsid();
-				if (sid < 0)
-				{
-					LogPrint(eLogError, "Daemon: could not create process group.");
-					return false;
-				}
-				std::string d = i2p::fs::GetDataDir();
-				if (chdir(d.c_str()) != 0)
-				{
-					LogPrint(eLogError, "Daemon: could not chdir: ", strerror(errno));
-					return false;
-				}
-
-				// 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
-			// this code is c-styled and a bit ugly, but we need fd for locking pidfile
-			std::string pidfile; i2p::config::GetOption("pidfile", pidfile);
-			if (pidfile == "") {
-				pidfile = i2p::fs::DataDirPath("i2pd.pid");
-			}
-			if (pidfile != "") {
-				pidFH = open(pidfile.c_str(), O_RDWR | O_CREAT, 0600);
-				if (pidFH < 0)
-				{
-					LogPrint(eLogError, "Daemon: could not create pid file ", pidfile, ": ", strerror(errno));
-					return false;
-				}
-				if (lockf(pidFH, F_TLOCK, 0) != 0)
-				{
-					LogPrint(eLogError, "Daemon: could not lock pid file ", pidfile, ": ", strerror(errno));
-					return false;
-				}
-				char pid[10];
-				sprintf(pid, "%d\n", getpid());
-				ftruncate(pidFH, 0);
-				if (write(pidFH, pid, strlen(pid)) < 0)
-				{
-					LogPrint(eLogError, "Daemon: could not write pidfile: ", strerror(errno));
-					return false;
-				}
-			}
-
-			// 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()
-		{
-			i2p::fs::Remove(pidfile);
-
-			return Daemon_Singleton::stop();			
-		}
-	}
-}
-
-#endif

DaemonWin32.cpp

@@ -1,81 +0,0 @@
-#include "Config.h"
-#include "Daemon.h"
-#include "util.h"
-#include "Log.h"
-
-#ifdef _WIN32
-
-#include "./Win32/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::config::GetOption("svcctl", serviceControl);
-			if (serviceControl == "install")
-			{
-				LogPrint(eLogInfo, "WinSVC: installing ", SERVICE_NAME, " as service");
-				InstallService(
-					SERVICE_NAME,               // Name of service
-					SERVICE_DISPLAY_NAME,       // Name to display
-					SERVICE_START_TYPE,         // Service start type
-					SERVICE_DEPENDENCIES,       // Dependencies
-					SERVICE_ACCOUNT,            // Service running account
-					SERVICE_PASSWORD            // Password of the account
-					);
-				exit(0);
-			}
-			else if (serviceControl == "remove")
-			{
-				LogPrint(eLogInfo, "WinSVC: uninstalling ", SERVICE_NAME, " service");
-				UninstallService(SERVICE_NAME);
-				exit(0);
-			}
-			
-			if (isDaemon == 1)
-			{
-				LogPrint(eLogDebug, "Daemon: running as service");
-				I2PService service(SERVICE_NAME);
-				if (!I2PService::Run(service))
-				{
-					LogPrint(eLogError, "Daemon: Service failed to run w/err 0x%08lx\n", GetLastError());
-					exit(EXIT_FAILURE);
-				}
-				exit(EXIT_SUCCESS);
-			}
-			else
-				LogPrint(eLogDebug, "Daemon: running as user");
-
-			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

Datagram.cpp

@@ -1,144 +0,0 @@
-#include <string.h>
-#include <vector>
-#include <openssl/sha.h>
-#include <openssl/rand.h>
-#include "Log.h"
-#include "TunnelBase.h"
-#include "RouterContext.h"
-#include "Destination.h"
-#include "Datagram.h"
-
-namespace i2p
-{
-namespace datagram
-{
-	DatagramDestination::DatagramDestination (std::shared_ptr<i2p::client::ClientDestination> owner): 
-		m_Owner (owner), m_Receiver (nullptr)
-	{
-	}
-	
-	DatagramDestination::~DatagramDestination ()
-	{
-	}
-	
-	void DatagramDestination::SendDatagramTo (const uint8_t * payload, size_t len, const i2p::data::IdentHash& ident, uint16_t fromPort, uint16_t toPort)
-	{
-		uint8_t buf[MAX_DATAGRAM_SIZE];
-		auto identityLen = m_Owner->GetIdentity ()->ToBuffer (buf, MAX_DATAGRAM_SIZE);
-		uint8_t * signature = buf + identityLen;
-		auto signatureLen = m_Owner->GetIdentity ()->GetSignatureLen ();
-		uint8_t * buf1 = signature + signatureLen;
-		size_t headerLen = identityLen + signatureLen;
-		
-		memcpy (buf1, payload, len);	
-		if (m_Owner->GetIdentity ()->GetSigningKeyType () == i2p::data::SIGNING_KEY_TYPE_DSA_SHA1)
-		{
-			uint8_t hash[32];	
-			SHA256(buf1, len, hash);
-			m_Owner->Sign (hash, 32, signature);
-		}
-		else
-			m_Owner->Sign (buf1, len, signature);
-
-		auto msg = CreateDataMessage (buf, len + headerLen, fromPort, toPort); 
-		auto remote = m_Owner->FindLeaseSet (ident);
-		if (remote)
-			m_Owner->GetService ().post (std::bind (&DatagramDestination::SendMsg, this, msg, remote));
-		else
-			m_Owner->RequestDestination (ident, std::bind (&DatagramDestination::HandleLeaseSetRequestComplete, this, std::placeholders::_1, msg));
-	}
-
-	void DatagramDestination::HandleLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> remote, std::shared_ptr<I2NPMessage> msg)
-	{
-		if (remote)
-			SendMsg (msg, remote);
-	}	
-		
-	void DatagramDestination::SendMsg (std::shared_ptr<I2NPMessage> msg, std::shared_ptr<const i2p::data::LeaseSet> remote)
-	{
-		auto outboundTunnel = m_Owner->GetTunnelPool ()->GetNextOutboundTunnel ();
-		auto leases = remote->GetNonExpiredLeases ();
-		if (!leases.empty () && outboundTunnel)
-		{
-			std::vector<i2p::tunnel::TunnelMessageBlock> msgs;			
-			uint32_t i = rand () % leases.size ();
-			auto garlic = m_Owner->WrapMessage (remote, msg, true);
-			msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-				{ 
-					i2p::tunnel::eDeliveryTypeTunnel,
-					leases[i]->tunnelGateway, leases[i]->tunnelID,
-					garlic
-				});
-			outboundTunnel->SendTunnelDataMsg (msgs);
-		}
-		else
-		{
-			if (outboundTunnel)
-				LogPrint (eLogWarning, "Failed to send datagram. All leases expired");
-			else
-				LogPrint (eLogWarning, "Failed to send datagram. No outbound tunnels");
-		}	
-	}
-
-	void DatagramDestination::HandleDatagram (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
-	{
-		i2p::data::IdentityEx identity;
-		size_t identityLen = identity.FromBuffer (buf, len);
-		const uint8_t * signature = buf + identityLen;
-		size_t headerLen = identityLen + identity.GetSignatureLen ();
-
-		bool verified = false;
-		if (identity.GetSigningKeyType () == i2p::data::SIGNING_KEY_TYPE_DSA_SHA1)
-		{
-			uint8_t hash[32];
-			SHA256(buf + headerLen, len - headerLen, hash);
-			verified = identity.Verify (hash, 32, signature);
-		}	
-		else	
-			verified = identity.Verify (buf + headerLen, len - headerLen, signature);
-				
-		if (verified)
-		{
-			auto it = m_ReceiversByPorts.find (toPort);
-			if (it != m_ReceiversByPorts.end ())
-				it->second (identity, fromPort, toPort, buf + headerLen, len -headerLen);
-			else if (m_Receiver != nullptr)
-				m_Receiver (identity, fromPort, toPort, buf + headerLen, len -headerLen);
-			else
-				LogPrint (eLogWarning, "Receiver for datagram is not set");	
-		}
-		else
-			LogPrint (eLogWarning, "Datagram signature verification failed");	
-	}
-
-	void DatagramDestination::HandleDataMessagePayload (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
-	{
-		// unzip it
-		uint8_t uncompressed[MAX_DATAGRAM_SIZE];
-		size_t uncompressedLen = m_Inflator.Inflate (buf, len, uncompressed, MAX_DATAGRAM_SIZE);
-		if (uncompressedLen)
-			HandleDatagram (fromPort, toPort, uncompressed, uncompressedLen); 
-	}
-
-	std::shared_ptr<I2NPMessage> DatagramDestination::CreateDataMessage (const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort)
-	{
-		auto msg = NewI2NPMessage ();
-		uint8_t * buf = msg->GetPayload ();
-		buf += 4; // reserve for length
-		size_t size = m_Deflator.Deflate (payload, len, buf, msg->maxLen - msg->len);
-		if (size)
-		{
-			htobe32buf (msg->GetPayload (), size); // length
-			htobe16buf (buf + 4, fromPort); // source port
-			htobe16buf (buf + 6, toPort); // destination port 
-			buf[9] = i2p::client::PROTOCOL_TYPE_DATAGRAM; // datagram protocol
-			msg->len += size + 4; 
-			msg->FillI2NPMessageHeader (eI2NPData);
-		}	
-		else
-			msg = nullptr;
-		return msg;
-	}	
-}
-}
-

Datagram.h

@@ -1,61 +0,0 @@
-#ifndef DATAGRAM_H__
-#define DATAGRAM_H__
-
-#include <inttypes.h>
-#include <memory>
-#include <functional>
-#include <map>
-#include "Base.h"
-#include "Identity.h"
-#include "LeaseSet.h"
-#include "I2NPProtocol.h"
-
-namespace i2p
-{
-namespace client
-{
-	class ClientDestination;
-}
-namespace datagram
-{
-	const size_t MAX_DATAGRAM_SIZE = 32768;
-	class DatagramDestination
-	{
-		typedef std::function<void (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)> Receiver;
-
-		public:
-
-			DatagramDestination (std::shared_ptr<i2p::client::ClientDestination> owner);
-			~DatagramDestination ();				
-
-			void SendDatagramTo (const uint8_t * payload, size_t len, const i2p::data::IdentHash& ident, uint16_t fromPort = 0, uint16_t toPort = 0);
-			void HandleDataMessagePayload (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
-
-			void SetReceiver (const Receiver& receiver) { m_Receiver = receiver; };
-			void ResetReceiver () { m_Receiver = nullptr; };
-
-			void SetReceiver (const Receiver& receiver, uint16_t port) { m_ReceiversByPorts[port] = receiver; };
-			void ResetReceiver (uint16_t port) { m_ReceiversByPorts.erase (port); };
-
-		private:
-
-			void HandleLeaseSetRequestComplete (std::shared_ptr<i2p::data::LeaseSet> leaseSet, std::shared_ptr<I2NPMessage> msg);
-			
-			std::shared_ptr<I2NPMessage> CreateDataMessage (const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort);
-			void SendMsg (std::shared_ptr<I2NPMessage> msg, std::shared_ptr<const i2p::data::LeaseSet> remote);
-			void HandleDatagram (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
-
-		private:
-
-			std::shared_ptr<i2p::client::ClientDestination> m_Owner;
-			Receiver m_Receiver; // default
-			std::map<uint16_t, Receiver> m_ReceiversByPorts;
-
-			i2p::data::GzipInflator m_Inflator;
-			i2p::data::GzipDeflator m_Deflator;
-	};		
-}
-}
-
-#endif
-

Destination.cpp

@@ -1,784 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <boost/lexical_cast.hpp>
-#include <openssl/rand.h>
-
-#include "Log.h"
-#include "FS.h"
-#include "Crypto.h"
-#include "Timestamp.h"
-#include "NetDb.h"
-#include "Destination.h"
-
-namespace i2p
-{
-namespace client
-{
-	ClientDestination::ClientDestination (const i2p::data::PrivateKeys& keys, bool isPublic, 
-			const std::map<std::string, std::string> * params):
-		m_IsRunning (false), m_Thread (nullptr), m_Work (m_Service),	
-		m_Keys (keys), m_IsPublic (isPublic), m_PublishReplyToken (0),
-		m_DatagramDestination (nullptr), m_PublishConfirmationTimer (m_Service), 
-		m_PublishVerificationTimer (m_Service), m_CleanupTimer (m_Service)
-	{
-		if (m_IsPublic)	
-			PersistTemporaryKeys ();
-		else
-			i2p::crypto::GenerateElGamalKeyPair(m_EncryptionPrivateKey, m_EncryptionPublicKey);
-		int inboundTunnelLen = DEFAULT_INBOUND_TUNNEL_LENGTH;
-		int outboundTunnelLen = DEFAULT_OUTBOUND_TUNNEL_LENGTH;
-		int inboundTunnelsQuantity = DEFAULT_INBOUND_TUNNELS_QUANTITY;
-		int outboundTunnelsQuantity = DEFAULT_OUTBOUND_TUNNELS_QUANTITY;
-		int numTags = DEFAULT_TAGS_TO_SEND;
-		std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers;
-		if (params)
-		{
-			auto it = params->find (I2CP_PARAM_INBOUND_TUNNEL_LENGTH);
-			if (it != params->end ())
-			{	
-				int len = boost::lexical_cast<int>(it->second);
-				if (len > 0)
-				{
-					inboundTunnelLen = len;
-					LogPrint (eLogInfo, "Destination: Inbound tunnel length set to ", len);
-				}
-			}	
-			it = params->find (I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH);
-			if (it != params->end ())
-			{
-				int len = boost::lexical_cast<int>(it->second);
-				if (len > 0)
-				{
-					outboundTunnelLen = len;
-					LogPrint (eLogInfo, "Destination: Outbound tunnel length set to ", len);
-				}
-			}	
-			it = params->find (I2CP_PARAM_INBOUND_TUNNELS_QUANTITY);
-			if (it != params->end ())
-			{
-				int quantity = boost::lexical_cast<int>(it->second);
-				if (quantity > 0)
-				{
-					inboundTunnelsQuantity = quantity;
-					LogPrint (eLogInfo, "Destination: Inbound tunnels quantity set to ", quantity);
-				}	
-			}
-			it = params->find (I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY);
-			if (it != params->end ())
-			{
-				int quantity = boost::lexical_cast<int>(it->second);
-				if (quantity > 0)
-				{
-					outboundTunnelsQuantity = quantity;
-					LogPrint (eLogInfo, "Destination: Outbound tunnels quantity set to ", quantity);
-				}	
-			}
-			it = params->find (I2CP_PARAM_TAGS_TO_SEND);
-			if (it != params->end ())
-			{
-				int tagsToSend = boost::lexical_cast<int>(it->second);
-				if (tagsToSend > 0)
-				{
-					numTags = tagsToSend;
-					LogPrint (eLogInfo, "Destination: Tags to send set to  ", tagsToSend);
-				}	
-			}	
-			it = params->find (I2CP_PARAM_EXPLICIT_PEERS);
-			if (it != params->end ())
-			{
-				explicitPeers = std::make_shared<std::vector<i2p::data::IdentHash> >();
-				std::stringstream ss(it->second);
-				std::string b64;
-				while (std::getline (ss, b64, ','))
-				{
-					i2p::data::IdentHash ident;
-					ident.FromBase64 (b64);
-					explicitPeers->push_back (ident);
-				}
-				LogPrint (eLogInfo, "Destination: Explicit peers set to ", it->second);
-			}
-		}	
-		SetNumTags (numTags);
-		m_Pool = i2p::tunnel::tunnels.CreateTunnelPool (inboundTunnelLen, outboundTunnelLen, inboundTunnelsQuantity, outboundTunnelsQuantity);  
-		if (explicitPeers)
-			m_Pool->SetExplicitPeers (explicitPeers);
-		if (m_IsPublic)
-			LogPrint (eLogInfo, "Destination: Local address ", GetIdentHash().ToBase32 (), " created");
-	}
-
-	ClientDestination::~ClientDestination ()
-	{
-		if (m_IsRunning)	
-			Stop ();
-		for (auto it: m_LeaseSetRequests)
-			if (it.second->requestComplete) it.second->requestComplete (nullptr);
-		m_LeaseSetRequests.clear ();
-		if (m_Pool)
-			i2p::tunnel::tunnels.DeleteTunnelPool (m_Pool);		
-		if (m_DatagramDestination)
-			delete m_DatagramDestination;
-	}	
-
-	void ClientDestination::Run ()
-	{
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_Service.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Destination: runtime exception: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void ClientDestination::Start ()
-	{	
-		if (!m_IsRunning)
-		{	
-			m_IsRunning = true;
-			m_Pool->SetLocalDestination (shared_from_this ());
-			m_Pool->SetActive (true);			
-			m_Thread = new std::thread (std::bind (&ClientDestination::Run, shared_from_this ()));
-			m_StreamingDestination = std::make_shared<i2p::stream::StreamingDestination> (shared_from_this ()); // TODO:
-			m_StreamingDestination->Start ();	
-			for (auto it: m_StreamingDestinationsByPorts)
-				it.second->Start ();
-			
-			m_CleanupTimer.expires_from_now (boost::posix_time::minutes (DESTINATION_CLEANUP_TIMEOUT));
-			m_CleanupTimer.async_wait (std::bind (&ClientDestination::HandleCleanupTimer,
-				shared_from_this (), std::placeholders::_1));
-		}	
-	}
-		
-	void ClientDestination::Stop ()
-	{	
-		if (m_IsRunning)
-		{	
-			m_CleanupTimer.cancel ();
-			m_PublishConfirmationTimer.cancel ();
-			m_PublishVerificationTimer.cancel ();
-			m_IsRunning = false;
-			m_StreamingDestination->Stop ();
-			m_StreamingDestination = nullptr;
-			for (auto it: m_StreamingDestinationsByPorts)
-				it.second->Stop ();
-			if (m_DatagramDestination)
-			{
-				auto d = m_DatagramDestination;
-				m_DatagramDestination = nullptr;
-				delete d;
-			}	
-			if (m_Pool)
-			{	
-				m_Pool->SetLocalDestination (nullptr);
-				i2p::tunnel::tunnels.StopTunnelPool (m_Pool);
-			}	
-			m_Service.stop ();
-			if (m_Thread)
-			{	
-				m_Thread->join (); 
-				delete m_Thread;
-				m_Thread = 0;
-			}	
-		}	
-	}	
-
-	std::shared_ptr<const i2p::data::LeaseSet> ClientDestination::FindLeaseSet (const i2p::data::IdentHash& ident)
-	{
-		auto it = m_RemoteLeaseSets.find (ident);
-		if (it != m_RemoteLeaseSets.end ())
-		{	
-			if (!it->second->IsExpired ())
-				return it->second;
-			else
-				LogPrint (eLogWarning, "Destination: remote LeaseSet expired");
-		}	
-		else
-		{	
-			auto ls = i2p::data::netdb.FindLeaseSet (ident);
-			if (ls && !ls->IsExpired ())
-			{
-				ls->PopulateLeases (); // since we don't store them in netdb
-				m_RemoteLeaseSets[ident] = ls;			
-				return ls;
-			}	
-		}
-		return nullptr;
-	}	
-
-	std::shared_ptr<const i2p::data::LeaseSet> ClientDestination::GetLeaseSet ()
-	{
-		if (!m_Pool) return nullptr;
-		if (!m_LeaseSet)
-			UpdateLeaseSet ();
-		return m_LeaseSet;
-	}	
-
-	void ClientDestination::UpdateLeaseSet ()
-	{
-		m_LeaseSet.reset (new i2p::data::LeaseSet (m_Pool));
-	}	
-
-	bool ClientDestination::SubmitSessionKey (const uint8_t * key, const uint8_t * tag)
-	{
-		struct
-		{
-			uint8_t k[32], t[32];
-		} data;	
-		memcpy (data.k, key, 32);
-		memcpy (data.t, tag, 32);
-		auto s = shared_from_this ();
-		m_Service.post ([s,data](void)
-			{
-				s->AddSessionKey (data.k, data.t);
-			});
-		return true;
-	}
-
-	void ClientDestination::ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		m_Service.post (std::bind (&ClientDestination::HandleGarlicMessage, shared_from_this (), msg)); 
-	}
-
-	void ClientDestination::ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		m_Service.post (std::bind (&ClientDestination::HandleDeliveryStatusMessage, shared_from_this (), msg)); 
-	}
-
-	void ClientDestination::HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		uint8_t typeID = buf[I2NP_HEADER_TYPEID_OFFSET];
-		switch (typeID)
-		{	
-			case eI2NPData:
-				HandleDataMessage (buf + I2NP_HEADER_SIZE, bufbe16toh (buf + I2NP_HEADER_SIZE_OFFSET));
-			break;
-			case eI2NPDeliveryStatus:
-				// we assume tunnel tests non-encrypted
-				HandleDeliveryStatusMessage (CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from));
-			break;	
-			case eI2NPDatabaseStore:
-				HandleDatabaseStoreMessage (buf + I2NP_HEADER_SIZE, bufbe16toh (buf + I2NP_HEADER_SIZE_OFFSET));
-			break;
-			case eI2NPDatabaseSearchReply:
-				HandleDatabaseSearchReplyMessage (buf + I2NP_HEADER_SIZE, bufbe16toh (buf + I2NP_HEADER_SIZE_OFFSET));
-			break;	
-			default:
-				i2p::HandleI2NPMessage (CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from));
-		}		
-	}	
-
-	void ClientDestination::HandleDatabaseStoreMessage (const uint8_t * buf, size_t len)
-	{
-		uint32_t replyToken = bufbe32toh (buf + DATABASE_STORE_REPLY_TOKEN_OFFSET);
-		size_t offset = DATABASE_STORE_HEADER_SIZE;
-		if (replyToken) 
-		{
-			LogPrint (eLogInfo, "Destination: Reply token is ignored for DatabaseStore");
-			offset += 36;
-		}
-		std::shared_ptr<i2p::data::LeaseSet> leaseSet;
-		if (buf[DATABASE_STORE_TYPE_OFFSET] == 1) // LeaseSet
-		{
-			LogPrint (eLogDebug, "Remote LeaseSet");
-			auto it = m_RemoteLeaseSets.find (buf + DATABASE_STORE_KEY_OFFSET);
-			if (it != m_RemoteLeaseSets.end ())
-			{
-				leaseSet = it->second;
-				if (leaseSet->IsNewer (buf + offset, len - offset))
-				{	
-					leaseSet->Update (buf + offset, len - offset); 
-					if (leaseSet->IsValid ())
-						LogPrint (eLogDebug, "Remote LeaseSet updated");
-					else
-					{
-						LogPrint (eLogDebug, "Remote LeaseSet update failed");
-						m_RemoteLeaseSets.erase (it);
-						leaseSet = nullptr;
-					}
-				}
-				else
-					LogPrint (eLogDebug, "Remote LeaseSet is older. Not updated");
-			}
-			else
-			{	
-				leaseSet = std::make_shared<i2p::data::LeaseSet> (buf + offset, len - offset);
-				if (leaseSet->IsValid ())
-				{
-					if (leaseSet->GetIdentHash () != GetIdentHash ())
-					{
-						LogPrint (eLogDebug, "New remote LeaseSet added");
-						m_RemoteLeaseSets[buf + DATABASE_STORE_KEY_OFFSET] = leaseSet;
-					}
-					else
-						LogPrint (eLogDebug, "Own remote LeaseSet dropped");
-				}
-				else
-				{
-					LogPrint (eLogError, "New remote LeaseSet failed");
-					leaseSet = nullptr;
-				}
-			}	
-		}	
-		else
-			LogPrint (eLogError, "Destination: Unexpected client's DatabaseStore type ", buf[DATABASE_STORE_TYPE_OFFSET], ", dropped");
-		
-		auto it1 = m_LeaseSetRequests.find (buf + DATABASE_STORE_KEY_OFFSET);
-		if (it1 != m_LeaseSetRequests.end ())
-		{
-			it1->second->requestTimeoutTimer.cancel ();
-			if (it1->second->requestComplete) it1->second->requestComplete (leaseSet);
-			m_LeaseSetRequests.erase (it1);
-		}	
-	}
-
-	void ClientDestination::HandleDatabaseSearchReplyMessage (const uint8_t * buf, size_t len)
-	{
-		i2p::data::IdentHash key (buf);
-		int num = buf[32]; // num
-		LogPrint (eLogDebug, "Destination: DatabaseSearchReply for ", key.ToBase64 (), " num=", num);
-		auto it = m_LeaseSetRequests.find (key);
-		if (it != m_LeaseSetRequests.end ())
-		{
-			auto request = it->second;
-			bool found = false;
-			if (request->excluded.size () < MAX_NUM_FLOODFILLS_PER_REQUEST)
-			{	
-				for (int i = 0; i < num; i++)
-				{
-					i2p::data::IdentHash peerHash (buf + 33 + i*32);
-					auto floodfill = i2p::data::netdb.FindRouter (peerHash);
-					if (floodfill)
-					{
-						LogPrint (eLogInfo, "Destination: Requesting ", key.ToBase64 (), " at ", peerHash.ToBase64 ());
-						if (SendLeaseSetRequest (key, floodfill, request))
-							found = true;
-					}	
-					else
-					{	
-						LogPrint (eLogInfo, "Destination: Found new floodfill, request it"); // TODO: recheck this message
-						i2p::data::netdb.RequestDestination (peerHash);
-					}	
-				}
-				if (!found)
-					LogPrint (eLogError, "Destination: Suggested floodfills are not presented in netDb");
-			}	
-			else
-				LogPrint (eLogInfo, "Destination: ", key.ToBase64 (), " was not found on ", MAX_NUM_FLOODFILLS_PER_REQUEST, " floodfills");
-			if (!found)
-			{
-				if (request->requestComplete) request->requestComplete (nullptr);
-				m_LeaseSetRequests.erase (key);
-			}	
-		}	
-		else	
-			LogPrint (eLogWarning, "Destination: Request for ", key.ToBase64 (), " not found");
-	}	
-		
-	void ClientDestination::HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		uint32_t msgID = bufbe32toh (msg->GetPayload () + DELIVERY_STATUS_MSGID_OFFSET);
-		if (msgID == m_PublishReplyToken)
-		{
-			LogPrint (eLogDebug, "Destination: Publishing LeaseSet confirmed");
-			m_ExcludedFloodfills.clear ();
-			m_PublishReplyToken = 0;
-			// schedule verification
-			m_PublishVerificationTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_VERIFICATION_TIMEOUT));
-			m_PublishVerificationTimer.async_wait (std::bind (&ClientDestination::HandlePublishVerificationTimer,
-			shared_from_this (), std::placeholders::_1));	
-		}
-		else
-			i2p::garlic::GarlicDestination::HandleDeliveryStatusMessage (msg);
-	}	
-
-	void ClientDestination::SetLeaseSetUpdated ()
-	{
-		i2p::garlic::GarlicDestination::SetLeaseSetUpdated ();	
-		UpdateLeaseSet ();
-		if (m_IsPublic)
-		{
-			m_PublishVerificationTimer.cancel ();
-			Publish ();
-		}
-	}
-		
-	void ClientDestination::Publish ()
-	{	
-		if (!m_LeaseSet || !m_Pool) 
-		{
-			LogPrint (eLogError, "Destination: Can't publish non-existing LeaseSet");
-			return;
-		}
-		if (m_PublishReplyToken)
-		{
-			LogPrint (eLogDebug, "Destination: Publishing LeaseSet is pending");
-			return;
-		}
-		auto outbound = m_Pool->GetNextOutboundTunnel ();
-		if (!outbound)
-		{
-			LogPrint (eLogError, "Destination: Can't publish LeaseSet. No outbound tunnels");
-			return;
-		}
-		auto floodfill = i2p::data::netdb.GetClosestFloodfill (m_LeaseSet->GetIdentHash (), m_ExcludedFloodfills);	
-		if (!floodfill)
-		{
-			LogPrint (eLogError, "Destination: Can't publish LeaseSet, no more floodfills found");
-			m_ExcludedFloodfills.clear ();
-			return;
-		}	
-		m_ExcludedFloodfills.insert (floodfill->GetIdentHash ());
-		LogPrint (eLogDebug, "Destination: Publish LeaseSet of ", GetIdentHash ().ToBase32 ());
-		RAND_bytes ((uint8_t *)&m_PublishReplyToken, 4);
-		auto msg = WrapMessage (floodfill, i2p::CreateDatabaseStoreMsg (m_LeaseSet, m_PublishReplyToken));			
-		m_PublishConfirmationTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_CONFIRMATION_TIMEOUT));
-		m_PublishConfirmationTimer.async_wait (std::bind (&ClientDestination::HandlePublishConfirmationTimer,
-			shared_from_this (), std::placeholders::_1));	
-		outbound->SendTunnelDataMsg (floodfill->GetIdentHash (), 0, msg);	
-	}
-
-	void ClientDestination::HandlePublishConfirmationTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{	
-			if (m_PublishReplyToken)
-			{
-				LogPrint (eLogWarning, "Destination: Publish confirmation was not received in ", PUBLISH_CONFIRMATION_TIMEOUT,  " seconds, will try again");
-				m_PublishReplyToken = 0;
-				Publish ();
-			}
-		}
-	}
-
-	void ClientDestination::HandlePublishVerificationTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{	
-			auto s = shared_from_this ();
-			RequestLeaseSet (GetIdentHash (), 
-				// "this" added due to bug in gcc 4.7-4.8
-				[s,this](std::shared_ptr<i2p::data::LeaseSet> leaseSet)
-				{
-					if (leaseSet)
-					{
-						if (s->m_LeaseSet && *s->m_LeaseSet == *leaseSet)
-						{
-							// we got latest LeasetSet
-							LogPrint (eLogDebug, "Destination: published LeaseSet verified");
-							s->m_PublishVerificationTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_REGULAR_VERIFICATION_INTERNAL));
-							s->m_PublishVerificationTimer.async_wait (std::bind (&ClientDestination::HandlePublishVerificationTimer, s, std::placeholders::_1));	
-							return;
-						}		
-					}	
-					else
-						LogPrint (eLogWarning, "Destination: couldn't find published LeaseSet");
-					// we have to publish again
-					s->Publish ();	
-				});
-		}
-	}
-
-	void ClientDestination::HandleDataMessage (const uint8_t * buf, size_t len)
-	{
-		uint32_t length = bufbe32toh (buf);
-		buf += 4;
-		// we assume I2CP payload
-		uint16_t fromPort = bufbe16toh (buf + 4), // source
-			toPort = bufbe16toh (buf + 6); // destination 
-		switch (buf[9])
-		{
-			case PROTOCOL_TYPE_STREAMING:
-			{
-				// streaming protocol
-				auto dest = GetStreamingDestination (toPort);
-				if (dest)
-					dest->HandleDataMessagePayload (buf, length);
-				else
-					LogPrint (eLogError, "Destination: Missing streaming destination");
-			}
-			break;
-			case PROTOCOL_TYPE_DATAGRAM:
-				// datagram protocol
-				if (m_DatagramDestination)
-					m_DatagramDestination->HandleDataMessagePayload (fromPort, toPort, buf, length);
-				else
-					LogPrint (eLogError, "Destination: Missing datagram destination");
-			break;
-			default:
-				LogPrint (eLogError, "Destination: Data: unexpected protocol ", buf[9]);
-		}
-	}	
-
-	void ClientDestination::CreateStream (StreamRequestComplete streamRequestComplete, const i2p::data::IdentHash& dest, int port) 
-	{
-		if (!streamRequestComplete) 
-		{
-			LogPrint (eLogError, "Destination: request callback is not specified in CreateStream");
-			return;
-		}	
-		auto leaseSet = FindLeaseSet (dest);
-		if (leaseSet)
-			streamRequestComplete(CreateStream (leaseSet, port));
-		else
-		{
-			auto s = shared_from_this ();
-			RequestDestination (dest,
-				[s, streamRequestComplete, port](std::shared_ptr<i2p::data::LeaseSet> ls)
-				{
-					if (ls)
-						streamRequestComplete(s->CreateStream (ls, port));
-					else
-						streamRequestComplete (nullptr);
-				});
-		}
-	}
-
-	std::shared_ptr<i2p::stream::Stream> ClientDestination::CreateStream (std::shared_ptr<const i2p::data::LeaseSet> remote, int port)
-	{
-		if (m_StreamingDestination)
-			return m_StreamingDestination->CreateNewOutgoingStream (remote, port);
-		else
-			return nullptr;
-	}
-
-	std::shared_ptr<i2p::stream::StreamingDestination> ClientDestination::GetStreamingDestination (int port) const 
-	{ 
-		if (port) 
-		{
-			auto it = m_StreamingDestinationsByPorts.find (port);
-			if (it != m_StreamingDestinationsByPorts.end ())
-				return it->second;
-		}	
-		// if port is zero or not found, use default destination
-		return m_StreamingDestination; 
-	}
-		
-	void ClientDestination::AcceptStreams (const i2p::stream::StreamingDestination::Acceptor& acceptor)
-	{
-		if (m_StreamingDestination)
-			m_StreamingDestination->SetAcceptor (acceptor);
-	}
-
-	void ClientDestination::StopAcceptingStreams ()
-	{
-		if (m_StreamingDestination)
-			m_StreamingDestination->ResetAcceptor ();
-	}
-		
-	bool ClientDestination::IsAcceptingStreams () const
-	{
-		if (m_StreamingDestination)
-			return m_StreamingDestination->IsAcceptorSet ();
-		return false;
-	}	
-
-	std::shared_ptr<i2p::stream::StreamingDestination> ClientDestination::CreateStreamingDestination (int port, bool gzip)
-	{
-		auto dest = std::make_shared<i2p::stream::StreamingDestination> (shared_from_this (), port, gzip); 
-		if (port)
-			m_StreamingDestinationsByPorts[port] = dest;
-		else // update default 
-			m_StreamingDestination = dest;
-		return dest;
-	}	
-		
-	i2p::datagram::DatagramDestination * ClientDestination::CreateDatagramDestination ()
-	{
-		if (!m_DatagramDestination)
-			m_DatagramDestination = new i2p::datagram::DatagramDestination (shared_from_this ());
-		return m_DatagramDestination;	
-	}
-
-	bool ClientDestination::RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete)
-	{
-		if (!m_Pool || !IsReady ()) 
-		{	
-			if (requestComplete) requestComplete (nullptr);
-			return false;
-		}	
-		m_Service.post (std::bind (&ClientDestination::RequestLeaseSet, shared_from_this (), dest, requestComplete));
-		return true;
-	}
-
-	void ClientDestination::CancelDestinationRequest (const i2p::data::IdentHash& dest)
-	{
-		auto s = shared_from_this ();
-		m_Service.post ([dest, s](void)
-			{
-				auto it = s->m_LeaseSetRequests.find (dest);
-				if (it != s->m_LeaseSetRequests.end ())
-				{	
-					auto requestComplete = it->second->requestComplete; 
-					s->m_LeaseSetRequests.erase (it);
-					if (requestComplete) requestComplete (nullptr);
-				}	
-			});				
-	}
-		
-	void ClientDestination::RequestLeaseSet (const i2p::data::IdentHash& dest, RequestComplete requestComplete)
-	{
-		std::set<i2p::data::IdentHash> excluded;
-		auto floodfill = i2p::data::netdb.GetClosestFloodfill (dest, excluded);
-		if (floodfill)
-		{
-			auto request = std::make_shared<LeaseSetRequest> (m_Service);
-			request->requestComplete = requestComplete;
-			auto ret = m_LeaseSetRequests.insert (std::pair<i2p::data::IdentHash, std::shared_ptr<LeaseSetRequest> >(dest,request));
-			if (ret.second) // inserted
-			{
-				if (!SendLeaseSetRequest (dest, floodfill, request))
-				{
-					// request failed
-					m_LeaseSetRequests.erase (dest);
-					if (request->requestComplete) request->requestComplete (nullptr);
-				}
-			}	
-			else // duplicate
-			{
-				LogPrint (eLogWarning, "Destination: Request of LeaseSet ", dest.ToBase64 (), " is pending already");
-				// TODO: queue up requests
-				if (request->requestComplete) request->requestComplete (nullptr);
-			}	
-		}	
-		else
-		{	
-			LogPrint (eLogError, "Destination: Can't request LeaseSet, no floodfills found");
-			if (requestComplete) requestComplete (nullptr);
-		}	
-	}	
-		
-	bool ClientDestination::SendLeaseSetRequest (const i2p::data::IdentHash& dest, 
-		std::shared_ptr<const i2p::data::RouterInfo>  nextFloodfill, std::shared_ptr<LeaseSetRequest> request)
-	{
-		if (!request->replyTunnel || !request->replyTunnel->IsEstablished ())
-			request->replyTunnel = m_Pool->GetNextInboundTunnel ();
-		if (!request->replyTunnel) LogPrint (eLogError, "Destination: Can't send LeaseSet request, no inbound tunnels found");
-		if (!request->outboundTunnel || !request->outboundTunnel->IsEstablished ())
-			request->outboundTunnel = m_Pool->GetNextOutboundTunnel ();
-		if (!request->outboundTunnel) LogPrint (eLogError, "Destination: Can't send LeaseSet request, no outbound tunnels found");
-			
-		if (request->replyTunnel && request->outboundTunnel)
-		{	
-			request->excluded.insert (nextFloodfill->GetIdentHash ());
-			request->requestTime = i2p::util::GetSecondsSinceEpoch ();
-			request->requestTimeoutTimer.cancel ();
-
-			uint8_t replyKey[32], replyTag[32];
-			RAND_bytes (replyKey, 32); // random session key 
-			RAND_bytes (replyTag, 32); // random session tag
-			AddSessionKey (replyKey, replyTag);
-
-			auto msg = WrapMessage (nextFloodfill,
-				CreateLeaseSetDatabaseLookupMsg (dest, request->excluded, 
-					request->replyTunnel, replyKey, replyTag));
-			request->outboundTunnel->SendTunnelDataMsg (
-				{
-					i2p::tunnel::TunnelMessageBlock 
-					{ 
-						i2p::tunnel::eDeliveryTypeRouter,
-						nextFloodfill->GetIdentHash (), 0, msg
-					}
-				});	
-			request->requestTimeoutTimer.expires_from_now (boost::posix_time::seconds(LEASESET_REQUEST_TIMEOUT));
-			request->requestTimeoutTimer.async_wait (std::bind (&ClientDestination::HandleRequestTimoutTimer,
-				shared_from_this (), std::placeholders::_1, dest));
-		}	
-		else
-			return false;
-		return true;
-	}	
-
-	void ClientDestination::HandleRequestTimoutTimer (const boost::system::error_code& ecode, const i2p::data::IdentHash& dest)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			auto it = m_LeaseSetRequests.find (dest);
-			if (it != m_LeaseSetRequests.end ())
-			{
-				bool done = false;
-				uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-				if (ts < it->second->requestTime + MAX_LEASESET_REQUEST_TIMEOUT)
-				{
-					auto floodfill = i2p::data::netdb.GetClosestFloodfill (dest, it->second->excluded);
-					if (floodfill)
-					{
-						// reset tunnels, because one them might fail
-						it->second->outboundTunnel = nullptr;
-						it->second->replyTunnel = nullptr;		
-						done = !SendLeaseSetRequest (dest, floodfill, it->second);
-					}
-					else
-						done = true;
-				}
-				else
-				{	
-					LogPrint (eLogWarning, "Destination: ", dest.ToBase64 (), " was not found within ",  MAX_LEASESET_REQUEST_TIMEOUT, " seconds");
-					done = true;
-				}
-				
-				if (done)
-				{
-					auto requestComplete = it->second->requestComplete; 
-					m_LeaseSetRequests.erase (it);
-					if (requestComplete) requestComplete (nullptr);
-				}	
-			}	
-		}	
-	}
-
-	void ClientDestination::HandleCleanupTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			CleanupExpiredTags ();
-			CleanupRemoteLeaseSets ();
-			m_CleanupTimer.expires_from_now (boost::posix_time::minutes (DESTINATION_CLEANUP_TIMEOUT));
-			m_CleanupTimer.async_wait (std::bind (&ClientDestination::HandleCleanupTimer,
-				shared_from_this (), std::placeholders::_1));
-		}
-	}	
-
-	void ClientDestination::CleanupRemoteLeaseSets ()
-	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		for (auto it = m_RemoteLeaseSets.begin (); it != m_RemoteLeaseSets.end ();)
-		{
-			if (it->second->IsEmpty () || ts > it->second->GetExpirationTime ()) // leaseset expired
-			{
-				LogPrint (eLogWarning, "Destination: Remote LeaseSet ", it->second->GetIdentHash ().ToBase64 (), " expired");
-				it = m_RemoteLeaseSets.erase (it);
-			}	
-			else 
-				it++;
-		}
-	}
-
-	void ClientDestination::PersistTemporaryKeys ()
-	{
-		std::string ident = GetIdentHash().ToBase32();
-		std::string path  = i2p::fs::DataDirPath("destinations", (ident + ".dat"));
-		std::ifstream f(path, std::ifstream::binary);
-
-		if (f) {
-			f.read ((char *)m_EncryptionPublicKey,  256);
-			f.read ((char *)m_EncryptionPrivateKey, 256);
-			return;
-		}
-
-		LogPrint (eLogInfo, "Destination: Creating new temporary keys for address ", ident, ".b32.i2p");
-		i2p::crypto::GenerateElGamalKeyPair(m_EncryptionPrivateKey, m_EncryptionPublicKey);
-
-		std::ofstream f1 (path, std::ofstream::binary | std::ofstream::out);
-		if (f1) {
-			f1.write ((char *)m_EncryptionPublicKey,  256);
-			f1.write ((char *)m_EncryptionPrivateKey, 256);
-			return;
-		}
-		LogPrint(eLogError, "Destinations: Can't save keys to ", path);
-	}
-}
-}

Destination.h

@@ -1,166 +0,0 @@
-#ifndef DESTINATION_H__
-#define DESTINATION_H__
-
-#include <thread>
-#include <mutex>
-#include <memory>
-#include <map>
-#include <set>
-#include <string>
-#include <functional>
-#include <boost/asio.hpp>
-#include "Identity.h"
-#include "TunnelPool.h"
-#include "Crypto.h"
-#include "LeaseSet.h"
-#include "Garlic.h"
-#include "NetDb.h"
-#include "Streaming.h"
-#include "Datagram.h"
-
-namespace i2p
-{
-namespace client
-{
-	const uint8_t PROTOCOL_TYPE_STREAMING = 6;
-	const uint8_t PROTOCOL_TYPE_DATAGRAM = 17;
-	const uint8_t PROTOCOL_TYPE_RAW = 18;	
-	const int PUBLISH_CONFIRMATION_TIMEOUT = 5; // in seconds
-	const int PUBLISH_VERIFICATION_TIMEOUT = 10; // in seconds after successfull publish
-	const int PUBLISH_REGULAR_VERIFICATION_INTERNAL = 100; // in seconds periodically	
-	const int LEASESET_REQUEST_TIMEOUT = 5; // in seconds
-	const int MAX_LEASESET_REQUEST_TIMEOUT = 40; // in seconds
-	const int DESTINATION_CLEANUP_TIMEOUT = 3; // in minutes 
-	const unsigned int MAX_NUM_FLOODFILLS_PER_REQUEST = 7;
-	
-	// I2CP
-	const char I2CP_PARAM_INBOUND_TUNNEL_LENGTH[] = "inbound.length";
-	const int DEFAULT_INBOUND_TUNNEL_LENGTH = 3;
-	const char I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH[] = "outbound.length";
-	const int DEFAULT_OUTBOUND_TUNNEL_LENGTH = 3;
-	const char I2CP_PARAM_INBOUND_TUNNELS_QUANTITY[] = "inbound.quantity";
-	const int DEFAULT_INBOUND_TUNNELS_QUANTITY = 5;
-	const char I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY[] = "outbound.quantity";
-	const int DEFAULT_OUTBOUND_TUNNELS_QUANTITY = 5;
-	const char I2CP_PARAM_EXPLICIT_PEERS[] = "explicitPeers";
-	const int STREAM_REQUEST_TIMEOUT = 60; //in seconds
-	const char I2CP_PARAM_TAGS_TO_SEND[] = "crypto.tagsToSend";
-	const int DEFAULT_TAGS_TO_SEND = 40;
-
-	typedef std::function<void (std::shared_ptr<i2p::stream::Stream> stream)> StreamRequestComplete;
-
-	class ClientDestination: public i2p::garlic::GarlicDestination,
-		public std::enable_shared_from_this<ClientDestination>
-	{
-		typedef std::function<void (std::shared_ptr<i2p::data::LeaseSet> leaseSet)> RequestComplete;
-		// leaseSet = nullptr means not found
-		struct LeaseSetRequest
-		{
-			LeaseSetRequest (boost::asio::io_service& service): requestTime (0), requestTimeoutTimer (service) {};
-			std::set<i2p::data::IdentHash> excluded;
-			uint64_t requestTime;
-			boost::asio::deadline_timer requestTimeoutTimer;
-			RequestComplete requestComplete;
-			std::shared_ptr<i2p::tunnel::OutboundTunnel> outboundTunnel;
-			std::shared_ptr<i2p::tunnel::InboundTunnel> replyTunnel;
-		};	
-		
-		
-		public:
-
-			ClientDestination (const i2p::data::PrivateKeys& keys, bool isPublic, const std::map<std::string, std::string> * params = nullptr);
-			~ClientDestination ();	
-
-			virtual void Start ();
-			virtual void Stop ();
-			bool IsRunning () const { return m_IsRunning; };
-			boost::asio::io_service& GetService () { return m_Service; };
-			std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () { return m_Pool; }; 
-			bool IsReady () const { return m_LeaseSet && !m_LeaseSet->IsExpired () && m_Pool->GetOutboundTunnels ().size () > 0; };
-			std::shared_ptr<const i2p::data::LeaseSet> FindLeaseSet (const i2p::data::IdentHash& ident);
-			bool RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete = nullptr);
-			void CancelDestinationRequest (const i2p::data::IdentHash& dest);	
-			
-			// streaming
-			std::shared_ptr<i2p::stream::StreamingDestination> CreateStreamingDestination (int port, bool gzip = true); // additional
-			std::shared_ptr<i2p::stream::StreamingDestination> GetStreamingDestination (int port = 0) const;
-			// following methods operate with default streaming destination
-			void CreateStream (StreamRequestComplete streamRequestComplete, const i2p::data::IdentHash& dest, int port = 0);
-			std::shared_ptr<i2p::stream::Stream> CreateStream (std::shared_ptr<const i2p::data::LeaseSet> remote, int port = 0);
-			void AcceptStreams (const i2p::stream::StreamingDestination::Acceptor& acceptor);
-			void StopAcceptingStreams ();
-			bool IsAcceptingStreams () const;
-			
-			// datagram
-			i2p::datagram::DatagramDestination * GetDatagramDestination () const { return m_DatagramDestination; };
-			i2p::datagram::DatagramDestination * CreateDatagramDestination ();
-
-			// implements LocalDestination
-			const i2p::data::PrivateKeys& GetPrivateKeys () const { return m_Keys; };
-			const uint8_t * GetEncryptionPrivateKey () const { return m_EncryptionPrivateKey; };
-			const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionPublicKey; };
-			
-			// implements GarlicDestination
-			std::shared_ptr<const i2p::data::LeaseSet> GetLeaseSet ();
-			std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () const { return m_Pool; }
-			void HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from);
-
-			// override GarlicDestination
-			bool SubmitSessionKey (const uint8_t * key, const uint8_t * tag);
-			void ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg);
-			void ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);	
-			void SetLeaseSetUpdated ();
-
-			// I2CP
-			void HandleDataMessage (const uint8_t * buf, size_t len);
-
-		private:
-				
-			void Run ();			
-			void UpdateLeaseSet ();
-			void Publish ();
-			void HandlePublishConfirmationTimer (const boost::system::error_code& ecode);
-			void HandlePublishVerificationTimer (const boost::system::error_code& ecode);
-			void HandleDatabaseStoreMessage (const uint8_t * buf, size_t len);
-			void HandleDatabaseSearchReplyMessage (const uint8_t * buf, size_t len);
-			void HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);		
-
-			void RequestLeaseSet (const i2p::data::IdentHash& dest, RequestComplete requestComplete);
-			bool SendLeaseSetRequest (const i2p::data::IdentHash& dest, std::shared_ptr<const i2p::data::RouterInfo>  nextFloodfill, std::shared_ptr<LeaseSetRequest> request);	
-			void HandleRequestTimoutTimer (const boost::system::error_code& ecode, const i2p::data::IdentHash& dest);
-			void HandleCleanupTimer (const boost::system::error_code& ecode);
-			void CleanupRemoteLeaseSets ();
-			void PersistTemporaryKeys ();			
-
-		private:
-
-			volatile bool m_IsRunning;
-			std::thread * m_Thread;	
-			boost::asio::io_service m_Service;
-			boost::asio::io_service::work m_Work;
-			i2p::data::PrivateKeys m_Keys;
-			uint8_t m_EncryptionPublicKey[256], m_EncryptionPrivateKey[256];
-			std::map<i2p::data::IdentHash, std::shared_ptr<i2p::data::LeaseSet> > m_RemoteLeaseSets;
-			std::map<i2p::data::IdentHash, std::shared_ptr<LeaseSetRequest> > m_LeaseSetRequests;
-
-			std::shared_ptr<i2p::tunnel::TunnelPool> m_Pool;
-			std::shared_ptr<i2p::data::LeaseSet> m_LeaseSet;
-			bool m_IsPublic;
-			uint32_t m_PublishReplyToken;
-			std::set<i2p::data::IdentHash> m_ExcludedFloodfills; // for publishing
-			
-			std::shared_ptr<i2p::stream::StreamingDestination> m_StreamingDestination; // default
-			std::map<uint16_t, std::shared_ptr<i2p::stream::StreamingDestination> > m_StreamingDestinationsByPorts;
-			i2p::datagram::DatagramDestination * m_DatagramDestination;
-	
-			boost::asio::deadline_timer m_PublishConfirmationTimer, m_PublishVerificationTimer, m_CleanupTimer;
-
-		public:
-			
-			// for HTTP only
-			int GetNumRemoteLeaseSets () const { return m_RemoteLeaseSets.size (); };
-	};	
-}	
-}	
-
-#endif

FS.cpp

@@ -1,158 +0,0 @@
-/*
-* Copyright (c) 2013-2016, 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 <algorithm>
-#include <boost/filesystem.hpp>
-
-#ifdef WIN32
-#include <shlobj.h>
-#endif
-
-#include "Base.h"
-#include "FS.h"
-#include "Log.h"
-
-namespace i2p {
-namespace fs {
-  std::string appName = "i2pd";
-  std::string dataDir = "";
-#ifdef _WIN32
-  std::string dirSep = "\\";
-#else
-  std::string dirSep = "/";
-#endif
-
-  const std::string & GetAppName () {
-    return appName;
-  }
-
-  void SetAppName (const std::string& name) {
-    appName = name;
-  }
-
-  const std::string & GetDataDir () {
-    return dataDir;
-  }
-
-  void DetectDataDir(const std::string & cmdline_param, bool isService) {
-    if (cmdline_param != "") {
-      dataDir = cmdline_param;
-      return;
-    }
-#if defined(WIN32) || defined(_WIN32)
-    char localAppData[MAX_PATH];
-    SHGetFolderPath(NULL, CSIDL_APPDATA, 0, NULL, localAppData);
-    dataDir = std::string(localAppData) + "\\" + appName;
-    return;
-#elif defined(MAC_OSX)
-    char *home = getenv("HOME");
-    dataDir = (home != NULL && strlen(home) > 0) ? home : "";
-    dataDir += "/Library/Application Support/" + appName;
-    return;
-#else /* other unix */
-    char *home = getenv("HOME");
-    if (isService) {
-      dataDir = "/var/lib/" + appName;
-    } else if (home != NULL && strlen(home) > 0) {
-      dataDir = std::string(home) + "/." + appName;
-    } else {
-      dataDir = "/tmp/" + appName;
-    }
-    return;
-#endif
-  }
-
-  bool Init() {
-    if (boost::filesystem::exists(dataDir))
-      boost::filesystem::create_directory(dataDir);
-    std::string destinations = DataDirPath("destinations");
-    if (boost::filesystem::exists(destinations))
-      boost::filesystem::create_directory(destinations);
-
-    return true;
-  }
-
-  bool ReadDir(const std::string & path, std::vector<std::string> & files) {
-    if (!boost::filesystem::exists(path))
-      return false;
-    boost::filesystem::directory_iterator it(path);
-    boost::filesystem::directory_iterator end;
-
-    for ( ; it != end; it++) {
-      if (!boost::filesystem::is_regular_file(it->status()))
-        continue;
-      files.push_back(it->path().string());
-    }
-
-    return true;
-  }
-
-  bool Exists(const std::string & path) {
-    return boost::filesystem::exists(path);
-  }
-
-  bool Remove(const std::string & path) {
-    if (!boost::filesystem::exists(path))
-      return false;
-    return boost::filesystem::remove(path);
-  }
-
-  void HashedStorage::SetPlace(const std::string &path) {
-    root = path + i2p::fs::dirSep + name;
-  }
-
-  bool HashedStorage::Init(const char * chars, size_t count) {
-    if (!boost::filesystem::exists(root)) {
-      boost::filesystem::create_directory(root);
-    }
-    
-    for (size_t i = 0; i < count; i++) {
-      auto p = root + i2p::fs::dirSep + prefix1 + chars[i];
-      if (boost::filesystem::exists(p))
-        continue;
-      if (boost::filesystem::create_directory(p))
-        continue; /* ^ throws exception on failure */
-      return false;
-    }
-    return true;
-  }
-
-  std::string HashedStorage::Path(const std::string & ident) const {
-    std::string safe_ident = ident;
-    std::replace(safe_ident.begin(), safe_ident.end(), '/',  '-');
-    std::replace(safe_ident.begin(), safe_ident.end(), '\\', '-');
-
-    std::stringstream t("");
-    t << this->root << i2p::fs::dirSep;
-    t << prefix1 << safe_ident[0] << i2p::fs::dirSep;
-    t << prefix2 << safe_ident    << "." << suffix;
-
-    return t.str();
-  }
-
-  void HashedStorage::Remove(const std::string & ident) {
-    std::string path = Path(ident);
-    if (!boost::filesystem::exists(path))
-      return;
-    boost::filesystem::remove(path);
-  }
-
-  void HashedStorage::Traverse(std::vector<std::string> & files) {
-    boost::filesystem::path p(root);
-    boost::filesystem::recursive_directory_iterator it(p);
-    boost::filesystem::recursive_directory_iterator end;
-
-    for ( ; it != end; it++) {
-      if (!boost::filesystem::is_regular_file( it->status() ))
-        continue;
-      const std::string & t = it->path().string();
-      files.push_back(t);
-    }
-  }
-} // fs
-} // i2p

FS.h

@@ -1,142 +0,0 @@
-/*
-* Copyright (c) 2013-2016, 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 FS_H__
-#define FS_H__
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-namespace i2p {
-namespace fs {
-  extern std::string dirSep;
-
-  /**
-   * @brief Class to work with NetDb & Router profiles
-   *
-   * Usage:
-   *
-   * const char alphabet[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-   * auto h = HashedStorage("name", "y", "z-", ".txt");
-   * h.SetPlace("/tmp/hs-test");
-   * h.GetName()          -> gives "name"
-   * h.GetRoot()          -> gives "/tmp/hs-test/name"
-   * h.Init(alphabet, 8); <- creates needed dirs, 8 is size of alphabet
-   * h.Path("abcd");      <- returns /tmp/hs-test/name/ya/z-abcd.txt
-   * h.Remove("abcd");    <- removes /tmp/hs-test/name/ya/z-abcd.txt, if it exists
-   * std::vector<std::string> files;
-   * h.Traverse(files);   <- finds all files in storage and saves in given vector
-   */
-  class HashedStorage {
-    protected:
-      std::string root;    /**< path to storage with it's name included */
-      std::string name;    /**< name of the storage */
-      std::string prefix1; /**< hashed directory prefix */
-      std::string prefix2; /**< prefix of file in storage */
-      std::string suffix;  /**< suffix of file in storage (extension) */
-
-    public:
-      HashedStorage(const char *n, const char *p1, const char *p2, const char *s):
-        name(n), prefix1(p1), prefix2(p2), suffix(s) {};
-
-      /** create subdirs in storage */
-      bool Init(const char* chars, size_t cnt);
-      const std::string & GetRoot() const { return this->root; }
-      const std::string & GetName() const { return this->name; }
-      /** set directory where to place storage directory */
-      void SetPlace(const std::string & path);
-      /** path to file with given ident */
-      std::string Path(const std::string & ident) const;
-      /** remove file by ident */
-      void Remove(const std::string & ident);
-      /** find all files in storage and store list in provided vector */
-      void Traverse(std::vector<std::string> & files);
-  };
-
-  /** @brief Returns current application name, default 'i2pd' */
-	const std::string & GetAppName ();
-  /** @brief Set applicaton name, affects autodetection of datadir */
-	void SetAppName (const std::string& name);
-
-  /** @brief Returns datadir path */
-  const std::string & GetDataDir();
-
-  /**
-   * @brief Set datadir either from cmdline option or using autodetection
-   * @param cmdline_param  Value of cmdline parameter --datadir=<something>
-   * @param isService      Value of cmdline parameter --service
-   *
-   * Examples of autodetected paths:
-   *
-   *   Windows < Vista: C:\Documents and Settings\Username\Application Data\i2pd\
-   *   Windows >= Vista: C:\Users\Username\AppData\Roaming\i2pd\
-   *   Mac: /Library/Application Support/i2pd/ or ~/Library/Application Support/i2pd/
-   *   Unix: /var/lib/i2pd/ (system=1) >> ~/.i2pd/ or /tmp/i2pd/
-   */
-  void DetectDataDir(const std::string & cmdline_datadir, bool isService = false);
-
-  /**
-   * @brief Create subdirectories inside datadir
-   */
-  bool Init();
-
-  /**
-   * @brief Get list of files in directory
-   * @param path  Path to directory
-   * @param files Vector to store found files
-   * @return true on success and false if directory not exists
-   */
-  bool ReadDir(const std::string & path, std::vector<std::string> & files);
-
-  /**
-   * @brief Remove file with given path
-   * @param path Absolute path to file
-   * @return true on success, false if file not exists, throws exception on error
-   */
-  bool Remove(const std::string & path);
-
-  /**
-   * @brief Check existence of file
-   * @param path Absolute path to file
-   * @return true if file exists, false otherwise
-   */
-  bool Exists(const std::string & path);
-
-  template<typename T>
-  void _ExpandPath(std::stringstream & path, T c) {
-    path << i2p::fs::dirSep << c;
-  }
-
-  template<typename T, typename ... Other>
-  void _ExpandPath(std::stringstream & path, T c, Other ... other) {
-    _ExpandPath(path, c);
-    _ExpandPath(path, other ...);
-  }
-
-  /**
-   * @brief Get path relative to datadir
-   *
-   * Examples (with datadir = "/tmp/i2pd"):
-   *
-   * i2p::fs::Path("test")             -> '/tmp/i2pd/test'
-   * i2p::fs::Path("test", "file.txt") -> '/tmp/i2pd/test/file.txt'
-   */
-  template<typename ... Other>
-  std::string DataDirPath(Other ... components) {
-    std::stringstream s("");
-    s << i2p::fs::GetDataDir();
-    _ExpandPath(s, components ...);
-
-    return s.str();
-  }
-} // fs
-} // i2p
-
-#endif // /* FS_H__ */

Garlic.cpp

@@ -1,651 +0,0 @@
-#include <inttypes.h>
-#include "I2PEndian.h"
-#include <map>
-#include <string>
-#include <openssl/rand.h>
-#include <openssl/sha.h>
-#include "RouterContext.h"
-#include "I2NPProtocol.h"
-#include "Tunnel.h"
-#include "TunnelPool.h"
-#include "Timestamp.h"
-#include "Log.h"
-#include "Garlic.h"
-
-namespace i2p
-{
-namespace garlic
-{
-	GarlicRoutingSession::GarlicRoutingSession (GarlicDestination * owner, 
-	    std::shared_ptr<const i2p::data::RoutingDestination> destination, int numTags, bool attachLeaseSet):
-		m_Owner (owner), m_Destination (destination), m_NumTags (numTags), 
-		m_LeaseSetUpdateStatus (attachLeaseSet ? eLeaseSetUpdated : eLeaseSetDoNotSend),
-		m_ElGamalEncryption (new i2p::crypto::ElGamalEncryption (destination->GetEncryptionPublicKey ()))
-	{
-		// create new session tags and session key
-		RAND_bytes (m_SessionKey, 32);
-		m_Encryption.SetKey (m_SessionKey);
-	}	
-
-	GarlicRoutingSession::GarlicRoutingSession (const uint8_t * sessionKey, const SessionTag& sessionTag):
-		m_Owner (nullptr), m_Destination (nullptr), m_NumTags (1), m_LeaseSetUpdateStatus (eLeaseSetDoNotSend)
-	{
-		memcpy (m_SessionKey, sessionKey, 32);
-		m_Encryption.SetKey (m_SessionKey);
-		m_SessionTags.push_back (sessionTag);
-		m_SessionTags.back ().creationTime = i2p::util::GetSecondsSinceEpoch ();
-	}	
-
-	GarlicRoutingSession::~GarlicRoutingSession	()
-	{	
-		for (auto it: m_UnconfirmedTagsMsgs)	
-			delete it.second;
-		m_UnconfirmedTagsMsgs.clear ();
-	}
-
-	std::shared_ptr<GarlicRoutingPath> GarlicRoutingSession::GetSharedRoutingPath ()
-	{
-		if (!m_SharedRoutingPath) return nullptr;
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		if (m_SharedRoutingPath->numTimesUsed >= ROUTING_PATH_MAX_NUM_TIMES_USED ||
-		    !m_SharedRoutingPath->outboundTunnel->IsEstablished () ||
-			ts*1000LL > m_SharedRoutingPath->remoteLease->endDate ||
-		    ts > m_SharedRoutingPath->updateTime + ROUTING_PATH_EXPIRATION_TIMEOUT)
-				m_SharedRoutingPath = nullptr;
-		if (m_SharedRoutingPath) m_SharedRoutingPath->numTimesUsed++;
-		return m_SharedRoutingPath;
-	}
-		
-	void GarlicRoutingSession::SetSharedRoutingPath (std::shared_ptr<GarlicRoutingPath> path)
-	{	
-		if (path && path->outboundTunnel && path->remoteLease) 
-		{	
-			path->updateTime = i2p::util::GetSecondsSinceEpoch ();
-			path->numTimesUsed = 0;
-		}	
-		else
-			path = nullptr;
-		m_SharedRoutingPath = path;
-	}
-		
-	GarlicRoutingSession::UnconfirmedTags * GarlicRoutingSession::GenerateSessionTags ()
-	{
-		auto tags = new UnconfirmedTags (m_NumTags);
-		tags->tagsCreationTime = i2p::util::GetSecondsSinceEpoch ();		
-		for (int i = 0; i < m_NumTags; i++)
-		{
-			RAND_bytes (tags->sessionTags[i], 32);
-			tags->sessionTags[i].creationTime = tags->tagsCreationTime;
-		}			
-		return tags;	
-	}
-
-	void GarlicRoutingSession::MessageConfirmed (uint32_t msgID)
-	{
-		TagsConfirmed (msgID);
-		if (msgID == m_LeaseSetUpdateMsgID)
-		{	
-			m_LeaseSetUpdateStatus = eLeaseSetUpToDate;
-			LogPrint (eLogInfo, "Garlic: LeaseSet update confirmed");
-		}	
-		else
-			CleanupExpiredTags ();
-	}	
-		
-	void GarlicRoutingSession::TagsConfirmed (uint32_t msgID) 
-	{ 
-		auto it = m_UnconfirmedTagsMsgs.find (msgID);	
-		if (it != m_UnconfirmedTagsMsgs.end ())
-		{
-			uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-			UnconfirmedTags * tags = it->second;
-			if (ts < tags->tagsCreationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
-			{	
-				for (int i = 0; i < tags->numTags; i++)
-					m_SessionTags.push_back (tags->sessionTags[i]);
-			}	
-			m_UnconfirmedTagsMsgs.erase (it);
-			delete tags;
-		}
-	}
-
-	bool GarlicRoutingSession::CleanupExpiredTags ()
-	{
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		for (auto it = m_SessionTags.begin (); it != m_SessionTags.end ();)
-		{
-			if (ts >= it->creationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
-				it = m_SessionTags.erase (it);
-			else 
-				it++;
-		}
-		// delete expired unconfirmed tags
-		for (auto it = m_UnconfirmedTagsMsgs.begin (); it != m_UnconfirmedTagsMsgs.end ();)
-		{
-			if (ts >= it->second->tagsCreationTime + OUTGOING_TAGS_CONFIRMATION_TIMEOUT)
-			{
-				if (m_Owner)
-					m_Owner->RemoveDeliveryStatusSession (it->first);
-				delete it->second;
-				it = m_UnconfirmedTagsMsgs.erase (it);
-			}	
-			else
-				it++;
-		}	
-		return !m_SessionTags.empty () || !m_UnconfirmedTagsMsgs.empty ();
- 	}
-
-	std::shared_ptr<I2NPMessage> GarlicRoutingSession::WrapSingleMessage (std::shared_ptr<const I2NPMessage> msg)
-	{
-		auto m = NewI2NPMessage ();
-		m->Align (12); // in order to get buf aligned to 16 (12 + 4)
-		size_t len = 0;
-		uint8_t * buf = m->GetPayload () + 4; // 4 bytes for length
-
-		// find non-expired tag
-		bool tagFound = false;	
-		SessionTag tag; 
-		if (m_NumTags > 0)
-		{	
-			uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-			while (!m_SessionTags.empty ())
-			{
-				if (ts < m_SessionTags.front ().creationTime + OUTGOING_TAGS_EXPIRATION_TIMEOUT)
-				{
-					tag = m_SessionTags.front ();
-					m_SessionTags.pop_front (); // use same tag only once
-					tagFound = true;
-					break;
-				}	
-				else
-					m_SessionTags.pop_front (); // remove expired tag
-			}
-		}	
-		// create message
-		if (!tagFound) // new session
-		{
-			LogPrint (eLogWarning, "Garlic: No tags available, will use ElGamal");
-			if (!m_Destination)
-			{
-				LogPrint (eLogError, "Garlic: Can't use ElGamal for unknown destination");
-				return nullptr;
-			}
-			// create ElGamal block
-			ElGamalBlock elGamal;
-			memcpy (elGamal.sessionKey, m_SessionKey, 32); 
-			RAND_bytes (elGamal.preIV, 32); // Pre-IV
-			uint8_t iv[32]; // IV is first 16 bytes
-			SHA256(elGamal.preIV, 32, iv); 
-			m_ElGamalEncryption->Encrypt ((uint8_t *)&elGamal, sizeof(elGamal), buf, true);			
-			m_Encryption.SetIV (iv);
-			buf += 514;
-			len += 514;	
-		}
-		else // existing session
-		{	
-			// session tag
-			memcpy (buf, tag, 32);	
-			uint8_t iv[32]; // IV is first 16 bytes
-			SHA256(tag, 32, iv);
-			m_Encryption.SetIV (iv);
-			buf += 32;
-			len += 32;		
-		}	
-		// AES block
-		len += CreateAESBlock (buf, msg);
-		htobe32buf (m->GetPayload (), len);
-		m->len += len + 4;
-		m->FillI2NPMessageHeader (eI2NPGarlic);
-		return m;
-	}	
-
-	size_t GarlicRoutingSession::CreateAESBlock (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg)
-	{
-		size_t blockSize = 0;
-		bool createNewTags = m_Owner && m_NumTags && ((int)m_SessionTags.size () <= m_NumTags*2/3);
-		UnconfirmedTags * newTags = createNewTags ? GenerateSessionTags () : nullptr;
-		htobuf16 (buf, newTags ? htobe16 (newTags->numTags) : 0); // tag count
-		blockSize += 2;
-		if (newTags) // session tags recreated
-		{	
-			for (int i = 0; i < newTags->numTags; i++)
-			{
-				memcpy (buf + blockSize, newTags->sessionTags[i], 32); // tags
-				blockSize += 32;
-			}
-		}	
-		uint32_t * payloadSize = (uint32_t *)(buf + blockSize);
-		blockSize += 4;
-		uint8_t * payloadHash = buf + blockSize;
-		blockSize += 32;
-		buf[blockSize] = 0; // flag
-		blockSize++;
-		size_t len = CreateGarlicPayload (buf + blockSize, msg, newTags);
-		htobe32buf (payloadSize, len);
-		SHA256(buf + blockSize, len, payloadHash);
-		blockSize += len;
-		size_t rem = blockSize % 16;
-		if (rem)
-			blockSize += (16-rem); //padding
-		m_Encryption.Encrypt(buf, blockSize, buf);
-		return blockSize;
-	}	
-
-	size_t GarlicRoutingSession::CreateGarlicPayload (uint8_t * payload, std::shared_ptr<const I2NPMessage> msg, UnconfirmedTags * newTags)
-	{
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec
-		uint32_t msgID;
-		RAND_bytes ((uint8_t *)&msgID, 4);
-		size_t size = 0;
-		uint8_t * numCloves = payload + size;
-		*numCloves = 0;
-		size++;
-
-		if (m_Owner)
-		{	
-			// resubmit non-confirmed LeaseSet
-			if (m_LeaseSetUpdateStatus == eLeaseSetSubmitted && 
-			    i2p::util::GetMillisecondsSinceEpoch () > m_LeaseSetSubmissionTime + LEASET_CONFIRMATION_TIMEOUT)
-					m_LeaseSetUpdateStatus = eLeaseSetUpdated;
-
-			// attach DeviveryStatus if necessary
-			if (newTags || m_LeaseSetUpdateStatus == eLeaseSetUpdated) // new tags created or leaseset updated
-			{
-				// clove is DeliveryStatus 
-				auto cloveSize = CreateDeliveryStatusClove (payload + size, msgID);
-				if (cloveSize > 0) // successive?
-				{
-					size += cloveSize;
-					(*numCloves)++;
-					if (newTags) // new tags created
-						m_UnconfirmedTagsMsgs[msgID] = newTags;
-					m_Owner->DeliveryStatusSent (shared_from_this (), msgID);
-				}
-				else
-					LogPrint (eLogWarning, "Garlic: DeliveryStatus clove was not created");
-			}	
-			// attach LeaseSet
-			if (m_LeaseSetUpdateStatus == eLeaseSetUpdated) 
-			{
-				m_LeaseSetUpdateStatus = eLeaseSetSubmitted;
-				m_LeaseSetUpdateMsgID = msgID;
-				m_LeaseSetSubmissionTime = i2p::util::GetMillisecondsSinceEpoch ();
-				// clove if our leaseSet must be attached
-				auto leaseSet = CreateDatabaseStoreMsg (m_Owner->GetLeaseSet ());
-				size += CreateGarlicClove (payload + size, leaseSet, false); 
-				(*numCloves)++;
-			}
-		}	
-		if (msg) // clove message ifself if presented
-		{	
-			size += CreateGarlicClove (payload + size, msg, m_Destination ? m_Destination->IsDestination () : false);
-			(*numCloves)++;
-		}	
-		
-		memset (payload + size, 0, 3); // certificate of message
-		size += 3;
-		htobe32buf (payload + size, msgID); // MessageID
-		size += 4;
-		htobe64buf (payload + size, ts); // Expiration of message
-		size += 8;
-		return size;
-	}	
-
-	size_t GarlicRoutingSession::CreateGarlicClove (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg, bool isDestination)
-	{
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec
-		size_t size = 0;
-		if (isDestination && m_Destination)
-		{
-			buf[size] = eGarlicDeliveryTypeDestination << 5;//  delivery instructions flag destination
-			size++;
-			memcpy (buf + size, m_Destination->GetIdentHash (), 32);
-			size += 32;
-		}	
-		else	
-		{	
-			buf[size] = 0;//  delivery instructions flag local
-			size++;
-		}
-		
-		memcpy (buf + size, msg->GetBuffer (), msg->GetLength ());
-		size += msg->GetLength ();
-		uint32_t cloveID;
-		RAND_bytes ((uint8_t *)&cloveID, 4);
-		htobe32buf (buf + size, cloveID); // CloveID
-		size += 4;
-		htobe64buf (buf + size, ts); // Expiration of clove
-		size += 8;
-		memset (buf + size, 0, 3); // certificate of clove
-		size += 3;
-		return size;
-	}	
-
-	size_t GarlicRoutingSession::CreateDeliveryStatusClove (uint8_t * buf, uint32_t msgID)
-	{		
-		size_t size = 0;
-		if (m_Owner)
-		{
-			auto inboundTunnel = m_Owner->GetTunnelPool ()->GetNextInboundTunnel ();
-			if (inboundTunnel)
-			{	
-				buf[size] = eGarlicDeliveryTypeTunnel << 5; // delivery instructions flag tunnel
-				size++;
-				// hash and tunnelID sequence is reversed for Garlic 
-				memcpy (buf + size, inboundTunnel->GetNextIdentHash (), 32); // To Hash
-				size += 32;
-				htobe32buf (buf + size, inboundTunnel->GetNextTunnelID ()); // tunnelID
-				size += 4; 	
-				// create msg 
-				auto msg = CreateDeliveryStatusMsg (msgID);
-				if (m_Owner)
-				{
-					//encrypt 
-					uint8_t key[32], tag[32];
-					RAND_bytes (key, 32); // random session key 
-					RAND_bytes (tag, 32); // random session tag
-					m_Owner->SubmitSessionKey (key, tag);
-					GarlicRoutingSession garlic (key, tag);
-					msg = garlic.WrapSingleMessage (msg);		
-				}
-				memcpy (buf + size, msg->GetBuffer (), msg->GetLength ());
-				size += msg->GetLength ();
-				// fill clove
-				uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec
-				uint32_t cloveID;
-				RAND_bytes ((uint8_t *)&cloveID, 4);
-				htobe32buf (buf + size, cloveID); // CloveID
-				size += 4;
-				htobe64buf (buf + size, ts); // Expiration of clove
-				size += 8;
-				memset (buf + size, 0, 3); // certificate of clove
-				size += 3;
-			}
-			else	
-				LogPrint (eLogError, "Garlic: No inbound tunnels in the pool for DeliveryStatus");
-		}
-		else
-			LogPrint (eLogWarning, "Garlic: Missing local LeaseSet");
-
-		return size;
-	}
-	
-	GarlicDestination::~GarlicDestination ()
-	{
-	}
-
-	void GarlicDestination::AddSessionKey (const uint8_t * key, const uint8_t * tag)
-	{
-		if (key)
-		{
-			uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-			auto decryption = std::make_shared<i2p::crypto::CBCDecryption>();
-			decryption->SetKey (key);
-			m_Tags[SessionTag(tag, ts)] = decryption;
-		}
-	}
-
-	bool GarlicDestination::SubmitSessionKey (const uint8_t * key, const uint8_t * tag) 
-	{
-		AddSessionKey (key, tag);
-		return true;
-	}
-
-	void GarlicDestination::HandleGarlicMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		uint8_t * buf = msg->GetPayload ();
-		uint32_t length = bufbe32toh (buf);
-		if (length > msg->GetLength ())
-		{
-			LogPrint (eLogWarning, "Garlic: message length ", length, " exceeds I2NP message length ", msg->GetLength ());
-			return;
-		}	
-		buf += 4; // length
-		auto it = m_Tags.find (SessionTag(buf));
-		if (it != m_Tags.end ())
-		{
-			// tag found. Use AES
-			if (length >= 32)
-			{	
-				uint8_t iv[32]; // IV is first 16 bytes
-				SHA256(buf, 32, iv);
-				it->second->SetIV (iv);
-				it->second->Decrypt (buf + 32, length - 32, buf + 32);
-				HandleAESBlock (buf + 32, length - 32, it->second, msg->from);
-			}	
-			else
-				LogPrint (eLogWarning, "Garlic: message length ", length, " is less than 32 bytes");
-			m_Tags.erase (it); // tag might be used only once	
-		}
-		else
-		{
-			// tag not found. Use ElGamal
-			ElGamalBlock elGamal;
-			if (length >= 514 && i2p::crypto::ElGamalDecrypt (GetEncryptionPrivateKey (), buf, (uint8_t *)&elGamal, true))
-			{	
-				auto decryption = std::make_shared<i2p::crypto::CBCDecryption>();
-				decryption->SetKey (elGamal.sessionKey);
-				uint8_t iv[32]; // IV is first 16 bytes
-				SHA256(elGamal.preIV, 32, iv); 
-				decryption->SetIV (iv);
-				decryption->Decrypt(buf + 514, length - 514, buf + 514);
-				HandleAESBlock (buf + 514, length - 514, decryption, msg->from);
-			}	
-			else
-				LogPrint (eLogError, "Garlic: Failed to decrypt message");
-		}
-	}	
-
-	void GarlicDestination::HandleAESBlock (uint8_t * buf, size_t len, std::shared_ptr<i2p::crypto::CBCDecryption> decryption,
-		std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		uint16_t tagCount = bufbe16toh (buf);
-		buf += 2; len -= 2;	
-		if (tagCount > 0)
-		{	
-			if (tagCount*32 > len) 
-			{
-				LogPrint (eLogError, "Garlic: Tag count ", tagCount, " exceeds length ", len);
-				return ;
-			}	
-			uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-			for (int i = 0; i < tagCount; i++)
-				m_Tags[SessionTag(buf + i*32, ts)] = decryption;	
-		}	
-		buf += tagCount*32;
-		len -= tagCount*32;
-		uint32_t payloadSize = bufbe32toh (buf);
-		if (payloadSize > len)
-		{
-			LogPrint (eLogError, "Garlic: Unexpected payload size ", payloadSize);
-			return;
-		}	
-		buf += 4;
-		uint8_t * payloadHash = buf;
-		buf += 32;// payload hash. 
-		if (*buf) // session key?
-			buf += 32; // new session key
-		buf++; // flag
-
-		// payload
-		uint8_t digest[32];
-		SHA256 (buf, payloadSize, digest);
-		if (memcmp (payloadHash, digest, 32)) // payload hash doesn't match
-		{
-			LogPrint (eLogError, "Garlic: wrong payload hash");
-			return;
-		}		    
-		HandleGarlicPayload (buf, payloadSize, from);
-	}	
-
-	void GarlicDestination::HandleGarlicPayload (uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		const uint8_t * buf1 = buf;
-		int numCloves = buf[0];
-		LogPrint (eLogDebug, "Garlic: ", numCloves," cloves");
-		buf++;
-		for (int i = 0; i < numCloves; i++)
-		{
-			// delivery instructions
-			uint8_t flag = buf[0];
-			buf++; // flag
-			if (flag & 0x80) // encrypted?
-			{
-				// TODO: implement
-				LogPrint (eLogWarning, "Garlic: clove encrypted");
-				buf += 32; 
-			}	
-			GarlicDeliveryType deliveryType = (GarlicDeliveryType)((flag >> 5) & 0x03);
-			switch (deliveryType)
-			{
-				case eGarlicDeliveryTypeLocal:
-					LogPrint (eLogDebug, "Garlic: type local");
-					HandleI2NPMessage (buf, len, from);
-				break;	
-				case eGarlicDeliveryTypeDestination:	
-					LogPrint (eLogDebug, "Garlic: type destination");
-					buf += 32; // destination. check it later or for multiple destinations
-					HandleI2NPMessage (buf, len, from);
-				break;
-				case eGarlicDeliveryTypeTunnel:
-				{	
-					LogPrint (eLogDebug, "Garlic: type tunnel");
-					// gwHash and gwTunnel sequence is reverted
-					uint8_t * gwHash = buf;
-					buf += 32;
-					uint32_t gwTunnel = bufbe32toh (buf);
-					buf += 4;
-					std::shared_ptr<i2p::tunnel::OutboundTunnel> tunnel;
-					if (from && from->GetTunnelPool ())
-						tunnel = from->GetTunnelPool ()->GetNextOutboundTunnel ();
-					if (tunnel) // we have send it through an outbound tunnel
-					{	
-						auto msg = CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from);
-						tunnel->SendTunnelDataMsg (gwHash, gwTunnel, msg);
-					}	
-					else
-						LogPrint (eLogWarning, "Garlic: No outbound tunnels available for garlic clove");
-					break;
-				}
-				case eGarlicDeliveryTypeRouter:
-					LogPrint (eLogWarning, "Garlic: type router not supported");
-					buf += 32;
-				break;	
-				default:
-					LogPrint (eLogWarning, "Garlic: unknown delivery type ", (int)deliveryType);
-			}
-			buf += GetI2NPMessageLength (buf); //  I2NP
-			buf += 4; // CloveID
-			buf += 8; // Date
-			buf += 3; // Certificate
-			if (buf - buf1  > (int)len)
-			{
-				LogPrint (eLogError, "Garlic: clove is too long");
-				break;
-			}	
-		}	
-	}	
-	
-	std::shared_ptr<I2NPMessage> GarlicDestination::WrapMessage (std::shared_ptr<const i2p::data::RoutingDestination> destination, 
-		std::shared_ptr<I2NPMessage> msg, bool attachLeaseSet)	
-	{
-		auto session = GetRoutingSession (destination, attachLeaseSet);  
-		return session->WrapSingleMessage (msg);	
-	}
-
-	std::shared_ptr<GarlicRoutingSession> GarlicDestination::GetRoutingSession (
-		std::shared_ptr<const i2p::data::RoutingDestination> destination, bool attachLeaseSet)
-	{
-		GarlicRoutingSessionPtr session;
-		{	
-			std::unique_lock<std::mutex> l(m_SessionsMutex);
-			auto it = m_Sessions.find (destination->GetIdentHash ());
-			if (it != m_Sessions.end ())
-				session = it->second;
-		}
-		if (!session)
-		{
-			session = std::make_shared<GarlicRoutingSession> (this, destination, 
-				attachLeaseSet ? m_NumTags : 4, attachLeaseSet); // specified num tags for connections and 4 for LS requests
-			std::unique_lock<std::mutex> l(m_SessionsMutex);
-			m_Sessions[destination->GetIdentHash ()] = session;
-		}	
-		return session;
-	}	
-	
-	void GarlicDestination::CleanupExpiredTags ()
-	{
-		// incoming
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		int numExpiredTags = 0;
-		for (auto it = m_Tags.begin (); it != m_Tags.end ();)
-		{
-			if (ts > it->first.creationTime + INCOMING_TAGS_EXPIRATION_TIMEOUT)
-			{
-				numExpiredTags++;
-				it = m_Tags.erase (it);
-			}	
-			else
-				it++;
-		}
-		if (numExpiredTags > 0)
-			LogPrint (eLogDebug, "Garlic: ", numExpiredTags, " tags expired for ", GetIdentHash().ToBase64 ());
-
-		// outgoing
-		std::unique_lock<std::mutex> l(m_SessionsMutex);
-		for (auto it = m_Sessions.begin (); it != m_Sessions.end ();)
-		{
-			it->second->GetSharedRoutingPath (); // delete shared path if necessary
-			if (!it->second->CleanupExpiredTags ())
-			{
-				LogPrint (eLogInfo, "Routing session to ", it->first.ToBase32 (), " deleted");
-				it = m_Sessions.erase (it);
-			}
-			else
-				it++;
-		}
-	}
-	
-	void GarlicDestination::RemoveDeliveryStatusSession (uint32_t msgID)
-	{
-		m_DeliveryStatusSessions.erase (msgID);
-	}
-
-	void GarlicDestination::DeliveryStatusSent (GarlicRoutingSessionPtr session, uint32_t msgID)
-	{
-		m_DeliveryStatusSessions[msgID] = session;
-	}		
-
-	void GarlicDestination::HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		uint32_t msgID = bufbe32toh (msg->GetPayload ());
-		{
-			auto it = m_DeliveryStatusSessions.find (msgID);
-			if (it != m_DeliveryStatusSessions.end ())			
-			{
-				it->second->MessageConfirmed (msgID);
-				m_DeliveryStatusSessions.erase (it);
-				LogPrint (eLogDebug, "Garlic: message ", msgID, " acknowledged");
-			}	
-		}
-	}
-
-	void GarlicDestination::SetLeaseSetUpdated ()
-	{
-		std::unique_lock<std::mutex> l(m_SessionsMutex);	
-		for (auto it: m_Sessions)
-			it.second->SetLeaseSetUpdated ();
-	}
-
-	void GarlicDestination::ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		HandleGarlicMessage (msg);
-	}
-
-	void GarlicDestination::ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		HandleDeliveryStatusMessage (msg);
-	}
-
-}	
-}

Garlic.h

@@ -1,201 +0,0 @@
-#ifndef GARLIC_H__
-#define GARLIC_H__
-
-#include <inttypes.h>
-#include <map>
-#include <list>
-#include <string>
-#include <thread>
-#include <mutex>
-#include <memory>
-#include "Crypto.h"
-#include "I2NPProtocol.h"
-#include "LeaseSet.h"
-#include "Queue.h"
-#include "Identity.h"
-
-namespace i2p
-{
-namespace tunnel
-{		
-	class OutboundTunnel;
-}
-	
-namespace garlic
-{
-	
-	enum GarlicDeliveryType 
-	{ 
-		eGarlicDeliveryTypeLocal = 0, 
-		eGarlicDeliveryTypeDestination = 1,
-		eGarlicDeliveryTypeRouter = 2,	
-		eGarlicDeliveryTypeTunnel = 3
-	};	
-
-	struct ElGamalBlock
-	{
-		uint8_t sessionKey[32];
-		uint8_t preIV[32];
-		uint8_t padding[158];
-	};		
-
-	const int INCOMING_TAGS_EXPIRATION_TIMEOUT = 960; // 16 minutes			
-	const int OUTGOING_TAGS_EXPIRATION_TIMEOUT = 720; // 12 minutes
-	const int OUTGOING_TAGS_CONFIRMATION_TIMEOUT = 10; // 10 seconds 
-	const int LEASET_CONFIRMATION_TIMEOUT = 4000; // in milliseconds
-	const int ROUTING_PATH_EXPIRATION_TIMEOUT = 30; // 30 seconds 
-	const int ROUTING_PATH_MAX_NUM_TIMES_USED = 100; // how many times might be used 
-	
-	struct SessionTag: public i2p::data::Tag<32> 
-	{
-		SessionTag (const uint8_t * buf, uint32_t ts = 0): Tag<32>(buf), creationTime (ts) {};
-		SessionTag () = default;
-		SessionTag (const SessionTag& ) = default;
-		SessionTag& operator= (const SessionTag& ) = default;
-#ifndef _WIN32
-		SessionTag (SessionTag&& ) = default; 
-		SessionTag& operator= (SessionTag&& ) = default;	
-#endif
-		uint32_t creationTime; // seconds since epoch	
-	};
-
-	struct GarlicRoutingPath
-	{
-		std::shared_ptr<i2p::tunnel::OutboundTunnel> outboundTunnel;
-		std::shared_ptr<const i2p::data::Lease> remoteLease;
-		int rtt; // RTT
-		uint32_t updateTime; // seconds since epoch
-		int numTimesUsed; 
-	};	
-	
-	class GarlicDestination;
-	class GarlicRoutingSession: public std::enable_shared_from_this<GarlicRoutingSession>
-	{
-			enum LeaseSetUpdateStatus
-			{
-				eLeaseSetUpToDate = 0,
-				eLeaseSetUpdated,
-				eLeaseSetSubmitted,
-				eLeaseSetDoNotSend
-			};
-		
-			struct UnconfirmedTags
-			{
-				UnconfirmedTags (int n): numTags (n), tagsCreationTime (0) { sessionTags = new SessionTag[numTags]; };
-				~UnconfirmedTags () { delete[] sessionTags; };
-				int numTags;
-				SessionTag * sessionTags;
-				uint32_t tagsCreationTime;
-			};
-
-		public:
-
-			GarlicRoutingSession (GarlicDestination * owner, std::shared_ptr<const i2p::data::RoutingDestination> destination, 
-				int numTags, bool attachLeaseSet);
-			GarlicRoutingSession (const uint8_t * sessionKey, const SessionTag& sessionTag); // one time encryption
-			~GarlicRoutingSession ();
-			std::shared_ptr<I2NPMessage> WrapSingleMessage (std::shared_ptr<const I2NPMessage> msg);
-			void MessageConfirmed (uint32_t msgID);
-			bool CleanupExpiredTags (); // returns true if something left 
-
-			void SetLeaseSetUpdated () 
-			{ 
-				if (m_LeaseSetUpdateStatus != eLeaseSetDoNotSend) m_LeaseSetUpdateStatus = eLeaseSetUpdated; 
-			};
-
-			std::shared_ptr<GarlicRoutingPath> GetSharedRoutingPath ();
-			void SetSharedRoutingPath (std::shared_ptr<GarlicRoutingPath> path);
-			
-		private:
-
-			size_t CreateAESBlock (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg);
-			size_t CreateGarlicPayload (uint8_t * payload, std::shared_ptr<const I2NPMessage> msg, UnconfirmedTags * newTags);
-			size_t CreateGarlicClove (uint8_t * buf, std::shared_ptr<const I2NPMessage> msg, bool isDestination);
-			size_t CreateDeliveryStatusClove (uint8_t * buf, uint32_t msgID);
-
-			void TagsConfirmed (uint32_t msgID);
-			UnconfirmedTags * GenerateSessionTags ();
-
-		private:
-
-			GarlicDestination * m_Owner;
-			std::shared_ptr<const i2p::data::RoutingDestination> m_Destination;
-			i2p::crypto::AESKey m_SessionKey;
-			std::list<SessionTag> m_SessionTags;
-			int m_NumTags;
-			std::map<uint32_t, UnconfirmedTags *> m_UnconfirmedTagsMsgs;	
-			
-			LeaseSetUpdateStatus m_LeaseSetUpdateStatus;
-			uint32_t m_LeaseSetUpdateMsgID;
-			uint64_t m_LeaseSetSubmissionTime; // in milliseconds
-			
-			i2p::crypto::CBCEncryption m_Encryption;
-			std::unique_ptr<const i2p::crypto::ElGamalEncryption> m_ElGamalEncryption; 
-
-			std::shared_ptr<GarlicRoutingPath> m_SharedRoutingPath;
-			
-		public:
-			// for HTTP only
-			size_t GetNumOutgoingTags () const { return m_SessionTags.size (); };
-	};	
-	//using GarlicRoutingSessionPtr = std::shared_ptr<GarlicRoutingSession>;
-	typedef std::shared_ptr<GarlicRoutingSession> GarlicRoutingSessionPtr; // TODO: replace to using after switch to 4.8	
-
-	class GarlicDestination: public i2p::data::LocalDestination
-	{
-		public:
-
-			GarlicDestination (): m_NumTags (32) {}; // 32 tags by default
-			~GarlicDestination ();
-
-			void SetNumTags (int numTags) { m_NumTags = numTags; };		
-			std::shared_ptr<GarlicRoutingSession> GetRoutingSession (std::shared_ptr<const i2p::data::RoutingDestination> destination, bool attachLeaseSet);	
-			void CleanupExpiredTags ();
-			void RemoveDeliveryStatusSession (uint32_t msgID);
-			std::shared_ptr<I2NPMessage> WrapMessage (std::shared_ptr<const i2p::data::RoutingDestination> destination, 
-			    std::shared_ptr<I2NPMessage> msg, bool attachLeaseSet = false);
-
-			void AddSessionKey (const uint8_t * key, const uint8_t * tag); // one tag
-			virtual bool SubmitSessionKey (const uint8_t * key, const uint8_t * tag); // from different thread
-			void DeliveryStatusSent (GarlicRoutingSessionPtr session, uint32_t msgID);
-			
-			virtual void ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg);
-			virtual void ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);			
-			virtual void SetLeaseSetUpdated ();
-			
-			virtual std::shared_ptr<const i2p::data::LeaseSet> GetLeaseSet () = 0; // TODO
-			virtual std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () const = 0;
-			virtual void HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from) = 0;
-			
-		protected:
-
-			void HandleGarlicMessage (std::shared_ptr<I2NPMessage> msg);
-			void HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);			
-	
-		private:
-
-			void HandleAESBlock (uint8_t * buf, size_t len, std::shared_ptr<i2p::crypto::CBCDecryption> decryption, 
-				std::shared_ptr<i2p::tunnel::InboundTunnel> from);
-			void HandleGarlicPayload (uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from);
-
-		private:
-			
-			// outgoing sessions
-			int m_NumTags;
-			std::mutex m_SessionsMutex;
-			std::map<i2p::data::IdentHash, GarlicRoutingSessionPtr> m_Sessions;
-			// incoming
-			std::map<SessionTag, std::shared_ptr<i2p::crypto::CBCDecryption>> m_Tags;
-			// DeliveryStatus
-			std::map<uint32_t, GarlicRoutingSessionPtr> m_DeliveryStatusSessions; // msgID -> session
-			
-		public:
-
-			// for HTTP only
-			size_t GetNumIncomingTags () const { return m_Tags.size (); }	
-			const decltype(m_Sessions)& GetSessions () const { return m_Sessions; };
-	};	
-}	
-}
-
-#endif

HTTPProxy.cpp

@@ -1,321 +0,0 @@
-#include <cstring>
-#include <cassert>
-#include <boost/lexical_cast.hpp>
-#include <boost/regex.hpp>
-#include <string>
-#include <atomic>
-#include "HTTPProxy.h"
-#include "util.h"
-#include "Identity.h"
-#include "Streaming.h"
-#include "Destination.h"
-#include "ClientContext.h"
-#include "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, "HTTPProxy: 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, "HTTPProxy: no socket for read");
-		}
-	}
-
-	void HTTPProxyHandler::Terminate() {
-		if (Kill()) return;
-		if (m_sock) 
-		{
-			LogPrint(eLogDebug, "HTTPProxy: close sock");
-			m_sock->close();
-			m_sock = nullptr;
-		}
-		Done(shared_from_this());
-	}
-
-	/* All hope is lost beyond this point */
-	//TODO: handle this apropriately
-	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, "HTTPProxy: request: ", m_method, " ", 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, "HTTPProxy: server: ", server, ", port: ", port, ", path: ", 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, "HTTPProxy: 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 (eLogInfo, "HTTPProxy: jump service for ", m_address, ", 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");
-		// TODO: temporary shortcut. Must be implemented properly
-		uint8_t * eol = nullptr;
-		bool isEndOfHeader = false;
-		while (!isEndOfHeader && len && (eol = (uint8_t *)memchr (http_buff, '\r', len)))
-		{
-			if (eol)
-			{
-				*eol = 0; eol++;			
-				if (strncmp ((const char *)http_buff, "Referer", 7)) // strip out referer
-				{
-					if (!strncmp ((const char *)http_buff, "User-Agent", 10)) // replace UserAgent
-						m_request.append("User-Agent: MYOB/6.66 (AN/ON)");
-					else
-						m_request.append ((const char *)http_buff);
-					m_request.append ("\r\n");
-				}
-				isEndOfHeader = !http_buff[0];
-				auto l = eol - http_buff;
-				http_buff = eol;
-				len -= l;
-				if (len > 0) // \r
-				{
-					http_buff++;
-					len--;
-				}	
-			}
-		}	
-		m_request.append(reinterpret_cast<const char *>(http_buff),len);	
-		return true;
-	}
-
-	bool HTTPProxyHandler::HandleData(uint8_t *http_buff, std::size_t len)
-	{
-		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, "HTTPProxy: rejected invalid request ending with: ", ((int)*http_buff));
-							HTTPRequestFailed(); //TODO: add correct code
-							return false;
-					}
-				break;
-				default:
-					LogPrint(eLogError, "HTTPProxy: 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, "HTTPProxy: sock recv: ", len, " bytes");
-		if(ecode) 
-		{
-			LogPrint(eLogWarning, "HTTPProxy: sock recv got error: ", ecode);
-			Terminate();
-			return;
-		}
-
-		if (HandleData(m_http_buff, len)) 
-		{
-			if (m_state == DONE) 
-			{
-				LogPrint(eLogDebug, "HTTPProxy: 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)
-			LogPrint (eLogError, "HTTPProxy: 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, "HTTPProxy: 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, "HTTPProxy: error 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);
-	}
-
-}
-}

HTTPProxy.h

@@ -1,32 +0,0 @@
-#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

HTTPServer.cpp

@@ -1,948 +0,0 @@
-#include <ctime>
-#include <iomanip>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include "Base.h"
-#include "FS.h"
-#include "Log.h"
-#include "Tunnel.h"
-#include "TransitTunnel.h"
-#include "Transports.h"
-#include "NetDb.h"
-#include "I2PEndian.h"
-#include "Streaming.h"
-#include "Destination.h"
-#include "RouterContext.h"
-#include "ClientContext.h"
-#include "HTTPServer.h"
-
-// For image and info
-#include "version.h"
-
-namespace i2p
-{
-namespace util
-{
-
-	const std::string HTTPConnection::itoopieImage = 
-		"<img alt=\"ICToopie Icon\" src=\"data:image/png;base64,"
-		"iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXM"
-		"AAA3XAAAN1wFCKJt4AAAAB3RJTUUH3ggRChYFXVBoSgAAIABJREFUeNrtnXl8VOX1/9/PvXcmewiQBB"
-		"J2CKsKihQXkCJuiD8VKyptXejXaikWbe1C1dqi0lpr7UvrgihV64ZCXaqCUBEUQVBAAZUl7EtYEkLIP"
-		"pmZ+zy/P+6dySx3JgESkpAcX/MiznLvc8/5POc55zznnAfaqFWTaIXPnAt0AzoBqYAB1AAVwAFgF3Ck"
-		"DQCnBvUHxgEXAMOBLsfw22+BT4ElwGKgrE1ftAwaBswEygFlv+QJvALX2AH8BchrY3HzpF8A+xtA4PU"
-		"BwxZgUhvLmwf9AfA1suBjgaEK+GWbDdA0dAswC0iwhVEvSk5A9smFThmIjFSUroPHC0cr0HYexNxTiH"
-		"aMfBFAiT2e99sA0PiUBXwMnFEfwZ/ZB3n1eTDmTDh3IMKdgoYZoi8CXBCABhioA/uRn3+H+OgreGcFq"
-		"vAoWj15udQ2Oj1tAGgcmgS8WJfgczsif3sd3D4OkZyCZnqPQUWEkKaBlgDbd2PO+gDx5H/B462TZwq4"
-		"zPYc2gDQgPQmcH084Z/eE/nkHYjRw9H8VQ17c02A5ka99j/kb59DHDgSl3cC+BswrQ0AJ04GsB4YFEv"
-		"47VJQr/8eNW4kuv8kKF8jEfXSfOSUf6JVe+PydhEwtg0Ax0/Jtv+dHesLU65EPn0Xmt/XJM+ibn0M8+"
-		"XF6HH4+xVwdhsAjp0Sgb1AB6dxCoH67B+oEaeh+80mVE8GLP0a8+LfI6R05KcA1gFntQHg2GgX0N3pg"
-		"87tkd/NRktPbj7jr/SghkxG7j7k6DEI23O5uLkxWWumwl8WS/i9OmPueQ3RnIQPkJKI2PUq+jkDgs5l"
-		"pGdwEfDPNgDUTQ9hbd5EUfds5PZ/owvRPIHr98Oqp9EvHBITBFOBa9qWgNg0FFjrZO1npKIOvgm61my"
-		"1Vq1d4IbhP0euzo9pE3TAih62ASCCioH2TrNn72vQuUPzF34QBDoqdyLywBHHMa+zwd62BITQX+yZEU"
-		"X/uR+V04TCN9ygFOaafNTbyzHnLsNc9g3S60ca7hjLgYlY9yxajNjFWcBNbRqgltKBUidmTRiFnPcnd"
-		"L9DwEUI0JNgz17k5xuRBYfRvX7I6YD8/mBEr+5o/uoTEHwC6vn3UE+9h9qwwxmAw/oh/3or4qJhaE5j"
-		"fGcF5vUzHH/rtV3dNgBgxfdvcfL1a+YjhIgep6Ej/zYX+eg8tMOlzs/RLQv52M/gujHo/pr6D0bXYG0"
-		"+5iX3II5W1I9Hlw/HnP8Qhimjtce432N+uDoKBAJ4AJje2gHQDjjqNPtn34265ZJwxmkarMnHvOi3iA"
-		"pP/cY/5izkx4/UL2CkaTBvGf6Jfw6L7gXus/aCCy4YcujQoZL8/HzdXrKC4x7UHfXdbLTI+1TXINPHO"
-		"/JbNLUMmoMNMN1J+DkdkLdeGc4cXYO3l+M/ZypaiPAFsHvMmDFFl1122ZoxY8Zsyc7OLgxl7JKv0YZM"
-		"RhquugezJh8zQvjmpEmT9hUWFuYrpc5etmyZsWXLliylVOLs2bPXCyFKA/fauAcxfjr+SLsgORHtjz+"
-		"OuYl1F62c/Dhk3My5F7/vQ1Toa8XjmIHPhRAK2L1w4cIDSimPiqCCgoJdI0aM2EtIptAtl+BTH4VfM/"
-		"SlPkalJ9feIyEhQa5fv36Nik/Fffv2LbHHIwH5v4ejx24uQkLttUNe+1uz8K/CIZUrIxVTLUWGMXAhM"
-		"tFdK/y8vLzNSimzDuGo++67b37oPdY8HS2cwOuZqWECqtm0adNaVT86AhQEftuvK361NAIAC1G/uc4R"
-		"AAo4s7UuAT9xUv+/uQ5l1tSqcE3A/f9GeWwru127dnu2bt3auz7jnzFjxriJEyeuEkIIgDufRjm5boY"
-		"bZn4QHIuYPn367gEDBtTXV2+/atWqI4GlIH8f2uYdhFkCUsG06x1/q2jCBNOmNgKVEwDK/otKctcK10"
-		"hEuS5G+U3LaNq5c2dhz549s4/hPj4hxFEgE6BoHmSkhj+7pmHqlwXvWaaUcmFtR9ebMjMzNxcXF/cHm"
-		"DEJNe2GcIAabjhnCuaXW6KAexCrYKVVaQDH2TW8PzItNXxcK9cjbeGTnZ295xiFD+CaMmWKPwD4uZ9G"
-		"g+7bnbX3vP766w8fq/ABpk2bFrTqV26ytorDjB0v3Oi8H5hje0OtCgCOrJh4ocWoUFqxsXac11xzzXG"
-		"Nefz48cGrLvsWZUSkcBwuq00RHTNmzHFlGFx55ZU5gb93HUQ6cffakTG17oWtDQDnO6n/K8+JUs1s3x"
-		"9cT8WgQYNkHdfdiVUVFEaDBw/2Bf7eVgCROTyGXntfl8t1XBmFOTk5e4O+vxflJOrcXLTUxKjdQgWc0"
-		"9oAcKZT5C+vdzjbBODzhwfqnC722Wef7cnMzNwthOglhEjMzMxct2HDhj1BARtG8CpHK6OF0yWz9u/8"
-		"/PxOAEoppJSlU6ZM2dipU6cCIcSXEyZM2KaUKncaQ3l5eXrQHkhHd/T8vTDydEctcEZrA0CPyDfOykP"
-		"hD2eOlJCdEXxPff7551FFmgsWLDg4atSorsXFxd3t2WQUFxcPGTJkSJeFCxceBti2bVtwoyk1CREpnD"
-		"7dEQGj9IknnvABFBcXl+u6rs+cOXNQYWFhLvC9t956K0/TtIMQvee/fPny4FUHdEcqf/RDmyYM6VN/m"
-		"+hUBUCa05uDutuhkgjdOLRvSFRvyZLIHcODV1xxRaxqHu3yyy/XgKqXXnopKI7enR3EZyLGnGnBwuPx"
-		"dP/666935+Xl7QNSIpYqJYToO3Xq1PWRN3vooYeqA98dOwzNdFislILeOTENwVYDAEeXp1uWNUOi7IJ"
-		"za4VbVFTUafXq1RtCZr+POFnDQIfbb7/962effbZdQDgjT7eyd8IsdB9MqQ09q6FDh3rKysoGOvquSq"
-		"mnnnoqzGpftGjRVxs3buwf+MrE0bFd7JwOxLJjcloLABz3/TukoTktmwkuxPgRwVmohg8fHtQg+/btK"
-		"60r1vD888+PCHXrbr7YWTjXjkHLzggKp59SKl5BUW9gD8CKFSu2jh07tm8AYPdMRCkVGwDtU2Omkbca"
-		"ACThLGhHhvtNeGZqqLEoemVnZx+srKwsGjhwYHo9A04A/L9zUZkZzs/t98D8GfUPjuXn538+ZsyYb0e"
-		"OHNkXq9sInTKQf/kpuowDHU3EvEdGawGA476cz4zN/OwMtNl3WxaCUkoVFRV1Sk1NTZg5c+aeY4k8vv"
-		"w7hN8f+wvD+qH9YzL1iQPI/v37T1y6dOnpAYClJKK+eQ7N74v/Q1PGXAJcrQUAjiyqjJO9oxTcOg7jr"
-		"7eGCSdtzpw5I6ln7eeqf0JaUvwZ7jfhVxMwnrmTuuINQa8By1CVB96AjLS6NUhI0CkKG60FAJVOb+4p"
-		"wtTjjMjvg2k3YCx6GJmUEK3eY1G3LGT+i6hhfev3vH4f/OwK9J2voEYPiS+UIX2Q707HXDsLPSkBrT7"
-		"rx/7imOOoONmCMJoIAMWOAChEF5qThx0+Q8eciV71PuqRNzGffg+xtyiaoalJyAuHwE8vR1w1yioaPZ"
-		"YScSmhayba0sfQjpYhF3yJ2rwXUVqJmdkO47QeyEuGItLSrHzF+qacCQFbC1Ax3NZDJ1sQTbUbmGxrg"
-		"TCZdEzHPPweRn0TOYUAPQHwYe4uRPj8kJwAudmAjoYv2t07YYYJazk67hnngot+g1yyzjE9zDjZy0BT"
-		"bgc7bgXXLEBqIqab1OLJSIbkSzCrvVFayw+4W4sNAFbxZxR9/DWnNB04gHQQPlhl5LQmAKx3evO9ldY"
-		"O4KlK76+KaYqsbG0AWO20BL35CWiJp6bwDRe8sTTmUvxxawOAIytKKtBWf4N5KgLA40EuXR+T5/NbGw"
-		"A+j/XB0/+1agBONZr5flxtqFobAMBqohRF//4IzedvGoY0mvpPRP15Tkz1/3JTjaupAfCvWK7oA68it"
-		"VOol/m8j5HFZTHd7tlNNa7mwOJYcT9VMx+haS2/pb2RiOr8A9ShEsdnWYjVXbRVagCAR2IAUdz+BKbR"
-		"wkNCQsATc5ExhC+AGU06vmbAowSs3rqOa/6GWaiB3WmxJmGlB5lxTUxeb8U61ILWrAFqgEdjgfHSe1C"
-		"Gq2UK30hAjbsvpvAF8KumHmNzmVnTsGLhUXTwCNqND+NvaSDQNXj4VczPN8bUspuABU0+zmbEs93EaK"
-		"H2zU60HlmYZ+WhqRbiHK74DnnTIzEnmMCqjDrU1ONsbhb2GuLkxy97DHX+ac0fBNv2Yw68NW73D59t+"
-		"zQ5NTfjamw8UI76NWLtVqRoxo7hzoP4T7utztYvbqyDrZp+qWpm/KvCSrUeH+sLsz9EDO+PHNANTTYj"
-		"TaAJWL8D84zb0eKlhIfQ97CaSnzVBoBwWgecS5zj2V5fitAE8sJhCGk2/TJmuOHVxcjL7zvm84ausgG"
-		"/rs0GAObOhQ8+QLz8Msp2D+Pa/qMGIz/8M8JtNGETSRfqhzMw3/jkuCeTAO4B/tpmBAJCMFIpXsc63r"
-		"VOJa8J1CvTUD+67OScFhI665evx3/FH9DKqsL4qM7nbDqSIQ9QqK3hm/rwWQBPY5192GoB4BaCuUpxN"
-		"cexNTq0L2r5P8DVyNrAcMGuA6jJT6AWrQnn37WMlT/kKg2UkCh0NHR01vKt+ojP1CrW1XXO0HvA1a0R"
-		"AFcC79ZzPMECzsgPrj4P+e4DDX+CSKAl7RfrMR94BSK7fmbTUT3Ar0QmGULGwK6Ojh+/eoV31XyWiDj"
-		"PtpwY7fJPVQC8BfxACOKWYuaQLccx2ncOZ/o6kam2sUu7h0dTvCFFRmf0Qm6Y7dxXONCvxzTrl9ZtGJ"
-		"anvnkr5pyl8NwCKyoZ7beOkrfzQ91H/fLPNTQKOCin8VdR41wgJbDyA88/1QEwGPiEOgoiu5Erf8r1n"
-		"rMY5K+mJmy8bzI/4W0WBlOp774W+eht4YWZhhtmvYf8cDVKSkSfXNSg7ojeOaiMVLT0ZJQmrPMAj1bC"
-		"7kPIrQVoq7cgF64BUzovKSkkq3uYrAaSp/uPI4Otkmp1O/fidwaOAOZhHZN3SgLgfuDBgBp3KrZIJkl"
-		"N4UbPBXzP54kQfIDms9T9Mm8HI2oFc1DZIZW/moCH30D+4aWGe84cstRVXMJYRmlefCd0rU1sM6fzRL"
-		"xw8R3AM41q05xkwacDn2L1BwqKPEL4YjyXem7mB14fPmIJX0Own0NB5o0dhszNQg+tzFWg/vDSiQ+6P"
-		"e3UBQzjIkbQk66ahxpOVPgAQxio96OXmc9OJxAo2zN4HauZdosHwDXA20RUBIXO/q50lvcztaoD7ZSv"
-		"DgYnkKDW8m1w/HeOR0SWZb++JLwGbzTnmns5oO2hAB9+R2AlkyS70ln0opsaSB8xmAGiI+21GrwoFB5"
-		"qGowhXnxcw2XiEZ6N9RUFPAXc2JIB4Lbdm8siLfcQ4Ysfc7XnOsZ5a/Ai6+EF7qZAL6E0cCKHuvz88A"
-		"JNw4B5n9UCII8e8lf8n2EiMdCRSFVOpfTiFQJBAm6VTpoukbqJiR8TZY+jIYUeSd9jcF3L049bMgBGA"
-		"EvsiJ5ygncG6eoh7q7sRKaswVtvS/o9/ucOXHPCBSj8EZE4F+r9lbWz/xauFQFB2tpFuHHp7pBgYxXV"
-		"nGwy0EV72vlLKNXrMJg3NMb9tUYE1hu2T+uKYeKIUWqY/wUeqcimo1THEPvREHzE58HrTr4SEen7L15"
-		"VO/s7k6UGM6BZppVJJNl0rCuMvKElaYAJwNxYwZoA/VbdVnkeQ81o/1nV6Zx8wJKg8NOTURcNR4SWlB"
-		"s6vLAo1Pi4tFHV+ImQAlzxxfBhS/IC/g3cHE/wncmSM/h1VRop6niEn0Sieo/FQd//l9egTE+EJtNRc"
-		"2oLz9TFjBD+ZlptJoA4QSQBvNqY929ItTizLuFfxAjfs8yoSCNF1RWW0NAQCAo4qCXgVoHzIrexWy/m"
-		"aFBl3j0hOkPovyHG32jORaKaLOCVSALVeKQ7Rum/hkYhxfH6Ec1pCRqgHzA5nvCvZaz3x4yvqcErnFW"
-		"hItA9TUPjOV5P/IgVLstZEGoU3/MNYZD5DouCxt+lZyPbpYX7/oYBL1rHs+gAlzASWWe/p8aY2YJt7J"
-		"YzeFJU4RG96Sb/zr1a5GzX0JTtzcRS/6olAOD78f1AF5OY4KmiWsRaCQPCr6BK/IoHU8qoDNn0UXzKl"
-		"65P+TLMoPzNhGjfH5D/XWmpiySS1Bn016rxnHQAHKRI3sujwefdwV7xPkvkWEaFCXtP7CODBPBcY4+z"
-		"oZaA5+NFq3T0uDo4FOJT+VOo8IO92CLzANuloi45L9pgeGtZ7VoymnOaxPhLJIFHmBX1/qesUu4Ip2g"
-		"jW+PN8HdbCgAgTkJnNR7xBesNZ+FLBAINwYv8J6EKjwgLFMW42S+uQpkR5wYaBrywqPYnFzAM1QRFxl"
-		"vZJQs4GMWLQooJPftaR+drNsYa4OsnY6wNCYAvgHtjgeBv4tmk6Li+InASvBu3WslaV9jMV+ERw9DWM"
-		"VOvRkQaf6YfteDL4DOp0+jXJMbfmhhueyQYXRis5CvRVOq/MQJBD2PFrsMPfRDgVT5xFw+mxArzSqRI"
-		"I1XhgCClrGtI25Yb0A3ZKSt67M8tqLX2hjMkZry/MUlHZyf7HD9zYYQ9/Vd8J2NMGA/WplmLA4C1jMP"
-		"fIx9MAUcpE1P5U6qJiSL02RVevNzFT6rDIgKiFkChdONF0Y0ZjUR44t3ae57DmcJsAt9fR6OcCkfg+U"
-		"JOw9DR+JgVsS7zwskab2OFR39rxwQEhG/3HqZETOa+1AqqRKTW60GuvIfJ1YrwXUKlwq8xfkT0rFm3G"
-		"XPL3tr3z2+CAzgkUr3CO3IHex0/r6Raq8KjAEykWs6aWNb/yy0dAACvAGdBtBleQZW4nftSN7FN1yNS"
-		"6Rdbvn/Y+h+6lAC8+jGyqgYZ6B1gGPDQa7UXGckw5cI4qeq/iCPyRu7mbRaJeJ7HS8yTblx8yCexwp5"
-		"+2546aZHIBiUFbGCwGMIGFfSKrAcaDCgNEbrdKy5hpHcyP/J48XMXD6QWUiycMoSc3ptwAfLBW6wzhT"
-		"In1D7L37mHbuSeTACom7hbefE5tX+NMnrGcaFawRpKKXca4zzghhYLgOD6Hf32UwLuUIE0sJDvJuKmM"
-		"1nmLgr0+gg/8v9Tk5CV1bWnjbzPbGIHnRo+4vcOi8w5vB+qTcsmZVDR1UXKp5Uc+ayKHKxDMlQ95HEX"
-		"8M8WuQTMJe52zi90xA9DPw58twYvuynQNa3W4g8FqF1rJ2JpglDhA5RSftKcfxcGK1gbVhiyrS/mUzl"
-		"0mZZJxv960rtyIPLGduyq54Q7cjKXrgYFwAgeZ26Mh7yXnoYf9YaAoQJEQPjBYI/t5gUEnKzhfzKHzS"
-		"t7oeZ2Y98vO7K/h5viyMJLJx37AUuUOEn5rjp6WDh3eBKHurnoEBiTX4GElOe70PPlLmyvBwgOt0gAf"
-		"AK8wi/FDaDmhrw/i1xm00esQ8kXEDxiFUL2Ddh0gRkf+i8gHu7EnkkZDDg9Ee3yVLo+lE3u9jwyN+Wx"
-		"9/I0CoK/dxjLG7wvKqk6KVogAmji0lQSvA539iuY0I4+d3TgmzpAcLBFAmA01llw07GS2QOa4Gfs51v"
-		"2iwXsls+QIbrSTaym1zYXYriyNUGE8EFAoog+W7BaQVcX3d7uRtdNeRR1dVEYg5ni1/xZSRq/lYSIsK"
-		"U6GbHz2kwFT+YwECiLc8k9LQ4AS4EPQNwMarptC1xvT843gMeplgB3YfIj9sov0LTpZH/lFlo7oCBU+"
-		"EKgBKhfH8SbJJz3cf0WELJ29aP9be2d1eoRSsXPuFcVU6Ias9XgTvbJiLHFTe8yFUaqFiNQ0FJtgPsB"
-		"RY9gHlhoOcvEoFrOEjdRpv5Cd93Axz5d4+IJsqJHD/KASiHANgeEUlCp6DpsJ4UaURGjIFVJ3E/m0Gd"
-		"GNt85gaCMCjGFP/Im800dXWkNpPAEgkQS1Lfkq9/zSJgDtNWLHg9ufiitkPSOiaeTTKIhZr+HjqKAYv"
-		"XTGN+5kgzxfxxVW+ijJZPAdo6I6jFKZp93iKLDaLNmcbEQLITa+kBbKwig9I4O+G/MgGGJVBjCPnNYw"
-		"EEfe5ZXoS2qQH+9FFUl4x68qC5mBOczlNPoRwJuzY9JfcPFOjoJuNjJPrmElfyPzwKuZlixaprGgbKB"
-		"5FZE6C6XgKMmBefuIHGXz/ngTKz0r5tbFAAA3gHtGpCRLuB0+/U4XfTVpMvz2MFWMrTNJJs3vbJTlJa"
-		"h3XGHJQEhKFSKzIALGOYOKstWsOko1rk6qdQ2WjrmtT6T9rIX3UQvutGJTNWJTC2NFBJJUAKBDz8VVI"
-		"rDlMj9HBJb2ckGtigPNYHQZTndkPTAoJCj5NMl4Nnel8XWGdlk+hUFm2vouaSSqldL8a6uJjcOz4WtP"
-		"OfRUmgW8G8QHzJAADzChVHfeYw8A+AfZGiv0V+MI1sD+N3vLH1805AgQ2YLgRTWul/7r9VLuKlfgWqm"
-		"EvpRwpWUcCc1/ALFFBQ/Zq/9eeT3Q1/1ucdJpxNKCfsZMJfB2uVsMDeBWMnSsIe4mk5iMO3Mn5OijaC"
-		"repAj2gIKzUsvRf/7v5A/vxS9x3pLA2ga+UohlLKqdYMbQfFiqvG0mosictERwC4U0LGelxAYlNIZHT"
-		"DRqKELKXTFSy7J+ElAEd7WsiNdSeMA5XQ+Xo1kz6eTTie0BCwgV4xjv3qZwdzMhmBk7zqgEz3FU+xSk"
-		"8gWP6VQ/RGrRChAd16A/s/PLOHfMQV95rPcISVPaAIlVVDgIiLCHP85UijhdLycQRIppAeXdwMvGyhm"
-		"KZmouKAXdOMw15KGP6SPX31ySqup4UU7sh0+VlHP8adgdUlrORpgHPvVJ8BoOwNGBE3Z03Czhz/QWXx"
-		"qFWKJj6nNzX7sJsQXr1hsnTYNo8SDlJJUzT40Mij8qzmAi1QOotjHUUpIohQFpNm3KyWLJLpSzun4aU"
-		"+P4MwMTRb14mYAOfSljH/hxU/HGI8kGUcy3uNo4phEAj+nmq8o5BAmAkEqCWThZxUGVTH7IAis+r+qF"
-		"qcBAjQfxBUhCJ8IooLBKoES8RZ7w5B/xyC0nhmoHpeiCtpBUhJi8mSUYTBL+cVtZuhEuRZBp5CRavYr"
-		"dE5Jju2oRZMynicZ6eCvp1PCJDpwoodNaiGawwCeZDvK0fUTWI2yf9dUdtwJO8ZzgSsi1NsboJLYpv0"
-		"nQvgPno22dyOqqBi1Efjr47D4BWsM0i8GmPG0pLIF7QO89svHsZ+zqZPO2BgRxA54G6SEQIYsG5Y6i3"
-		"XE/RtNKfwGAYBTD5Nr6KLNo0q+ZP//tN7wu3SE2o4amoc6+n2YPh2uGop+9W0BnqlBUbPDy+5Geeq+5"
-		"JLqcH5xSj3X+2PncCz137WpPbkGzwi6jjOEQZW6DvgJML0DHDyI0HOgSqCOjIO1WxFTf4Lr7AtRN90W"
-		"nMOZUVngnkaK4fqAc0iI0AKCdNo3+L0q2E3shpcjTzkAzOMbBTkqGM0YiOjTGfHwFtTi3jBnPaJfGVp"
-		"7N77Jd1rzzdDEwGCMNSzWGzNiduLUz8Ho6tgIVSRVIaDSHTeKup5SALBAsLE2GrgC9ccdlqAPZSB67E"
-		"XMWYt5ur3lcUMvhKlUXiD6F7bqF1HdaPs4brIhYonJaoQOEV5Sgi5gF6yMuHA6+5QDQPDJIh6tfwGs2"
-		"YGcPhqu3w6fPoo41AuhFJmOFziA0WjtrCXQJWLvwN0oRYQq5C+N9ChLt+8pC4C1ayE3t/b/P95sPfz0"
-		"T+BWgbjvPUR5KZLo42Ks0Gg57fFQ0iiDU4BOedh7+2PGB04k0lITtDUUGon4IxzZLqcsAAD2xyh+XeN"
-		"DLP8MuXYtAEVhnnqot7++Eas7wqOCimWUNnjLjEi7xkVCRFQw7ZQGQCxav8FeC28HYEuYpx66ibKaZF"
-		"z17B51rCGw0ohedKV0Ib+Bc/IOBw1LgUGNXa4sGjoY1+IAEGIkQWgihAjODs1eDJJZFzeF6vhIx0MZq"
-		"VE6YSGJeBvIGHRhssIOBen4cJFIDUaEBiht3QB4KfjXUlsEwlacHpKosVVzCnoDLwV7KMHauCECfCm8"
-		"SPkJc0YDlnGASjIAQXYwLhCph3a0bgDU0pwwdahIJBMdDRNFEkspaDBlqQFrHXoXdgFSUZhk8zrF6Mf"
-		"ZD1YDNnOIr+kKKFLxkYKLcnwOu5Gr2wBg0b+i1PFhBN0QgORbulLaQD1ziznM7qDraYbxIweNZHwcoS"
-		"MfUnbMRqEBrGIbi+kEKNz46GTnJRwOb5Nr0xdtAKh1/cJBUI2BH0V7u5Z8Dj70E8ycEVQx116HXUhyQ"
-		"7Zt/HiQQC4GBpJtdGQ1+49B81TxNkWsIc/WYT664wI0SvDhj2oV9kJTM725nRmUjXWapgpzC/uisxMT"
-		"PwbZ7OaH9Dgu5awo5jUSKSMZ8NMHHZBstwHREUmGHXoyMdll8+cHFNOZrLjTaC+FfEA6pp0QkoGfLFx"
-		"IwIdkDypiwgmgE1DYlAxvbsfGVWIdFnVWGHtr8JGDzlEklbSngqP0JbHeO3cGUEARr5OMh2QAeqAF/y"
-		"ulxj7ixyTN5omGhgs/lRhsQqMPB0iinQMHJYso5nOysGoC/HRB0Q6XvYUt7YBzpPDvp5G7gLZEDRAAZ"
-		"U0UwzrjRaFxyF6VsyjiCjTS6Ri2/05YGOko24EVlFFK96Bm6YYXt531I4B9gMcWVx4ayr63AA7hpxwd"
-		"8HIhRxlMeyRuNLx8w2E+IR1JKtauv4+sEDXvR7Eb6SD8X2CdBUAbAJzpOmqLjWupD4rDVFMa3GARJLC"
-		"fXAyS8JBCd2oopgwfJeiU0t6e/9Z33fjJBfQQ004g2YZJID0uG5O0kM814ACSimCF8mEySeEwEiuDAF"
-		"z46IwgwW4CJIBKajgQteYLrJPS/9ZcGN2MT+HlQ6wzBmopGS9dSKAUH4WIei5hVgQuE500jChNcRBJO"
-		"aEF6X76YKAIL1IvwUsxRths1jDJQpJur/UBQB3G5Kij/yBsO6eouTDZaMYAqHJ4x025zfAUFEe/Nz35"
-		"AAABiUlEQVTwUoHAjJppVk5vMpJ0dNwkhC0TGlCJj8OANyIeoDA4iEnnkJZe1sEGbtojqcCHHz8JGCT"
-		"jQqIH+13VYHIAiT8uX4cAi9s0QHxKBKqDccGIM4VIwkMSbhLwY+BGpxrwIzAwcKHZwgv9XQ1evAiq0C"
-		"hH2QEZFZMvafjojIGsg0cC6+yXIkyqo1LCnWgHcc5Fbn0AOA34zjEqeEM9x69C/lVYuwuh28surGNr6"
-		"pOfH6kffWQCabijMv1N/FQgKMVPTdQOX11jfgbrRLBWTgMdATia+pVSncyyMB8JmCQiSUQFtdOJXfMn"
-		"bRrAmcqD1vWpTQLoBexqykE0t3N0noCoLdpTlRQnsSFkS9AABlbCtqL1kKDVJ4TU0sWtzAISWAdptmk"
-		"Am9phNX9QTcwD1cg8K8HqBLYO+FEbAMIpF3gc+AGNv1G1GPgSqzYgkKeTBmTar2ygg22TGHZgqgBYb/"
-		"+mHGvzKrRS0R/yqsZq++6BRshpPMUDQcfzHFrIsqZHhWqasAtHc6b/D3cbSAuGcmWdAAAAAElFTkSuQmCC\" />";
-
-	const std::string HTTPConnection::itoopieFavicon =
-		"data:image/png;base64,"
-		"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv"
-		"8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My4wOGVynO"
-		"EAAAIzSURBVDhPjZNdSFNhGMf3nm3n7OzMs+8JtfJGzdlgoPtoWBrkqc1OsLTMKEY3eZOQbbS6aBVYO"
-		"oO8CKSLXEulQtZNahAM9Cq6lS533UUaeDEEKcN/79x7kbQT/eDhfPB7/u/7Poej08JqtXoEQbhoMpmG"
-		"ZFn2stf/h8nEZ4aHue1SiWBlhSCV4n41NBifBINBjina8DyfzOUIVlcJtrYINjcJ3rw1oFAg4HnjHaZ"
-		"p4/Ppv8zPH0G5XKZNPZibO4lKpYJ8vgOqqv+uKMq/d9Hfz/0sFr3w+/3IZt2YnbWhszOAxUUv0mkCs9"
-		"ncyNT6hEL6dYBgY4Ngd5eger+zU7sODHA/mpubzUytj9FofLa0VGv4s9bWCCTJUGSaNvSzXT3stuHDM"
-		"rc3xEqF4N2CERciURyyHfgqSZKPqfuxUMyC+OKcL4YHyl28nDFAPdqDZMcQ7tPnSfURUt0jMBgMH1nL"
-		"fkRRDPvcLds3otfhbRTwasaE8b6He43VSrT3QW3tBT3iPdbyN3T7Ibsor988H8OxtiaMx2sB1aBbCRW"
-		"R1hbQhbqYXh+6QkaJn8DZyzF09x6HeiaOTC6NK9cSsFqkb3aH3cLU+tCAx9l8FoXPBUy9n8LgyCCmS9"
-		"MYez0Gm9P2iWna0GOcDp8KY2JhAsnbSQS6Ahh9OgrlklINeM40bWhAkBd4SLIEh8cBURLhOeiBIArVA"
-		"U4yTRvJItk5PRehQVFaYfpbt9PBtTmdziaXyyUzjaHT/QZBQuKHAA0UxAAAAABJRU5ErkJggg==";
-
-	const char HTTP_COMMAND_TUNNELS[] = "tunnels";
-	const char HTTP_COMMAND_TRANSIT_TUNNELS[] = "transit_tunnels";
-	const char HTTP_COMMAND_TRANSPORTS[] = "transports";	
-	const char HTTP_COMMAND_START_ACCEPTING_TUNNELS[] = "start_accepting_tunnels";	
-	const char HTTP_COMMAND_STOP_ACCEPTING_TUNNELS[] = "stop_accepting_tunnels";	
-	const char HTTP_COMMAND_RUN_PEER_TEST[] = "run_peer_test";	
-	const char HTTP_COMMAND_LOCAL_DESTINATIONS[] = "local_destinations";
-	const char HTTP_COMMAND_LOCAL_DESTINATION[] = "local_destination";
-	const char HTTP_PARAM_BASE32_ADDRESS[] = "b32";
-	const char HTTP_COMMAND_SAM_SESSIONS[] = "sam_sessions";
-	const char HTTP_COMMAND_SAM_SESSION[] = "sam_session";
-	const char HTTP_PARAM_SAM_SESSION_ID[] = "id";
-	const char HTTP_COMMAND_I2P_TUNNELS[] = "i2p_tunnels";
-	
-	namespace misc_strings
-	{
-
-		const char name_value_separator[] = { ':', ' ' };
-		const char crlf[] = { '\r', '\n' };
-
-	} // namespace misc_strings
-
-	std::vector<boost::asio::const_buffer> HTTPConnection::reply::to_buffers(int status)
-	{
-		std::vector<boost::asio::const_buffer> buffers;
-		if (headers.size () > 0)
-		{
-			status_string = "HTTP/1.1 ";
-			status_string += std::to_string (status);
-			status_string += " ";
-			switch (status)
-			{
-				case 105: status_string += "Name Not Resolved"; break;
-                case 200: status_string += "OK"; break;
-                case 400: status_string += "Bad Request"; break;
-                case 404: status_string += "Not Found"; break;
-                case 408: status_string += "Request Timeout"; break;
-                case 500: status_string += "Internal Server Error"; break;
-                case 502: status_string += "Bad Gateway"; break;
-                case 503: status_string += "Not Implemented"; break;
-                case 504: status_string += "Gateway Timeout"; break;
-				default: status_string += "WTF";
-			}
-			buffers.push_back(boost::asio::buffer(status_string, status_string.size()));
-            buffers.push_back(boost::asio::buffer(misc_strings::crlf));
-			
-			for (std::size_t i = 0; i < headers.size(); ++i)
-			{
-				header& h = headers[i];
-				buffers.push_back(boost::asio::buffer(h.name));
-				buffers.push_back(boost::asio::buffer(misc_strings::name_value_separator));
-				buffers.push_back(boost::asio::buffer(h.value));
-				buffers.push_back(boost::asio::buffer(misc_strings::crlf));
-			}
-			buffers.push_back(boost::asio::buffer(misc_strings::crlf));
-		}
-		buffers.push_back(boost::asio::buffer(content));
-		return buffers;
-	}
-
-	void HTTPConnection::Terminate ()
-	{
-		if (!m_Stream) return;
-		m_Stream->Close ();
-		m_Stream = nullptr;
-		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& ecode, std::size_t bytes_transferred)
-	{
-		if (!ecode)
-  		{
-			if (!m_Stream) // new request
-			{
-				m_Buffer[bytes_transferred] = 0;
-				m_BufferLen = bytes_transferred;
-				RunRequest();
-			}
-			else // follow-on
-				m_Stream->Send ((uint8_t *)m_Buffer, bytes_transferred);
-			Receive ();
-		}
-		else if (ecode != boost::asio::error::operation_aborted)
-			Terminate ();
-	}
-
-	void HTTPConnection::RunRequest ()
-	{
-		auto address = ExtractAddress ();
-		if (address.length () > 1 && address[1] != '?') // not just '/' or '/?'
-		{
-			std::string uri ("/"), b32;
-			size_t pos = address.find ('/', 1);
-			if (pos == std::string::npos)
-				b32 = address.substr (1); // excluding leading '/' to end of line
-			else
-			{
-				b32 = address.substr (1, pos - 1); // excluding leading '/' to next '/'
-				uri = address.substr (pos); // rest of line
-			}
-
-			HandleDestinationRequest (b32, uri);
-		}
-		else
-			HandleRequest (address);
-	}
-
-	std::string HTTPConnection::ExtractAddress ()
-	{
-		char * get = strstr (m_Buffer, "GET");
-		if (get)
-		{
-			char * http = strstr (get, "HTTP");
-			if (http)
-				return std::string (get + 4, http - get - 5);
-		}
-		return "";
-	}
-
-	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 (eLogDebug, "HTTPServer: extracted parameters: ", 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& ecode)
-	{
-		if (ecode != 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::HandleWrite (const boost::system::error_code& ecode)
-	{
-		if (ecode || (m_Stream && !m_Stream->IsOpen ()))
-		{
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}	
-		else // data keeps coming
-			AsyncStreamReceive ();
-	}
-
-	void HTTPConnection::HandleRequest (const std::string& address)
-	{
-		std::stringstream s;
-		// Html5 head start
-		s << "<!DOCTYPE html>\r\n<html lang=\"en\">"; // TODO: Add support for locale.
-		s << "<head>\r\n<meta charset=\"utf-8\">\r\n"; // TODO: Find something to parse html/template system. This is horrible.
-		s << "<link rel='shortcut icon' href='" + itoopieFavicon + "'>\r\n";
-		s << "<title>Purple I2P " << VERSION " Webconsole</title>\r\n";
-		s << "<style>\r\n";
-		s << "body {font: 100%/1.5em sans-serif; margin: 0; padding: 1.5em; background: #FAFAFA; color: #103456;}";
-		s << "a {text-decoration: none; color: #894C84;}";
-		s << "a:hover {color: #FAFAFA; background: #894C84;}";
-		s << ".header {font-size: 2.5em; text-align: center; margin: 1.5em 0; color: #894C84;}";
-		s << ".wrapper {margin: 0 auto; padding: 1em; max-width: 60em;}";
-		s << ".left {float: left; position: absolute;}";
-		s << ".right {font-size: 1em; margin-left: 13em; float: left; max-width: 46em; overflow: auto;}";
-		s << ".established_tunnel {color: #56b734;}";
-		s << ".expiring_tunnel {color: #d3ae3f;}";
-		s << ".failed_tunnel {color: #d33f3f;}";
-		s << ".another_tunnel {color: #434343;}";
-		s << "caption {font-size: 1.5em; text-align: center; color: #894C84;}";
-		s << "table {width: 100%; border-collapse: collapse; text-align: center;}";
-		s << "</style>\r\n</head>\r\n<body>\r\n";
-		s << "<div class=header><b>i2pd </b>webconsole</div>";
-		s << "<div class=wrapper>";
-		s << "<div class=left>\r\n";
-		s << "<a href=/>Main page</a><br>\r\n<br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_LOCAL_DESTINATIONS << ">Local destinations</a><br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_TUNNELS << ">Tunnels</a><br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_TRANSIT_TUNNELS << ">Transit tunnels</a><br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_TRANSPORTS << ">Transports</a><br>\r\n<br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_I2P_TUNNELS << ">I2P tunnels</a><br>\r\n";
-		if (i2p::client::context.GetSAMBridge ())
-			s << "<a href=/?" << HTTP_COMMAND_SAM_SESSIONS << ">SAM sessions</a><br>\r\n<br>\r\n";
-		if (i2p::context.AcceptsTunnels ())
-			s << "<a href=/?" << HTTP_COMMAND_STOP_ACCEPTING_TUNNELS << ">Stop accepting tunnels</a><br>\r\n<br>\r\n";
-		else	
-			s << "<a href=/?" << HTTP_COMMAND_START_ACCEPTING_TUNNELS << ">Start accepting tunnels</a><br>\r\n<br>\r\n";
-		s << "<a href=/?" << HTTP_COMMAND_RUN_PEER_TEST << ">Run peer test</a><br>\r\n<br>\r\n";
-		s << "</div><div class=right>";
-		if (address.length () > 1)
-			HandleCommand (address.substr (2), s);
-		else			
-			FillContent (s);
-		s << "</div></div>\r\n</body>\r\n</html>";
-		SendReply (s.str ());
-	}
-
-	void HTTPConnection::FillContent (std::stringstream& s)
-	{
-		s << "<b>Uptime:</b> " << boost::posix_time::to_simple_string (
-			boost::posix_time::time_duration (boost::posix_time::seconds (
-			i2p::context.GetUptime ()))) << "<br>\r\n";
-		s << "<b>Status:</b> ";
-		switch (i2p::context.GetStatus ())
-		{
-			case eRouterStatusOK: s << "OK"; break;
-			case eRouterStatusTesting: s << "Testing"; break;
-			case eRouterStatusFirewalled: s << "Firewalled"; break; 
-			default: s << "Unknown";
-		} 
-		s << "<br>\r\n";
-		s << "<b>Tunnel creation success rate:</b> " << i2p::tunnel::tunnels.GetTunnelCreationSuccessRate () << "%<br>\r\n";
-		s << "<b>Received:</b> " << i2p::transport::transports.GetTotalReceivedBytes ()/1000 << "K";
-		s << " (" << i2p::transport::transports.GetInBandwidth () <<" Bps)<br>\r\n";
-		s << "<b>Sent:</b> " << i2p::transport::transports.GetTotalSentBytes ()/1000 << "K";
-		s << " (" << i2p::transport::transports.GetOutBandwidth () <<" Bps)<br>\r\n";
-		s << "<b>Data path:</b> " << i2p::fs::GetDataDir() << "<br>\r\n<br>\r\n";
-		s << "<b>Our external address:</b>" << "<br>\r\n" ;
-		for (auto& address : i2p::context.GetRouterInfo().GetAddresses())
-		{
-			switch (address.transportStyle)
-			{
-				case i2p::data::RouterInfo::eTransportNTCP:
-					if (address.host.is_v6 ())
-						s << "NTCP6&nbsp;&nbsp;";
-					else
-						s << "NTCP&nbsp;&nbsp;";
-				break;
-				case i2p::data::RouterInfo::eTransportSSU:
-					if (address.host.is_v6 ())
-						s << "SSU6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;";
-					else
-						s << "SSU&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;";
-				break;
-				default:
-					s << "Unknown&nbsp;&nbsp;";
-			}
-			s << address.host.to_string() << ":" << address.port << "<br>\r\n";
-		}
-		s << "<br>\r\n<b>Routers:</b> " << i2p::data::netdb.GetNumRouters () << " ";
-		s << "<b>Floodfills:</b> " << i2p::data::netdb.GetNumFloodfills () << " ";
-		s << "<b>LeaseSets:</b> " << i2p::data::netdb.GetNumLeaseSets () << "<br>\r\n";
-
-		size_t clientTunnelCount = i2p::tunnel::tunnels.CountOutboundTunnels();
-		clientTunnelCount += i2p::tunnel::tunnels.CountInboundTunnels();
-		size_t transitTunnelCount = i2p::tunnel::tunnels.CountTransitTunnels();
-		
-		s << "<b>Client Tunnels:</b> " << std::to_string(clientTunnelCount) << " ";
-		s << "<b>Transit Tunnels:</b> " << std::to_string(transitTunnelCount) << "<br>\r\n";
-	}
-
-	void HTTPConnection::HandleCommand (const std::string& command, std::stringstream& s)
-	{
-		size_t paramsPos = command.find('&');
-		std::string cmd = command.substr (0, paramsPos);
-		if (cmd == HTTP_COMMAND_TRANSPORTS)
-			ShowTransports (s);
-		else if (cmd == HTTP_COMMAND_TUNNELS)
-			ShowTunnels (s);
-		else if (cmd == HTTP_COMMAND_TRANSIT_TUNNELS)
-			ShowTransitTunnels (s);
-		else if (cmd == HTTP_COMMAND_START_ACCEPTING_TUNNELS)
-			StartAcceptingTunnels (s);
-		else if (cmd == HTTP_COMMAND_STOP_ACCEPTING_TUNNELS)
-			StopAcceptingTunnels (s);
-		else if (cmd == HTTP_COMMAND_RUN_PEER_TEST)
-			RunPeerTest (s);
-		else if (cmd == HTTP_COMMAND_LOCAL_DESTINATIONS)
-			ShowLocalDestinations (s);	
-		else if (cmd == HTTP_COMMAND_LOCAL_DESTINATION)
-		{
-			std::map<std::string, std::string> params;
-			ExtractParams (command.substr (paramsPos), params);
-			auto b32 = params[HTTP_PARAM_BASE32_ADDRESS];
-			ShowLocalDestination (b32, s);
-		}	
-		else if (cmd == HTTP_COMMAND_SAM_SESSIONS)
-			ShowSAMSessions (s);
-		else if (cmd == HTTP_COMMAND_SAM_SESSION)
-		{
-			std::map<std::string, std::string> params;
-			ExtractParams (command.substr (paramsPos), params);
-			auto id = params[HTTP_PARAM_SAM_SESSION_ID];
-			ShowSAMSession (id, s);
-		}	
-		else if (cmd == HTTP_COMMAND_I2P_TUNNELS)
-			ShowI2PTunnels (s);
-	}	
-
-	void HTTPConnection::ShowLocalDestinations (std::stringstream& s)
-	{
-		s << "<b>Local Destinations:</b><br>\r\n<br>\r\n";
-		for (auto& it: i2p::client::context.GetDestinations ())
-		{
-			auto ident = it.second->GetIdentHash ();; 
-			s << "<a href=/?" << HTTP_COMMAND_LOCAL_DESTINATION;
-			s << "&" << HTTP_PARAM_BASE32_ADDRESS << "=" << ident.ToBase32 () << ">"; 
-			s << i2p::client::context.GetAddressBook ().ToAddress(ident) << "</a><br>\r\n" << std::endl;
-		}
-	}
-
-	void  HTTPConnection::ShowLocalDestination (const std::string& b32, std::stringstream& s)
-	{
-		s << "<b>Local Destination:</b><br>\r\n<br>\r\n";
-		i2p::data::IdentHash ident;
-		ident.FromBase32 (b32);
-		auto dest = i2p::client::context.FindLocalDestination (ident);
-		if (dest)
-		{
-			s << "<b>Base64:</b><br>\r\n<textarea readonly=\"readonly\" cols=\"64\" rows=\"1\" wrap=\"off\">";
-			s << dest->GetIdentity ()->ToBase64 () << "</textarea><br>\r\n<br>\r\n";
-			s << "<b>LeaseSets:</b> <i>" << dest->GetNumRemoteLeaseSets () << "</i><br>\r\n";
-			auto pool = dest->GetTunnelPool ();
-			if (pool)
-			{
-				s << "<b>Tunnels:</b><br>\r\n";
-				for (auto it: pool->GetOutboundTunnels ())
-				{
-					it->Print (s);
-					auto state = it->GetState ();
-					if (state == i2p::tunnel::eTunnelStateFailed)
-						s << " " << "Failed";
-					else if (state == i2p::tunnel::eTunnelStateExpiring)
-						s << " " << "Exp";
-					s << "<br>\r\n" << std::endl;
-				}
-				for (auto it: pool->GetInboundTunnels ())
-				{
-					it->Print (s);
-					auto state = it->GetState ();
-					if (state == i2p::tunnel::eTunnelStateFailed)
-						s << " " << "Failed";
-					else if (state == i2p::tunnel::eTunnelStateExpiring)
-						s << " " << "Exp";
-					s << "<br>\r\n" << std::endl;
-				}
-			}	
-			s << "<b>Tags</b><br>Incoming: " << dest->GetNumIncomingTags () << "<br>Outgoing:<br>" << std::endl;
-			for (auto it: dest->GetSessions ())
-			{
-				s << i2p::client::context.GetAddressBook ().ToAddress(it.first) << " ";
-				s << it.second->GetNumOutgoingTags () << "<br>" << std::endl;
-			}	
-			s << "<br>" << std::endl;
-			// s << "<br>\r\n<b>Streams:</b><br>\r\n";
-			// for (auto it: dest->GetStreamingDestination ()->GetStreams ())
-			// {	
-				// s << it.first << "->" << i2p::client::context.GetAddressBook ().ToAddress(it.second->GetRemoteIdentity ()) << " ";
-				// s << " [" << it.second->GetNumSentBytes () << ":" << it.second->GetNumReceivedBytes () << "]";
-				// s << " [out:" << it.second->GetSendQueueSize () << "][in:" << it.second->GetReceiveQueueSize () << "]";
-				// s << "[buf:" << it.second->GetSendBufferSize () << "]";
-				// s << "[RTT:" << it.second->GetRTT () << "]";
-				// s << "[Window:" << it.second->GetWindowSize () << "]";
-				// s << "[Status:" << (int)it.second->GetStatus () << "]"; 
-				// s << "<br>\r\n"<< std::endl; 
-			// }	
-			s << "<br>\r\n<table><caption>Streams</caption><tr>";
-			s << "<th>StreamID</th>";
-			s << "<th>Destination</th>";
-			s << "<th>Sent</th>";
-			s << "<th>Received</th>";
-			s << "<th>Out</th>";
-			s << "<th>In</th>";
-			s << "<th>Buf</th>";
-			s << "<th>RTT</th>";
-			s << "<th>Window</th>";
-			s << "<th>Status</th>";
-			s << "</tr>";
-
-			for (auto it: dest->GetStreamingDestination ()->GetStreams ())
-			{	
-				s << "<tr>";
-				s << "<td>" << it.first << "</td>";
-				s << "<td>" << i2p::client::context.GetAddressBook ().ToAddress(it.second->GetRemoteIdentity ()) << "</td>";
-				s << "<td>" << it.second->GetNumSentBytes () << "</td>";
-				s << "<td>" << it.second->GetNumReceivedBytes () << "</td>";
-				s << "<td>" << it.second->GetSendQueueSize () << "</td>";
-				s << "<td>" << it.second->GetReceiveQueueSize () << "</td>";
-				s << "<td>" << it.second->GetSendBufferSize () << "</td>";
-				s << "<td>" << it.second->GetRTT () << "</td>";
-				s << "<td>" << it.second->GetWindowSize () << "</td>";
-				s << "<td>" << (int)it.second->GetStatus () << "</td>";
-				s << "</tr><br>\r\n" << std::endl; 
-			}
-		}	
-	}
-
-	void HTTPConnection::ShowTunnels (std::stringstream& s)
-	{
-		s << "<b>Tunnels:</b><br>\r\n<br>\r\n";
-		s << "<b>Queue size:</b> " << i2p::tunnel::tunnels.GetQueueSize () << "<br>\r\n";
-		for (auto it: i2p::tunnel::tunnels.GetOutboundTunnels ())
-		{
-			it->Print (s);
-			auto state = it->GetState ();
-			if (state == i2p::tunnel::eTunnelStateFailed)
-				s << "<span class=failed_tunnel> " << "Failed</span>";
-			else if (state == i2p::tunnel::eTunnelStateExpiring)
-				s << "<span class=expiring_tunnel> " << "Exp</span>";
-			s << " " << (int)it->GetNumSentBytes () << "<br>\r\n";
-			s << std::endl;
-		}
-
-		for (auto it: i2p::tunnel::tunnels.GetInboundTunnels ())
-		{
-			it->Print (s);
-			auto state = it->GetState ();
-			if (state == i2p::tunnel::eTunnelStateFailed)
-				s << "<span class=failed_tunnel> " << "Failed</span>";
-			else if (state == i2p::tunnel::eTunnelStateExpiring)
-				s << "<span class=expiring_tunnel> " << "Exp</span>";
-			s << " " << (int)it->GetNumReceivedBytes () << "<br>\r\n";
-			s << std::endl;
-		}
-	}	
-
-	void HTTPConnection::ShowTransitTunnels (std::stringstream& s)
-	{
-		s << "<b>Transit tunnels:</b><br>\r\n<br>\r\n";
-		for (auto it: i2p::tunnel::tunnels.GetTransitTunnels ())
-		{
-			if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelGateway>(it))
-				s << it->GetTunnelID () << " ⇒ ";
-			else if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelEndpoint>(it))
-				s << " ⇒ " << it->GetTunnelID ();
-			else
-				s << " ⇒ " << it->GetTunnelID () << " ⇒ ";
-			s << " " << it->GetNumTransmittedBytes () << "<br>\r\n";
-		}
-	}
-
-	void HTTPConnection::ShowTransports (std::stringstream& s)
-	{
-		s << "<b>Transports:</b><br>\r\n<br>\r\n";
-		auto ntcpServer = i2p::transport::transports.GetNTCPServer (); 
-		if (ntcpServer)
-		{	
-			s << "<b>NTCP</b><br>\r\n";
-			for (auto it: ntcpServer->GetNTCPSessions ())
-			{
-				if (it.second && it.second->IsEstablished ())
-				{
-					// incoming connection doesn't have remote RI
-					if (it.second->IsOutgoing ()) s << " ⇒ ";
-					s << i2p::data::GetIdentHashAbbreviation (it.second->GetRemoteIdentity ()->GetIdentHash ()) <<  ": "
-						<< it.second->GetSocket ().remote_endpoint().address ().to_string ();
-					if (!it.second->IsOutgoing ()) s << " ⇒ ";
-					s << " [" << it.second->GetNumSentBytes () << ":" << it.second->GetNumReceivedBytes () << "]";
-					s << "<br>\r\n" << std::endl;
-				}
-			}
-		}	
-		auto ssuServer = i2p::transport::transports.GetSSUServer ();
-		if (ssuServer)
-		{
-			s << "<br>\r\n<b>SSU</b><br>\r\n";
-			for (auto it: ssuServer->GetSessions ())
-			{
-				auto endpoint = it.second->GetRemoteEndpoint ();
-				if (it.second->IsOutgoing ()) s << " ⇒ ";
-				s << endpoint.address ().to_string () << ":" << endpoint.port ();
-				if (!it.second->IsOutgoing ()) s << " ⇒ ";
-				s << " [" << it.second->GetNumSentBytes () << ":" << it.second->GetNumReceivedBytes () << "]";
-				if (it.second->GetRelayTag ())
-					s << " [itag:" << it.second->GetRelayTag () << "]";
-				s << "<br>\r\n" << std::endl;
-			}
-			s << "<br>\r\n<b>SSU6</b><br>\r\n";
-			for (auto it: ssuServer->GetSessionsV6 ())
-			{
-				auto endpoint = it.second->GetRemoteEndpoint ();
-				if (it.second->IsOutgoing ()) s << " ⇒ ";
-				s << endpoint.address ().to_string () << ":" << endpoint.port ();
-				if (!it.second->IsOutgoing ()) s << " ⇒ ";
-				s << " [" << it.second->GetNumSentBytes () << ":" << it.second->GetNumReceivedBytes () << "]";
-				s << "<br>\r\n" << std::endl;
-			}
-		}
-	}
-	
-	void HTTPConnection::ShowSAMSessions (std::stringstream& s)
-	{
-		s << "<b>SAM Sessions:</b><br>\r\n<br>\r\n";
-		auto sam = i2p::client::context.GetSAMBridge ();
-		if (sam)
-		{	
-			for (auto& it: sam->GetSessions ())
-			{
-				s << "<a href=/?" << HTTP_COMMAND_SAM_SESSION;
-				s << "&" << HTTP_PARAM_SAM_SESSION_ID << "=" << it.first << ">";
-				s << it.first << "</a><br>\r\n" << std::endl;
-			}	
-		}	
-	}	
-
-	void HTTPConnection::ShowSAMSession (const std::string& id, std::stringstream& s)
-	{
-		s << "<b>SAM Session:</b><br>\r\n<br>\r\n";
-		auto sam = i2p::client::context.GetSAMBridge ();
-		if (sam)
-		{
-			auto session = sam->FindSession (id);
-			if (session)
-			{
-				auto& ident = session->localDestination->GetIdentHash();
-				s << "<a href=/?" << HTTP_COMMAND_LOCAL_DESTINATION;
-				s << "&" << HTTP_PARAM_BASE32_ADDRESS << "=" << ident.ToBase32 () << ">"; 
-				s << i2p::client::context.GetAddressBook ().ToAddress(ident) << "</a><br>\r\n" << std::endl;
-				s << "<b>Streams:</b><br>\r\n";
-				for (auto it: session->sockets)
-				{
-					switch (it->GetSocketType ())
-					{
-						case i2p::client::eSAMSocketTypeSession:
-							s << "session";
-						break;	
-						case i2p::client::eSAMSocketTypeStream:
-							s << "stream";
-						break;	
-						case i2p::client::eSAMSocketTypeAcceptor:
-							s << "acceptor";
-						break;
-						default:
-							s << "unknown";
-					}
-					s << " [" << it->GetSocket ().remote_endpoint() << "]";
-					s << "<br>\r\n" << std::endl;
-				}	
-			}
-		}	
-	}	
-
-	void HTTPConnection::ShowI2PTunnels (std::stringstream& s)
-	{
-		s << "<b>Client Tunnels:</b><br>\r\n<br>\r\n";
-		for (auto& it: i2p::client::context.GetClientTunnels ())
-		{
-			s << it.second->GetName () << " ⇐ ";
-			auto& ident = it.second->GetLocalDestination ()->GetIdentHash();
-			s << "<a href=/?" << HTTP_COMMAND_LOCAL_DESTINATION;
-			s << "&" << HTTP_PARAM_BASE32_ADDRESS << "=" << ident.ToBase32 () << ">"; 
-			s << i2p::client::context.GetAddressBook ().ToAddress(ident);
-			s << "</a><br>\r\n"<< std::endl;
-		}	
-		s << "<br>\r\n<b>Server Tunnels:</b><br>\r\n<br>\r\n";
-		for (auto& it: i2p::client::context.GetServerTunnels ())
-		{
-			s << it.second->GetName () << " ⇒ ";
-			auto& ident = it.second->GetLocalDestination ()->GetIdentHash();
-			s << "<a href=/?" << HTTP_COMMAND_LOCAL_DESTINATION;
-			s << "&" << HTTP_PARAM_BASE32_ADDRESS << "=" << ident.ToBase32 () << ">"; 
-			s << i2p::client::context.GetAddressBook ().ToAddress(ident);
-			s << ":" << it.second->GetLocalPort ();
-			s << "</a><br>\r\n"<< std::endl;
-		}	
-	}	
-	
-	void HTTPConnection::StopAcceptingTunnels (std::stringstream& s)
-	{
-		s << "<b>Stop Accepting Tunnels:</b><br>\r\n<br>\r\n";
-		i2p::context.SetAcceptsTunnels (false);
-		s << "Accepting tunnels stopped" <<  std::endl;
-	}
-
-	void HTTPConnection::StartAcceptingTunnels (std::stringstream& s)
-	{
-		s << "<b>Start Accepting Tunnels:</b><br>\r\n<br>\r\n";
-		i2p::context.SetAcceptsTunnels (true);
-		s << "Accepting tunnels started" <<  std::endl;		
-	}
-
-	void HTTPConnection::RunPeerTest (std::stringstream& s)
-	{
-		s << "<b>Run Peer Test:</b><br>\r\n<br>\r\n";
-		i2p::transport::transports.PeerTest ();
-		s << "Peer test is running" <<  std::endl;
-	}
-
-	void HTTPConnection::HandleDestinationRequest (const std::string& address, const std::string& uri)
-	{
-		std::string request = "GET " + uri + " HTTP/1.1\r\nHost:" + address + "\r\n\r\n";
-		LogPrint(eLogInfo, "HTTPServer: client request: ", request);
-		SendToAddress (address, 80, request.c_str (), request.size ());		
-	}
-
-	void HTTPConnection::SendToAddress (const std::string& address, int port, const char * buf, size_t len)
-	{	
-		i2p::data::IdentHash destination;
-		if (!i2p::client::context.GetAddressBook ().GetIdentHash (address, destination))
-		{
-			LogPrint (eLogWarning, "HTTPServer: Unknown address ", address);
-			SendReply ("<html>" + itoopieImage + "<br>\r\nUnknown address " + address + "</html>", 404);
-			return;
-		}		
-
-		auto leaseSet = i2p::client::context.GetSharedLocalDestination ()->FindLeaseSet (destination);
-		if (leaseSet && !leaseSet->IsExpired ())
-			SendToDestination (leaseSet, port, buf, len);
-		else
-		{
-			memcpy (m_Buffer, buf, len);
-			m_BufferLen = len;
-			i2p::client::context.GetSharedLocalDestination ()->RequestDestination (destination);
-			m_Timer.expires_from_now (boost::posix_time::seconds(HTTP_DESTINATION_REQUEST_TIMEOUT));
-			m_Timer.async_wait (std::bind (&HTTPConnection::HandleDestinationRequestTimeout,
-				shared_from_this (), std::placeholders::_1, destination, port, m_Buffer, m_BufferLen));
-		}
-	}
-	
-	void HTTPConnection::HandleDestinationRequestTimeout (const boost::system::error_code& ecode, 
-		i2p::data::IdentHash destination, int port, const char * buf, size_t len)
-	{	
-		if (ecode != boost::asio::error::operation_aborted)
-		{	
-			auto leaseSet = i2p::client::context.GetSharedLocalDestination ()->FindLeaseSet (destination);
-			if (leaseSet && !leaseSet->IsExpired ())
-				SendToDestination (leaseSet, port, buf, len);
-			else
-				// still no LeaseSet
-				SendReply (leaseSet ? "<html>" + itoopieImage + "<br>\r\nLeases expired</html>" : "<html>" + itoopieImage + "LeaseSet not found</html>", 504);
-		}
-	}	
-	
-	void HTTPConnection::SendToDestination (std::shared_ptr<const i2p::data::LeaseSet> remote, int port, const char * buf, size_t len)
-	{
-		if (!m_Stream)
-			m_Stream = i2p::client::context.GetSharedLocalDestination ()->CreateStream (remote, port);
-		if (m_Stream)
-		{
-			m_Stream->Send ((uint8_t *)buf, len);
-			AsyncStreamReceive ();
-		}
-	}
-
-	void HTTPConnection::AsyncStreamReceive ()
-	{
-		if (m_Stream)
-			m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, 8192),
-				std::bind (&HTTPConnection::HandleStreamReceive, shared_from_this (),
-					std::placeholders::_1, std::placeholders::_2),
-				45); // 45 seconds timeout
-	}
-
-	void HTTPConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (!ecode)
-		{
-			boost::asio::async_write (*m_Socket, boost::asio::buffer (m_StreamBuffer, bytes_transferred),
-        		std::bind (&HTTPConnection::HandleWrite, shared_from_this (), std::placeholders::_1));
-		}
-		else
-		{
-			if (ecode == boost::asio::error::timed_out)
-				SendReply ("<html>" + itoopieImage + "<br>\r\nNot responding</html>", 504);
-			else if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-	}
-
-	void HTTPConnection::SendReply (const std::string& content, int status)
-	{
-		m_Reply.content = content;
-		m_Reply.headers.resize(3);
-        // we need the date header to be complaint 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.headers[0].name = "Date";
-            m_Reply.headers[0].value = std::string(time_buff);
-            m_Reply.headers[1].name = "Content-Length";
-            m_Reply.headers[1].value = boost::lexical_cast<std::string>(m_Reply.content.size());
-            m_Reply.headers[2].name = "Content-Type";
-            m_Reply.headers[2].value = "text/html";
-        }
-		
-		boost::asio::async_write (*m_Socket, m_Reply.to_buffers(status),
-			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))
-	{
-	}
-
-	HTTPServer::~HTTPServer ()
-	{
-		Stop ();
-	}
-
-	void HTTPServer::Start ()
-	{
-		m_Thread = std::unique_ptr<std::thread>(new std::thread (std::bind (&HTTPServer::Run, this)));
-		m_Acceptor.listen ();
-		Accept ();
-	}
-
-	void HTTPServer::Stop ()
-	{
-		m_Acceptor.close();
-		m_Service.stop ();
-		if (m_Thread)
-        {
-            m_Thread->join ();
-            m_Thread = nullptr;
-        }
-	}
-
-	void HTTPServer::Run ()
-	{
-		m_Service.run ();
-	}
-
-	void HTTPServer::Accept ()
-	{
-		auto newSocket = std::make_shared<boost::asio::ip::tcp::socket> (m_Service);
-		m_Acceptor.async_accept (*newSocket, boost::bind (&HTTPServer::HandleAccept, this,
-			boost::asio::placeholders::error, newSocket));
-	}
-
-	void HTTPServer::HandleAccept(const boost::system::error_code& ecode, 
-		std::shared_ptr<boost::asio::ip::tcp::socket> newSocket)
-	{
-		if (!ecode)
-		{
-			CreateConnection(newSocket);
-			Accept ();
-		}
-	}
-
-	void HTTPServer::CreateConnection(std::shared_ptr<boost::asio::ip::tcp::socket> newSocket)
-	{
-		auto conn = std::make_shared<HTTPConnection> (newSocket);
-		conn->Receive ();
-	}
-}
-}
-
-
-

HTTPServer.h

@@ -1,138 +0,0 @@
-#ifndef HTTP_SERVER_H__
-#define HTTP_SERVER_H__
-
-#include <sstream>
-#include <thread>
-#include <memory>
-#include <boost/asio.hpp>
-#include <boost/array.hpp>
-#include "LeaseSet.h"
-#include "Streaming.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>
-	{
-		protected:
-
-			struct header
-			{
-			  std::string name;
-			  std::string value;
-			};
-
-			struct request
-			{
-			  std::string method;
-			  std::string uri;
-			  std::string host;
-		      int port;	
-			  int http_version_major;
-			  int http_version_minor;
-			  std::vector<header> headers;
-			};
-
-			struct reply
-			{
-				std::vector<header> headers;
-				std::string status_string, content;
-				std::vector<boost::asio::const_buffer> to_buffers (int status);
-			};
-
-		public:
-
-			HTTPConnection (std::shared_ptr<boost::asio::ip::tcp::socket> socket): 
-				m_Socket (socket), m_Timer (socket->get_io_service ()), 
-				m_Stream (nullptr), m_BufferLen (0) {};
-			void Receive ();
-			
-		private:
-
-			void Terminate ();
-			void HandleReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
-			void AsyncStreamReceive ();
-			void HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred);
-			void HandleWriteReply(const boost::system::error_code& ecode);
-			void HandleWrite (const boost::system::error_code& ecode);
-			void SendReply (const std::string& content, int status = 200);
-
-			void HandleRequest (const std::string& address);
-			void HandleCommand (const std::string& command, std::stringstream& s);
-			void ShowTransports (std::stringstream& s);
-			void ShowTunnels (std::stringstream& s);
-			void ShowTransitTunnels (std::stringstream& s);
-			void ShowLocalDestinations (std::stringstream& s);
-			void ShowLocalDestination (const std::string& b32, std::stringstream& s);
-			void ShowSAMSessions (std::stringstream& s);
-			void ShowSAMSession (const std::string& id, std::stringstream& s);
-			void ShowI2PTunnels (std::stringstream& s);
-			void StartAcceptingTunnels (std::stringstream& s);
-			void StopAcceptingTunnels (std::stringstream& s);
-			void RunPeerTest (std::stringstream& s);
-			void FillContent (std::stringstream& s);
-			std::string ExtractAddress ();
-			void ExtractParams (const std::string& str, std::map<std::string, std::string>& params);
-			
-			
-		protected:
-
-			std::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
-			boost::asio::deadline_timer m_Timer;
-			std::shared_ptr<i2p::stream::Stream> m_Stream;
-			char m_Buffer[HTTP_CONNECTION_BUFFER_SIZE + 1], m_StreamBuffer[HTTP_CONNECTION_BUFFER_SIZE + 1];
-			size_t m_BufferLen;
-			request m_Request;
-			reply m_Reply;
-
-		protected:
-	
-			virtual void RunRequest ();
-			void HandleDestinationRequest(const std::string& address, const std::string& uri);
-			void SendToAddress (const std::string& address, int port, const char * buf, size_t len);
-			void HandleDestinationRequestTimeout (const boost::system::error_code& ecode, 
-				i2p::data::IdentHash destination, int port, const char * buf, size_t len);
-			void SendToDestination (std::shared_ptr<const i2p::data::LeaseSet> remote, int port, const char * buf, size_t len);
-
-		public:
-
-			static const std::string itoopieImage;
-			static const std::string itoopieFavicon;
-	};
-
-	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,
-				std::shared_ptr<boost::asio::ip::tcp::socket> newSocket);
-			
-		private:
-
-			std::unique_ptr<std::thread> m_Thread;
-			boost::asio::io_service m_Service;
-			boost::asio::io_service::work m_Work;
-			boost::asio::ip::tcp::acceptor m_Acceptor;
-
-		protected:
-			virtual void CreateConnection(std::shared_ptr<boost::asio::ip::tcp::socket> newSocket);
-	};
-}
-}
-
-#endif
-
-

I2PService.cpp

@@ -1,211 +0,0 @@
-#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, "I2PService: Remote destination ", dest, " not found");
-			streamRequestComplete (nullptr);
-		}
-	}
-
-	TCPIPPipe::TCPIPPipe(I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> upstream, std::shared_ptr<boost::asio::ip::tcp::socket> downstream) : I2PServiceHandler(owner), m_up(upstream), m_down(downstream) {}
-
-	TCPIPPipe::~TCPIPPipe()
-	{
-		Terminate();
-	}
-	
-	void TCPIPPipe::Start()
-	{
-		AsyncReceiveUpstream();
-		AsyncReceiveDownstream();
-	}
-
-	void TCPIPPipe::Terminate()
-	{
-		if(Kill()) return;
-		Done(shared_from_this());
-		if (m_up) {
-			if (m_up->is_open()) {
-				m_up->close();
-			}
-			m_up = nullptr;
-		}
-		if (m_down) {
-			if (m_down->is_open()) {
-				m_down->close();
-			}
-			m_down = nullptr;
-		}
-	}
-	
-	void TCPIPPipe::AsyncReceiveUpstream()
-	{
-		if (m_up) {
-			m_up->async_read_some(boost::asio::buffer(m_upstream_to_down_buf, TCP_IP_PIPE_BUFFER_SIZE),
-															std::bind(&TCPIPPipe::HandleUpstreamReceived, shared_from_this(),
-																				std::placeholders::_1, std::placeholders::_2));
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: no upstream socket for read");
-		}
-	}
-
-	void TCPIPPipe::AsyncReceiveDownstream()
-	{
-		if (m_down) {
-			m_down->async_read_some(boost::asio::buffer(m_downstream_to_up_buf, TCP_IP_PIPE_BUFFER_SIZE),
-															std::bind(&TCPIPPipe::HandleDownstreamReceived, shared_from_this(),
-																				std::placeholders::_1, std::placeholders::_2));
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: no downstream socket for read");
-		}
-	}
-
-	void TCPIPPipe::UpstreamWrite(const uint8_t * buf, size_t len)
-	{
-		if (m_up) {
-			LogPrint(eLogDebug, "TCPIPPipe: write upstream ", (int)len);
-			boost::asio::async_write(*m_up, boost::asio::buffer(buf, len),
-															 boost::asio::transfer_all(),
-															 std::bind(&TCPIPPipe::HandleUpstreamWrite,
-																				 shared_from_this(),
-																				 std::placeholders::_1)
-															 );
-		} else {
-			LogPrint(eLogError, "tcpip pipe upstream socket null");
-		}
-	}
-
-	void TCPIPPipe::DownstreamWrite(const uint8_t * buf, size_t len)
-	{
-		if (m_down) {
-			LogPrint(eLogDebug, "TCPIPPipe: write downstream ", (int)len);
-			boost::asio::async_write(*m_down, boost::asio::buffer(buf, len),
-															 boost::asio::transfer_all(),
-															 std::bind(&TCPIPPipe::HandleDownstreamWrite,
-																				 shared_from_this(),
-																				 std::placeholders::_1)
-															 );
-		} else { 
-			LogPrint(eLogError, "tcpip pipe downstream socket null");
-		}
-	}
-	
-	
-	void TCPIPPipe::HandleDownstreamReceived(const boost::system::error_code & ecode, std::size_t bytes_transfered)
-	{
-		LogPrint(eLogDebug, "TCPIPPipe downstream got ", (int) bytes_transfered);
-		if (ecode) {
-			LogPrint(eLogError, "TCPIPPipe Downstream read error:" , ecode.message());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate();
-		} else {
-			if (bytes_transfered > 0 ) {
-				memcpy(m_upstream_buf, m_downstream_to_up_buf, bytes_transfered);
-				UpstreamWrite(m_upstream_buf, bytes_transfered);
-			}
-			AsyncReceiveDownstream();
-		}
-	}
-
-	void TCPIPPipe::HandleDownstreamWrite(const boost::system::error_code & ecode) {
-		if (ecode) {
-			LogPrint(eLogError, "TCPIPPipe Downstream write error:" , ecode.message());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate();
-		}
-	}
-	
-	void TCPIPPipe::HandleUpstreamWrite(const boost::system::error_code & ecode) {
-		if (ecode) {
-			LogPrint(eLogError, "TCPIPPipe Upstream write error:" , ecode.message());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate();
-		}
-	}
-	
-	void TCPIPPipe::HandleUpstreamReceived(const boost::system::error_code & ecode, std::size_t bytes_transfered)
-	{
-		LogPrint(eLogDebug, "TCPIPPipe upstream got ", (int) bytes_transfered);
-		if (ecode) {
-			LogPrint(eLogError, "TCPIPPipe Upstream read error:" , ecode.message());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate();
-		} else {
-			if (bytes_transfered > 0 ) {
-				memcpy(m_upstream_buf, m_upstream_to_down_buf, bytes_transfered);
-				DownstreamWrite(m_upstream_buf, bytes_transfered);
-			}
-			AsyncReceiveUpstream();
-		}
-	}
-	
-	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, "I2PService: ", 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, "I2PService: ", GetName(), " closing socket on accept because: ", ecode.message ());
-		}
-	}
-
-}
-}

I2PTunnel.cpp

@@ -1,503 +0,0 @@
-#include <cassert>
-#include "Base.h"
-#include "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 (eLogError, "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 (eLogError, "I2PTunnel: write error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-			StreamReceive ();
-	}
-
-	void I2PTunnelConnection::StreamReceive ()
-	{
-		if (m_Stream)
-		{
-			if (m_Stream->GetStatus () == i2p::stream::eStreamStatusNew ||
-			    m_Stream->GetStatus () == i2p::stream::eStreamStatusOpen) // regular
-			{	
-				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);
-			}	
-			else // closed by peer
-			{
-				// get remaning data
-				auto len = m_Stream->ReadSome (m_StreamBuffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE);
-				if (len > 0) // still some data
-					Write (m_StreamBuffer, len);
-				else // no more data
-					Terminate (); 
-			}		
-		}	
-	}	
-
-	void I2PTunnelConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (ecode)
-		{
-			LogPrint (eLogError, "I2PTunnel: stream read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-			{
-				if (bytes_transferred > 0)
-					Write (m_StreamBuffer, bytes_transferred); // postpone termination
-				else	
-					Terminate ();
-			}	
-		}
-		else
-			Write (m_StreamBuffer, bytes_transferred);
-	}
-
-	void I2PTunnelConnection::Write (const uint8_t * buf, size_t len)
-	{
-		boost::asio::async_write (*m_Socket, boost::asio::buffer (buf, len), boost::asio::transfer_all (),
-        	std::bind (&I2PTunnelConnection::HandleWrite, shared_from_this (), std::placeholders::_1));
-	}
-
-	void I2PTunnelConnection::HandleConnect (const boost::system::error_code& ecode)
-	{
-		if (ecode)
-		{
-			LogPrint (eLogError, "I2PTunnel: connect error: ", ecode.message ());
-			Terminate ();
-		}
-		else
-		{
-			LogPrint (eLogDebug, "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), m_From (stream->GetRemoteIdentity ())
-	{
-	}
-
-	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 == "\r") endOfHeader = true;
-					else
-					{	
-						if (line.find ("Host:") != std::string::npos)
-							m_OutHeader << "Host: " << m_Host << "\r\n";
-						else
-							m_OutHeader << line << "\n";
-					}	
-				}
-				else
-					break;
-			}
-			// add X-I2P fields
-			if (m_From)
-			{
-				m_OutHeader << X_I2P_DEST_B32 << ": " << context.GetAddressBook ().ToAddress(m_From->GetIdentHash ()) << "\r\n";
-				m_OutHeader << X_I2P_DEST_HASH << ": " << m_From->GetIdentHash ().ToBase64 () << "\r\n";
-				m_OutHeader << X_I2P_DEST_B64 << ": " << m_From->ToBase64 () << "\r\n";
-			}
-
-			if (endOfHeader)
-			{
-				m_OutHeader << "\r\n"; // end of header
-				m_OutHeader << m_InHeader.str ().substr (m_InHeader.tellg ()); // data right after header
-				m_HeaderSent = true;
-				I2PTunnelConnection::Write ((uint8_t *)m_OutHeader.str ().c_str (), m_OutHeader.str ().length ());
-			}
-		}	
-	}
-
-	I2PTunnelConnectionIRC::I2PTunnelConnectionIRC (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& webircpass):
-        I2PTunnelConnection (owner, stream, socket, target), m_From (stream->GetRemoteIdentity ()), 
-        m_NeedsWebIrc (webircpass.length() ? true : false), m_WebircPass (webircpass)
-    {
-    }
-
-    void I2PTunnelConnectionIRC::Write (const uint8_t * buf, size_t len)
-    {
-    	if (m_NeedsWebIrc) {
-        	m_NeedsWebIrc = false;
-        	m_OutPacket.str ("");
-            m_OutPacket << "WEBIRC " << this->m_WebircPass << " cgiirc " << context.GetAddressBook ().ToAddress (m_From->GetIdentHash ()) << " 127.0.0.1\n";
-            I2PTunnelConnection::Write ((uint8_t *)m_OutPacket.str ().c_str (), m_OutPacket.str ().length ());
-        }
-
-    	std::string line;
-        m_OutPacket.str ("");
-        m_InPacket.clear ();
-        m_InPacket.write ((const char *)buf, len);
-        
-        while (!m_InPacket.eof () && !m_InPacket.fail ())
-        {
-            std::getline (m_InPacket, line);
-            if (line.length () == 0 && m_InPacket.eof ()) {
-            	m_InPacket.str ("");
-            }
-            auto pos = line.find ("USER");
-            if (pos != std::string::npos && pos == 0)
-            {
-                pos = line.find (" ");
-                pos++;
-                pos = line.find (" ", pos);
-                pos++;
-                auto nextpos = line.find (" ", pos);
-                m_OutPacket << line.substr (0, pos);
-                m_OutPacket << context.GetAddressBook ().ToAddress (m_From->GetIdentHash ());
-                m_OutPacket << line.substr (nextpos) << '\n';
-            } else {
-                m_OutPacket << line << '\n';
-            }
-        }
-        I2PTunnelConnection::Write ((uint8_t *)m_OutPacket.str ().c_str (), m_OutPacket.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 (eLogDebug, "I2PTunnel: new connection");
-			auto connection = std::make_shared<I2PTunnelConnection>(GetOwner(), m_Socket, stream);
-			GetOwner()->AddHandler (connection);
-			connection->I2PConnect ();
-			Done(shared_from_this());
-		}
-		else
-		{
-			LogPrint (eLogError, "I2PTunnel: 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& name, const std::string& destination, 
-	    const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort): 
-		TCPIPAcceptor (address, port, localDestination), m_Name (name), 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, "I2PTunnel: 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& name, const std::string& address, 
-	    int port, std::shared_ptr<ClientDestination> localDestination, int inport, bool gzip): 
-		I2PService (localDestination), m_Name (name), m_Address (address), m_Port (port), m_IsAccessList (false)
-	{
-		m_PortDestination = localDestination->CreateStreamingDestination (inport > 0 ? inport : port, gzip);
-	}
-	
-	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> resolver)
-	{	
-		if (!ecode)
-		{	
-			auto addr = (*it).endpoint ().address ();
-			LogPrint (eLogInfo, "I2PTunnel: server tunnel ", (*it).host_name (), " has been resolved to ", addr);
-			m_Endpoint.address (addr);
-			Accept ();	
-		}	
-		else
-			LogPrint (eLogError, "I2PTunnel: 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 (eLogError, "I2PTunnel: 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, "I2PTunnel: 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& name, const std::string& address, 
-	    int port, std::shared_ptr<ClientDestination> localDestination, 
-	    const std::string& host, int inport, bool gzip):
-		I2PServerTunnel (name, address, port, localDestination, inport, gzip), 
-		m_Host (host.length () > 0 ? host : address)
-	{
-	}
-
-	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 (), m_Host);
-		AddHandler (conn);
-		conn->Connect ();
-	}
-
-    I2PServerTunnelIRC::I2PServerTunnelIRC (const std::string& name, const std::string& address, 
-        int port, std::shared_ptr<ClientDestination> localDestination, 
-        const std::string& webircpass, int inport, bool gzip):
-        I2PServerTunnel (name, address, port, localDestination, inport, gzip),
-        m_WebircPass (webircpass)
-    {
-    }
-
-    void I2PServerTunnelIRC::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
-    {
-	    auto conn = std::make_shared<I2PTunnelConnectionIRC> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint (), this->m_WebircPass);
-	    AddHandler (conn);
-        conn->Connect ();
-    }
-
-}		
-}	

I2PTunnel.h

@@ -1,208 +0,0 @@
-#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
-	// for HTTP tunnels		
-	const char X_I2P_DEST_HASH[] = "X-I2P-DestHash"; // hash  in base64
-	const char X_I2P_DEST_B64[] = "X-I2P-DestB64"; // full address in base64
-	const char X_I2P_DEST_B32[] = "X-I2P-DestB32"; // .b32.i2p address
-
-	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;
-			std::shared_ptr<const i2p::data::IdentityEx> m_From;
-	};
-
-	class I2PTunnelConnectionIRC: public I2PTunnelConnection
-    {
-        public:
-                
-            I2PTunnelConnectionIRC (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& m_WebircPass); 
-
-        protected:
-
-            void Write (const uint8_t * buf, size_t len);
-
-        private:
-   
-            std::shared_ptr<const i2p::data::IdentityEx> m_From;
-            std::stringstream m_OutPacket, m_InPacket;
-			bool m_NeedsWebIrc;
-            std::string m_WebircPass; 
-    };
-
-
-	class I2PClientTunnel: public TCPIPAcceptor
-	{
-		protected:
-
-			// Implements TCPIPAcceptor
-			std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
-
-		public:
-
-			I2PClientTunnel (const std::string& name, const std::string& destination, 
-				const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0);
-			~I2PClientTunnel () {}
-	
-			void Start ();
-			void Stop ();
-
-			const char* GetName() { return m_Name.c_str (); }	
-			
-		private:
-
-			const i2p::data::IdentHash * GetIdentHash ();
-
-		private:
-			
-			std::string m_Name, m_Destination;
-			const i2p::data::IdentHash * m_DestinationIdentHash;
-			int m_DestinationPort;	
-	};	
-
-	class I2PServerTunnel: public I2PService
-	{
-		public:
-
-			I2PServerTunnel (const std::string& name, const std::string& address, int port, 
-				std::shared_ptr<ClientDestination> localDestination, int inport = 0, bool gzip = true);	
-
-			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; };
-			uint16_t GetLocalPort () const { return m_PortDestination->GetLocalPort (); };
-			const boost::asio::ip::tcp::endpoint& GetEndpoint () const { return m_Endpoint; }
-
-			const char* GetName() { return m_Name.c_str (); }	
-			
-		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_Name, 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& name, const std::string& address, int port, 
-				std::shared_ptr<ClientDestination> localDestination, const std::string& host,
-			    int inport = 0, bool gzip = true);	
-
-		private:
-
-			void CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
-
-		private:
-
-			std::string m_Host;
-	};
-	
-    class I2PServerTunnelIRC: public I2PServerTunnel
-    {
-        public:
-
-            I2PServerTunnelIRC (const std::string& name, const std::string& address, int port, 
-                std::shared_ptr<ClientDestination> localDestination, const std::string& webircpass,
-                int inport = 0, bool gzip = true);   
-
-        private:
-
-            void CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
-
-        private:
-
-        	std::string m_WebircPass;
-    };
-
-}
-}	
-
-#endif

Identity.cpp

@@ -1,573 +0,0 @@
-#include <time.h>
-#include <stdio.h>
-#include <openssl/sha.h>
-#include <openssl/dh.h>
-#include <openssl/rand.h>
-#include "Crypto.h"
-#include "I2PEndian.h"
-#include "Log.h"
-#include "Identity.h"
-
-namespace i2p
-{
-namespace data
-{
-	Identity& Identity::operator=(const Keys& keys)
-	{
-		// copy public and signing keys together
-		memcpy (publicKey, keys.publicKey, sizeof (publicKey) + sizeof (signingKey));
-		memset (certificate, 0, sizeof (certificate));		
-		return *this;
-	}
-
-	size_t Identity::FromBuffer (const uint8_t * buf, size_t len)
-	{
-		if ( len < DEFAULT_IDENTITY_SIZE ) {
-			// buffer too small, don't overflow
-			return 0;
-		}
-		memcpy (publicKey, buf, DEFAULT_IDENTITY_SIZE);
-		return DEFAULT_IDENTITY_SIZE;
-	}
-
-	IdentHash Identity::Hash () const
-	{
-		IdentHash hash;
-		SHA256(publicKey, DEFAULT_IDENTITY_SIZE, hash);
-		return hash;
-	}	
-	
-	IdentityEx::IdentityEx ():
-		m_ExtendedLen (0), m_ExtendedBuffer (nullptr)
-	{
-	}
-
-	IdentityEx::IdentityEx(const uint8_t * publicKey, const uint8_t * signingKey, SigningKeyType type)
-	{	
-		memcpy (m_StandardIdentity.publicKey, publicKey, sizeof (m_StandardIdentity.publicKey));
-		if (type != SIGNING_KEY_TYPE_DSA_SHA1)
-		{
-			size_t excessLen = 0;
-			uint8_t * excessBuf = nullptr;
-			switch (type)
-			{
-				case SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-				{	
-					size_t padding =  128 - i2p::crypto::ECDSAP256_KEY_LENGTH; // 64 = 128 - 64
-					RAND_bytes (m_StandardIdentity.signingKey, padding);
-					memcpy (m_StandardIdentity.signingKey + padding, signingKey, i2p::crypto::ECDSAP256_KEY_LENGTH);
-					break;
-				}
-				case SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-				{	
-					size_t padding = 128 - i2p::crypto::ECDSAP384_KEY_LENGTH; // 32 = 128 - 96
-					RAND_bytes (m_StandardIdentity.signingKey, padding);
-					memcpy (m_StandardIdentity.signingKey + padding, signingKey, i2p::crypto::ECDSAP384_KEY_LENGTH);
-					break;
-				}	
-				case SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-				{
-					memcpy (m_StandardIdentity.signingKey, signingKey, 128);
-					excessLen = i2p::crypto::ECDSAP521_KEY_LENGTH - 128; // 4 = 132 - 128
-					excessBuf = new uint8_t[excessLen];
-					memcpy (excessBuf, signingKey + 128, excessLen);
-					break;
-				}	
-				case SIGNING_KEY_TYPE_RSA_SHA256_2048:
-				{
-					memcpy (m_StandardIdentity.signingKey, signingKey, 128);
-					excessLen = i2p::crypto::RSASHA2562048_KEY_LENGTH - 128; // 128 = 256 - 128
-					excessBuf = new uint8_t[excessLen];
-					memcpy (excessBuf, signingKey + 128, excessLen);
-					break;
-				}	
-				case SIGNING_KEY_TYPE_RSA_SHA384_3072:
-				{
-					memcpy (m_StandardIdentity.signingKey, signingKey, 128);
-					excessLen = i2p::crypto::RSASHA3843072_KEY_LENGTH - 128; // 256 = 384 - 128
-					excessBuf = new uint8_t[excessLen];
-					memcpy (excessBuf, signingKey + 128, excessLen);
-					break;
-				}	
-				case SIGNING_KEY_TYPE_RSA_SHA512_4096:
-				{
-					memcpy (m_StandardIdentity.signingKey, signingKey, 128);
-					excessLen = i2p::crypto::RSASHA5124096_KEY_LENGTH - 128; // 384 = 512 - 128
-					excessBuf = new uint8_t[excessLen];
-					memcpy (excessBuf, signingKey + 128, excessLen);
-					break;
-				}	
-				case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
-				{
-					size_t padding =  128 - i2p::crypto::EDDSA25519_PUBLIC_KEY_LENGTH; // 96 = 128 - 32
-					RAND_bytes (m_StandardIdentity.signingKey, padding);
-					memcpy (m_StandardIdentity.signingKey + padding, signingKey, i2p::crypto::EDDSA25519_PUBLIC_KEY_LENGTH);
-					break;
-				}	
-				default:
-					LogPrint (eLogError, "Identity: Signing key type ", (int)type, " is not supported");
-			}	
-			m_ExtendedLen = 4 + excessLen; // 4 bytes extra + excess length
-			// fill certificate
-			m_StandardIdentity.certificate[0] = CERTIFICATE_TYPE_KEY;
-			htobe16buf (m_StandardIdentity.certificate + 1, m_ExtendedLen); 
-			// fill extended buffer
-			m_ExtendedBuffer = new uint8_t[m_ExtendedLen];
-			htobe16buf (m_ExtendedBuffer, type);
-			htobe16buf (m_ExtendedBuffer + 2, CRYPTO_KEY_TYPE_ELGAMAL);
-			if (excessLen && excessBuf)
-			{
-				memcpy (m_ExtendedBuffer + 4, excessBuf, excessLen);
-				delete[] excessBuf;
-			}	
-			// calculate ident hash
-			uint8_t * buf = new uint8_t[GetFullLen ()];
-			ToBuffer (buf, GetFullLen ());
-			SHA256(buf, GetFullLen (), m_IdentHash);
-			delete[] buf;
-		}
-		else // DSA-SHA1
-		{
-			memcpy (m_StandardIdentity.signingKey, signingKey, sizeof (m_StandardIdentity.signingKey));
-			memset (m_StandardIdentity.certificate, 0, sizeof (m_StandardIdentity.certificate));
-			m_IdentHash = m_StandardIdentity.Hash ();
-			m_ExtendedLen = 0;
-			m_ExtendedBuffer = nullptr;
-		}	
-		CreateVerifier ();
-	}	
-		
-	IdentityEx::IdentityEx (const uint8_t * buf, size_t len):
-		m_ExtendedLen (0), m_ExtendedBuffer (nullptr)
-	{
-		FromBuffer (buf, len);
-	}
-
-	IdentityEx::IdentityEx (const IdentityEx& other):
-		m_ExtendedLen (0), m_ExtendedBuffer (nullptr)
-	{
-		*this = other;
-	}	
-
-	IdentityEx::IdentityEx (const Identity& standard):
-		m_ExtendedLen (0), m_ExtendedBuffer (nullptr)
-	{
-		*this = standard;
-	}	
-		
-	IdentityEx::~IdentityEx ()
-	{
-		delete[] m_ExtendedBuffer;
-	}	
-
-	IdentityEx& IdentityEx::operator=(const IdentityEx& other)
-	{
-		memcpy (&m_StandardIdentity, &other.m_StandardIdentity, DEFAULT_IDENTITY_SIZE);
-		m_IdentHash = other.m_IdentHash;
-		
-		delete[] m_ExtendedBuffer;
-		m_ExtendedLen = other.m_ExtendedLen;
-		if (m_ExtendedLen > 0)
-		{	
-			m_ExtendedBuffer = new uint8_t[m_ExtendedLen];
-			memcpy (m_ExtendedBuffer, other.m_ExtendedBuffer, m_ExtendedLen);
-		}	        
-		else
-			m_ExtendedBuffer = nullptr;
-		
-		m_Verifier = nullptr;
-		
-		return *this;
-	}	
-
-	IdentityEx& IdentityEx::operator=(const Identity& standard)
-	{
-		m_StandardIdentity = standard;
-		m_IdentHash = m_StandardIdentity.Hash ();
-		
-		delete[] m_ExtendedBuffer;
-		m_ExtendedBuffer = nullptr;
-		m_ExtendedLen = 0;
-
-		m_Verifier = nullptr;
-		
-		return *this;
-	}	
-		
-	size_t IdentityEx::FromBuffer (const uint8_t * buf, size_t len)
-	{
-		if (len < DEFAULT_IDENTITY_SIZE)
-		{
-			LogPrint (eLogError, "Identity: buffer length ", len, " is too small");
-			return 0;
-		}	
-		memcpy (&m_StandardIdentity, buf, DEFAULT_IDENTITY_SIZE);
-
-		delete[] m_ExtendedBuffer; m_ExtendedBuffer = nullptr;
-		m_ExtendedLen = bufbe16toh (m_StandardIdentity.certificate + 1);
-		if (m_ExtendedLen)
-		{
-			if (m_ExtendedLen + DEFAULT_IDENTITY_SIZE <= len)
-			{	
-				m_ExtendedBuffer = new uint8_t[m_ExtendedLen];
-				memcpy (m_ExtendedBuffer, buf + DEFAULT_IDENTITY_SIZE, m_ExtendedLen);
-			}	
-			else
-			{
-				LogPrint (eLogError, "Identity: Certificate length ", m_ExtendedLen, " exceeds buffer length ", len - DEFAULT_IDENTITY_SIZE);
-				m_ExtendedLen = 0;
-				return 0;
-			}	
-		}		
-		else
-		{
-			m_ExtendedLen = 0;
-			m_ExtendedBuffer = nullptr;
-		}	
-		SHA256(buf, GetFullLen (), m_IdentHash);
-		
-		m_Verifier = nullptr;
-		
-		return GetFullLen ();
-	}	
-
-	size_t IdentityEx::ToBuffer (uint8_t * buf, size_t len) const
-	{
-		const size_t fullLen = GetFullLen();
-		if (fullLen > len) return 0; // buffer is too small and may overflow somewhere else
-		memcpy (buf, &m_StandardIdentity, DEFAULT_IDENTITY_SIZE);
-		if (m_ExtendedLen > 0 && m_ExtendedBuffer)
-			memcpy (buf + DEFAULT_IDENTITY_SIZE, m_ExtendedBuffer, m_ExtendedLen);
-		return fullLen;
-	}
-
-	size_t IdentityEx::FromBase64(const std::string& s)
-	{
-		const size_t slen = s.length();
-		uint8_t buf[slen]; // binary data can't exceed base64
-		const size_t len = Base64ToByteStream (s.c_str(), slen, buf, slen);
-		return FromBuffer (buf, len);
-	}	
-	
-	std::string IdentityEx::ToBase64 () const
-	{
-		const size_t bufLen = GetFullLen();
-		const size_t strLen = Base64EncodingBufferSize(bufLen);
-		uint8_t buf[bufLen];
-		char str[strLen];
-		size_t l = ToBuffer (buf, bufLen);
-		size_t l1 = i2p::data::ByteStreamToBase64 (buf, l, str, strLen);
-		str[l1] = 0;
-		return std::string (str);
-	}
-	
-	size_t IdentityEx::GetSigningPublicKeyLen () const
-	{
-		if (!m_Verifier) CreateVerifier ();
-		if (m_Verifier)	
-			return m_Verifier->GetPublicKeyLen ();
-		return 128;
-	}	
-
-	size_t IdentityEx::GetSigningPrivateKeyLen () const
-	{
-		if (!m_Verifier) CreateVerifier ();
-		if (m_Verifier)	
-			return m_Verifier->GetPrivateKeyLen ();
-		return GetSignatureLen ()/2;
-	}	
-		
-	size_t IdentityEx::GetSignatureLen () const
-	{	
-		if (!m_Verifier) CreateVerifier ();	
-		if (m_Verifier)
-			return m_Verifier->GetSignatureLen ();
-		return i2p::crypto::DSA_SIGNATURE_LENGTH;
-	}	
-	bool IdentityEx::Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const 
-	{
-		if (!m_Verifier) CreateVerifier ();
-		if (m_Verifier)
-			return m_Verifier->Verify (buf, len, signature);
-		return false;
-	}	
-
-	SigningKeyType IdentityEx::GetSigningKeyType () const
-	{
-		if (m_StandardIdentity.certificate[0] == CERTIFICATE_TYPE_KEY && m_ExtendedBuffer)				
-			return bufbe16toh (m_ExtendedBuffer); // signing key
-		return SIGNING_KEY_TYPE_DSA_SHA1;
-	}	
-
-	CryptoKeyType IdentityEx::GetCryptoKeyType () const
-	{
-		if (m_StandardIdentity.certificate[0] == CERTIFICATE_TYPE_KEY && m_ExtendedBuffer)				
-			return bufbe16toh (m_ExtendedBuffer + 2); // crypto key
-		return CRYPTO_KEY_TYPE_ELGAMAL;
-	}	
-		
-	void IdentityEx::CreateVerifier () const 
-	{
-		auto keyType = GetSigningKeyType ();
-		switch (keyType)
-		{
-			case SIGNING_KEY_TYPE_DSA_SHA1:
-				m_Verifier.reset (new i2p::crypto::DSAVerifier (m_StandardIdentity.signingKey));
-			break;
-			case SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-			{	
-				size_t padding =  128 - i2p::crypto::ECDSAP256_KEY_LENGTH; // 64 = 128 - 64
-				m_Verifier.reset (new i2p::crypto::ECDSAP256Verifier (m_StandardIdentity.signingKey + padding));
-				break;
-			}	
-			case SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-			{	
-				size_t padding = 128 - i2p::crypto::ECDSAP384_KEY_LENGTH; // 32 = 128 - 96
-				m_Verifier.reset (new i2p::crypto::ECDSAP384Verifier (m_StandardIdentity.signingKey + padding));
-				break;
-			}	
-			case SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-			{	
-				uint8_t signingKey[i2p::crypto::ECDSAP521_KEY_LENGTH];
-				memcpy (signingKey, m_StandardIdentity.signingKey, 128);
-				size_t excessLen = i2p::crypto::ECDSAP521_KEY_LENGTH - 128; // 4 = 132- 128
-				memcpy (signingKey + 128, m_ExtendedBuffer + 4, excessLen); // right after signing and crypto key types
-				m_Verifier.reset (new i2p::crypto::ECDSAP521Verifier (signingKey));
-				break;
-			}		
-			case SIGNING_KEY_TYPE_RSA_SHA256_2048:
-			{	
-				uint8_t signingKey[i2p::crypto::RSASHA2562048_KEY_LENGTH];
-				memcpy (signingKey, m_StandardIdentity.signingKey, 128);
-				size_t excessLen = i2p::crypto::RSASHA2562048_KEY_LENGTH - 128; // 128 = 256- 128
-				memcpy (signingKey + 128, m_ExtendedBuffer + 4, excessLen); // right after signing and crypto key types
-				m_Verifier.reset (new i2p::crypto:: RSASHA2562048Verifier (signingKey));
-				break;
-			}	
-			case SIGNING_KEY_TYPE_RSA_SHA384_3072:
-			{	
-				uint8_t signingKey[i2p::crypto::RSASHA3843072_KEY_LENGTH];
-				memcpy (signingKey, m_StandardIdentity.signingKey, 128);
-				size_t excessLen = i2p::crypto::RSASHA3843072_KEY_LENGTH - 128; // 256 = 384- 128
-				memcpy (signingKey + 128, m_ExtendedBuffer + 4, excessLen); // right after signing and crypto key types
-				m_Verifier.reset (new i2p::crypto:: RSASHA3843072Verifier (signingKey));
-				break;
-			}	
-			case SIGNING_KEY_TYPE_RSA_SHA512_4096:
-			{	
-				uint8_t signingKey[i2p::crypto::RSASHA5124096_KEY_LENGTH];
-				memcpy (signingKey, m_StandardIdentity.signingKey, 128);
-				size_t excessLen = i2p::crypto::RSASHA5124096_KEY_LENGTH - 128; // 384 = 512- 128
-				memcpy (signingKey + 128, m_ExtendedBuffer + 4, excessLen); // right after signing and crypto key types
-				m_Verifier.reset (new i2p::crypto:: RSASHA5124096Verifier (signingKey));
-				break;
-			}	
-			case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
-			{
-				size_t padding =  128 - i2p::crypto::EDDSA25519_PUBLIC_KEY_LENGTH; // 96 = 128 - 32
-				m_Verifier.reset (new i2p::crypto::EDDSA25519Verifier (m_StandardIdentity.signingKey + padding));
-				break;
-			}	
-			default:
-				LogPrint (eLogError, "Identity: Signing key type ", (int)keyType, " is not supported");
-		}			
-	}	
-	
-	void IdentityEx::DropVerifier () const
-	{
-		// TODO: potential race condition with Verify
-		m_Verifier = nullptr; 
-	}
-
-	PrivateKeys& PrivateKeys::operator=(const Keys& keys)
-	{
-		m_Public = std::make_shared<IdentityEx>(Identity (keys));
-		memcpy (m_PrivateKey, keys.privateKey, 256); // 256 
-		memcpy (m_SigningPrivateKey, keys.signingPrivateKey, m_Public->GetSigningPrivateKeyLen ());
-		m_Signer = nullptr;
-		CreateSigner ();
-		return *this;
-	}
-
-	PrivateKeys& PrivateKeys::operator=(const PrivateKeys& other)
-	{		
-		m_Public = std::make_shared<IdentityEx>(*other.m_Public);
-		memcpy (m_PrivateKey, other.m_PrivateKey, 256); // 256 
-		memcpy (m_SigningPrivateKey, other.m_SigningPrivateKey, m_Public->GetSigningPrivateKeyLen ()); 
-		m_Signer = nullptr;
-		CreateSigner ();
-		return *this;
-	}	
-		
-	size_t PrivateKeys::FromBuffer (const uint8_t * buf, size_t len)
-	{
-		m_Public = std::make_shared<IdentityEx>(buf, len);
-		size_t ret = m_Public->GetFullLen ();
-		memcpy (m_PrivateKey, buf + ret, 256); // private key always 256
-		ret += 256;
-		size_t signingPrivateKeySize = m_Public->GetSigningPrivateKeyLen ();
-		memcpy (m_SigningPrivateKey, buf + ret, signingPrivateKeySize); 
-		ret += signingPrivateKeySize;
-		m_Signer = nullptr;
-		CreateSigner ();
-		return ret;
-	}
-		
-	size_t PrivateKeys::ToBuffer (uint8_t * buf, size_t len) const
-	{
-		size_t ret = m_Public->ToBuffer (buf, len);
-		memcpy (buf + ret, m_PrivateKey, 256); // private key always 256
-		ret += 256;
-		size_t signingPrivateKeySize = m_Public->GetSigningPrivateKeyLen (); 
-		memcpy (buf + ret, m_SigningPrivateKey, signingPrivateKeySize); 
-		ret += signingPrivateKeySize;
-		return ret;
-	}	
-
-	size_t PrivateKeys::FromBase64(const std::string& s)
-	{
-		uint8_t * buf = new uint8_t[s.length ()];
-		size_t l = i2p::data::Base64ToByteStream (s.c_str (), s.length (), buf, s.length ());
-		size_t ret = FromBuffer (buf, l);
-		delete[] buf;
-		return ret;
-	}	
-	
-	std::string PrivateKeys::ToBase64 () const
-	{
-		uint8_t * buf = new uint8_t[GetFullLen ()];
-		char * str = new char[GetFullLen ()*2];
-		size_t l = ToBuffer (buf, GetFullLen ());
-		size_t l1 = i2p::data::ByteStreamToBase64 (buf, l, str, GetFullLen ()*2);
-		str[l1] = 0;
-		delete[] buf;
-		std::string ret(str);
-		delete[] str;
-		return ret;
-	}
-
-	void PrivateKeys::Sign (const uint8_t * buf, int len, uint8_t * signature) const
-	{
-		if (m_Signer)
-			m_Signer->Sign (buf, len, signature);
-	}			
-
-	void PrivateKeys::CreateSigner ()
-	{
-		switch (m_Public->GetSigningKeyType ())
-		{	
-			case SIGNING_KEY_TYPE_DSA_SHA1:
-				m_Signer.reset (new i2p::crypto::DSASigner (m_SigningPrivateKey));
-			break;	
-			case SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-				m_Signer.reset (new i2p::crypto::ECDSAP256Signer (m_SigningPrivateKey));
-			break;
-			case SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-				m_Signer.reset (new i2p::crypto::ECDSAP384Signer (m_SigningPrivateKey));
-			break;	
-			case SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-				m_Signer.reset (new i2p::crypto::ECDSAP521Signer (m_SigningPrivateKey));
-			break;	
-			case SIGNING_KEY_TYPE_RSA_SHA256_2048:
-				m_Signer.reset (new i2p::crypto::RSASHA2562048Signer (m_SigningPrivateKey));
-			break;
-			case SIGNING_KEY_TYPE_RSA_SHA384_3072:
-				m_Signer.reset (new i2p::crypto::RSASHA3843072Signer (m_SigningPrivateKey));
-			break;
-			case SIGNING_KEY_TYPE_RSA_SHA512_4096:
-				m_Signer.reset (new i2p::crypto::RSASHA5124096Signer (m_SigningPrivateKey));
-			break;	
-			case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
-				m_Signer.reset (new i2p::crypto::EDDSA25519Signer (m_SigningPrivateKey));
-			break;
-			default:
-				LogPrint (eLogError, "Identity: Signing key type ", (int)m_Public->GetSigningKeyType (), " is not supported");
-		}
-	}	
-		
-	PrivateKeys PrivateKeys::CreateRandomKeys (SigningKeyType type)
-	{
-		if (type != SIGNING_KEY_TYPE_DSA_SHA1)
-		{
-			PrivateKeys keys;
-			// signature
-			uint8_t signingPublicKey[512]; // signing public key is 512 bytes max 
-			switch (type)
-			{	
-				case SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-					i2p::crypto::CreateECDSAP256RandomKeys (keys.m_SigningPrivateKey, signingPublicKey);
-				break;	
-				case SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-					i2p::crypto::CreateECDSAP384RandomKeys (keys.m_SigningPrivateKey, signingPublicKey);	
-				break;
-				case SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-					i2p::crypto::CreateECDSAP521RandomKeys (keys.m_SigningPrivateKey, signingPublicKey);	
-				break;	
-				case SIGNING_KEY_TYPE_RSA_SHA256_2048:
-					i2p::crypto::CreateRSARandomKeys (i2p::crypto::RSASHA2562048_KEY_LENGTH, keys.m_SigningPrivateKey, signingPublicKey);	
-				break;
-				case SIGNING_KEY_TYPE_RSA_SHA384_3072:
-					i2p::crypto::CreateRSARandomKeys (i2p::crypto::RSASHA3843072_KEY_LENGTH, keys.m_SigningPrivateKey, signingPublicKey);	
-				break;
-				case SIGNING_KEY_TYPE_RSA_SHA512_4096:
-					i2p::crypto::CreateRSARandomKeys (i2p::crypto::RSASHA5124096_KEY_LENGTH, keys.m_SigningPrivateKey, signingPublicKey);	
-				break;	
-				case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
-					i2p::crypto::CreateEDDSA25519RandomKeys (keys.m_SigningPrivateKey, signingPublicKey);
-				break;
-				default:
-					LogPrint (eLogError, "Identity: Signing key type ", (int)type, " is not supported. Create DSA-SHA1");
-					return PrivateKeys (i2p::data::CreateRandomKeys ()); // DSA-SHA1
-			}	
-			// encryption
-			uint8_t publicKey[256];
-			i2p::crypto::GenerateElGamalKeyPair (keys.m_PrivateKey, publicKey);
-			// identity
-			keys.m_Public = std::make_shared<IdentityEx> (publicKey, signingPublicKey, type);
-
-			keys.CreateSigner ();
-			return keys;
-		}	
-		return PrivateKeys (i2p::data::CreateRandomKeys ()); // DSA-SHA1
-	}	
-		
-	Keys CreateRandomKeys ()
-	{
-		Keys keys;		
-		// encryption
-		i2p::crypto::GenerateElGamalKeyPair(keys.privateKey, keys.publicKey);
-		// signing
-		i2p::crypto::CreateDSARandomKeys (keys.signingPrivateKey, keys.signingKey);	
-		return keys;
-	}	
-
-	IdentHash CreateRoutingKey (const IdentHash& ident)
-	{
-		uint8_t buf[41]; // ident + yyyymmdd
-		memcpy (buf, (const uint8_t *)ident, 32);
-		time_t t = time (nullptr);
-		struct tm tm;
-#ifdef _WIN32
-		gmtime_s(&tm, &t);
-		sprintf_s((char *)(buf + 32), 9, "%04i%02i%02i", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
-#else
-		gmtime_r(&t, &tm);
-		sprintf((char *)(buf + 32), "%04i%02i%02i", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
-#endif		
-		IdentHash key;
-		SHA256(buf, 40, key);
-		return key;
-	}	
-	
-	XORMetric operator^(const IdentHash& key1, const IdentHash& key2)
-	{
-		XORMetric m;
-		const uint64_t * hash1 = key1.GetLL (), * hash2 = key2.GetLL ();
-		m.metric_ll[0] = hash1[0] ^ hash2[0];
-		m.metric_ll[1] = hash1[1] ^ hash2[1];
-		m.metric_ll[2] = hash1[2] ^ hash2[2];
-		m.metric_ll[3] = hash1[3] ^ hash2[3];
-		return m;
-	}	
-}
-}

Identity.h

@@ -1,195 +0,0 @@
-#ifndef IDENTITY_H__
-#define IDENTITY_H__
-
-#include <inttypes.h>
-#include <string.h>
-#include <string>
-#include <memory>
-#include "Base.h"
-#include "Signature.h"
-
-namespace i2p
-{
-namespace data
-{
-	typedef Tag<32> IdentHash;
-	inline std::string GetIdentHashAbbreviation (const IdentHash& ident) 
-	{ 
-		return ident.ToBase64 ().substr (0, 4); 
-	}
-
-	struct Keys
-	{
-		uint8_t privateKey[256];
-		uint8_t signingPrivateKey[20];
-		uint8_t publicKey[256];
-		uint8_t signingKey[128];
-	};
-	
-	const uint8_t CERTIFICATE_TYPE_NULL = 0;
-	const uint8_t CERTIFICATE_TYPE_HASHCASH = 1;
-	const uint8_t CERTIFICATE_TYPE_HIDDEN = 2;
-	const uint8_t CERTIFICATE_TYPE_SIGNED = 3;	
-	const uint8_t CERTIFICATE_TYPE_MULTIPLE = 4;	
-	const uint8_t CERTIFICATE_TYPE_KEY = 5;
-
-	struct Identity
-	{
-		uint8_t publicKey[256];
-		uint8_t signingKey[128];
-		uint8_t certificate[3];	// byte 1 - type, bytes 2-3 - length
-
-		Identity () = default;
-		Identity (const Keys& keys) { *this = keys; };
-		Identity& operator=(const Keys& keys);
-		size_t FromBuffer (const uint8_t * buf, size_t len);
-		IdentHash Hash () const;
-	};
-
-	Keys CreateRandomKeys ();
-	
-	const size_t DEFAULT_IDENTITY_SIZE = sizeof (Identity); // 387 bytes
-	
-	const uint16_t CRYPTO_KEY_TYPE_ELGAMAL = 0;
-	const uint16_t SIGNING_KEY_TYPE_DSA_SHA1 = 0;
-	const uint16_t SIGNING_KEY_TYPE_ECDSA_SHA256_P256 = 1;
-	const uint16_t SIGNING_KEY_TYPE_ECDSA_SHA384_P384 = 2;
-	const uint16_t SIGNING_KEY_TYPE_ECDSA_SHA512_P521 = 3;
-	const uint16_t SIGNING_KEY_TYPE_RSA_SHA256_2048 = 4;
-	const uint16_t SIGNING_KEY_TYPE_RSA_SHA384_3072 = 5;
-	const uint16_t SIGNING_KEY_TYPE_RSA_SHA512_4096 = 6;
-	const uint16_t SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519 = 7;
-	typedef uint16_t SigningKeyType;
-	typedef uint16_t CryptoKeyType;	
-	
-	class IdentityEx
-	{
-		public:
-
-			IdentityEx ();
-			IdentityEx (const uint8_t * publicKey, const uint8_t * signingKey,
-				SigningKeyType type = SIGNING_KEY_TYPE_DSA_SHA1);
-			IdentityEx (const uint8_t * buf, size_t len);
-			IdentityEx (const IdentityEx& other);
-			IdentityEx (const Identity& standard);
-			~IdentityEx ();
-			IdentityEx& operator=(const IdentityEx& other);
-			IdentityEx& operator=(const Identity& standard);
-
-			size_t FromBuffer (const uint8_t * buf, size_t len);
-			size_t ToBuffer (uint8_t * buf, size_t len) const;
-			size_t FromBase64(const std::string& s);
-			std::string ToBase64 () const;
-			const Identity& GetStandardIdentity () const { return m_StandardIdentity; };
-			const IdentHash& GetIdentHash () const { return m_IdentHash; };
-			const uint8_t * GetEncryptionPublicKey () const { return m_StandardIdentity.publicKey; };
-			size_t GetFullLen () const { return m_ExtendedLen + DEFAULT_IDENTITY_SIZE; };
-			size_t GetSigningPublicKeyLen () const;
-			size_t GetSigningPrivateKeyLen () const;
-			size_t GetSignatureLen () const;
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const;
-			SigningKeyType GetSigningKeyType () const;
-			CryptoKeyType GetCryptoKeyType () const;
-			void DropVerifier () const; // to save memory			
-
-		private:
-
-			void CreateVerifier () const;
-			
-		private:
-
-			Identity m_StandardIdentity;
-			IdentHash m_IdentHash;
-			mutable std::unique_ptr<i2p::crypto::Verifier> m_Verifier; 
-			size_t m_ExtendedLen;
-			uint8_t * m_ExtendedBuffer;
-	};	
-	
-	class PrivateKeys // for eepsites
-	{
-		public:
-			
-			PrivateKeys () = default;
-			PrivateKeys (const PrivateKeys& other) { *this = other; };
-			PrivateKeys (const Keys& keys) { *this = keys; };
-			PrivateKeys& operator=(const Keys& keys);
-			PrivateKeys& operator=(const PrivateKeys& other);
-			~PrivateKeys () = default;
-			
-			std::shared_ptr<const IdentityEx> GetPublic () const { return m_Public; };
-			const uint8_t * GetPrivateKey () const { return m_PrivateKey; };
-			const uint8_t * GetSigningPrivateKey () const { return m_SigningPrivateKey; };
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const;
-
-			size_t GetFullLen () const { return m_Public->GetFullLen () + 256 + m_Public->GetSigningPrivateKeyLen (); }; 		
-			size_t FromBuffer (const uint8_t * buf, size_t len);
-			size_t ToBuffer (uint8_t * buf, size_t len) const;
-
-			size_t FromBase64(const std::string& s);
-			std::string ToBase64 () const;
-
-			static PrivateKeys CreateRandomKeys (SigningKeyType type = SIGNING_KEY_TYPE_DSA_SHA1);
-	
-		private:
-
-			void CreateSigner ();
-			
-		private:
-
-			std::shared_ptr<IdentityEx> m_Public;
-			uint8_t m_PrivateKey[256];
-			uint8_t m_SigningPrivateKey[1024]; // assume private key doesn't exceed 1024 bytes
-			std::unique_ptr<i2p::crypto::Signer> m_Signer;
-	};
-
-	// kademlia
-	struct XORMetric
-	{
-		union
-		{	
-			uint8_t metric[32];
-			uint64_t metric_ll[4];	
-		};	
-
-		void SetMin () { memset (metric, 0, 32); };
-		void SetMax () { memset (metric, 0xFF, 32); };
-		bool operator< (const XORMetric& other) const { return memcmp (metric, other.metric, 32) < 0; };
-	};	
-
-	IdentHash CreateRoutingKey (const IdentHash& ident);
-	XORMetric operator^(const IdentHash& key1, const IdentHash& key2); 	
-	
-	// destination for delivery instuctions
-	class RoutingDestination
-	{
-		public:
-
-			RoutingDestination () {};
-			virtual ~RoutingDestination () {};
-			
-			virtual const IdentHash& GetIdentHash () const = 0;
-			virtual const uint8_t * GetEncryptionPublicKey () const = 0;
-			virtual bool IsDestination () const = 0; // for garlic 
-	};	
-
-	class LocalDestination 
-	{
-		public:
-
-			virtual ~LocalDestination() {};
-			virtual const PrivateKeys& GetPrivateKeys () const = 0;
-			virtual const uint8_t * GetEncryptionPrivateKey () const = 0; 
-			virtual const uint8_t * GetEncryptionPublicKey () const = 0; 
-
-			std::shared_ptr<const IdentityEx> GetIdentity () const { return GetPrivateKeys ().GetPublic (); };
-			const IdentHash& GetIdentHash () const { return GetIdentity ()->GetIdentHash (); };  
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const 
-			{ 
-				GetPrivateKeys ().Sign (buf, len, signature); 
-			};
-	};	
-}
-}
-
-
-#endif

LICENSE

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

LeaseSet.cpp

@@ -1,248 +0,0 @@
-#include <string.h>
-#include "I2PEndian.h"
-#include "Crypto.h"
-#include "Log.h"
-#include "Timestamp.h"
-#include "NetDb.h"
-#include "TunnelPool.h"
-#include "LeaseSet.h"
-
-namespace i2p
-{
-namespace data
-{
-	
-	LeaseSet::LeaseSet (const uint8_t * buf, size_t len, bool storeLeases):
-		m_IsValid (true), m_StoreLeases (storeLeases), m_ExpirationTime (0)
-	{
-		m_Buffer = new uint8_t[len];
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer ();
-	}
-
-	LeaseSet::LeaseSet (std::shared_ptr<const i2p::tunnel::TunnelPool> pool):
-		m_IsValid (true), m_StoreLeases (true), m_ExpirationTime (0)
-	{	
-		if (!pool) return;
-		// header
-		auto localDestination = pool->GetLocalDestination ();
-		if (!localDestination)
-		{
-			m_Buffer = nullptr;
-			m_BufferLen = 0;
-			m_IsValid = false;
-			LogPrint (eLogError, "LeaseSet: Destination for local LeaseSet doesn't exist");
-			return;
-		}	
-		m_Buffer = new uint8_t[MAX_LS_BUFFER_SIZE];
-		m_BufferLen = localDestination->GetIdentity ()->ToBuffer (m_Buffer, MAX_LS_BUFFER_SIZE);
-		memcpy (m_Buffer + m_BufferLen, localDestination->GetEncryptionPublicKey (), 256);
-		m_BufferLen += 256;
-		auto signingKeyLen = localDestination->GetIdentity ()->GetSigningPublicKeyLen ();
-		memset (m_Buffer + m_BufferLen, 0, signingKeyLen);
-		m_BufferLen += signingKeyLen;
-		int numTunnels = pool->GetNumInboundTunnels () + 2; // 2 backup tunnels 
-		if (numTunnels > 16) numTunnels = 16; // 16 tunnels maximum 
-		auto tunnels = pool->GetInboundTunnels (numTunnels);
-		m_Buffer[m_BufferLen] = tunnels.size (); // num leases
-		m_BufferLen++;
-		// leases
-		auto currentTime = i2p::util::GetMillisecondsSinceEpoch ();
-		for (auto it: tunnels)
-		{	
-			memcpy (m_Buffer + m_BufferLen, it->GetNextIdentHash (), 32);
-			m_BufferLen += 32; // gateway id
-			htobe32buf (m_Buffer + m_BufferLen, it->GetNextTunnelID ());
-			m_BufferLen += 4; // tunnel id
-			uint64_t ts = it->GetCreationTime () + i2p::tunnel::TUNNEL_EXPIRATION_TIMEOUT - i2p::tunnel::TUNNEL_EXPIRATION_THRESHOLD; // 1 minute before expiration
-			ts *= 1000; // in milliseconds
-			if (ts > m_ExpirationTime) m_ExpirationTime = ts;
-			// make sure leaseset is newer than previous, but adding some time to expiration date
-			ts += (currentTime - it->GetCreationTime ()*1000LL)*2/i2p::tunnel::TUNNEL_EXPIRATION_TIMEOUT; // up to 2 secs
-			htobe64buf (m_Buffer + m_BufferLen, ts);
-			m_BufferLen += 8; // end date
-		}
-		// signature
-		localDestination->Sign (m_Buffer, m_BufferLen, m_Buffer + m_BufferLen);
-		m_BufferLen += localDestination->GetIdentity ()->GetSignatureLen (); 
-		LogPrint (eLogDebug, "LeaseSet: Local LeaseSet of ", tunnels.size (), " leases created");
-
-		ReadFromBuffer ();
-	}
-
-	void LeaseSet::Update (const uint8_t * buf, size_t len)
-	{	
-		if (len > m_BufferLen)
-		{
-			auto oldBuffer = m_Buffer;
-			m_Buffer = new uint8_t[len];
-			delete[] oldBuffer;
-		}	
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer (false);
-	}
-
-	void LeaseSet::PopulateLeases ()
-	{
-		m_StoreLeases = true;
-		ReadFromBuffer (false);
-	}	
-		
-	void LeaseSet::ReadFromBuffer (bool readIdentity)	
-	{	
-		if (readIdentity || !m_Identity)
-			m_Identity = std::make_shared<IdentityEx>(m_Buffer, m_BufferLen);
-		size_t size = m_Identity->GetFullLen ();
-		if (size > m_BufferLen)
-		{
-			LogPrint (eLogError, "LeaseSet: identity length ", size, " exceeds buffer size ", m_BufferLen);
-			m_IsValid = false;
-			return;
-		}
-		memcpy (m_EncryptionKey, m_Buffer + size, 256);
-		size += 256; // encryption key
-		size += m_Identity->GetSigningPublicKeyLen (); // unused signing key
-		uint8_t num = m_Buffer[size];
-		size++; // num
-		LogPrint (eLogDebug, "LeaseSet: read num=", (int)num);
-		if (!num || num > MAX_NUM_LEASES)
-		{	  
-			LogPrint (eLogError, "LeaseSet: incorrect number of leases", (int)num);
-			m_IsValid = false;
-			return;
-		}	
-
-		// reset existing leases	
-		if (m_StoreLeases)
-			for (auto it: m_Leases)
-				it->isUpdated = false;		
-		else	
-			m_Leases.clear ();
-
-		// process leases
-		m_ExpirationTime = 0;
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		const uint8_t * leases = m_Buffer + size;
-		for (int i = 0; i < num; i++)
-		{
-			Lease lease;
-			lease.tunnelGateway = leases;
-			leases += 32; // gateway
-			lease.tunnelID = bufbe32toh (leases);
-			leases += 4; // tunnel ID
-			lease.endDate = bufbe64toh (leases); 
-			leases += 8; // end date
-			if (ts < lease.endDate + LEASE_ENDDATE_THRESHOLD)
-			{	
-				if (lease.endDate > m_ExpirationTime)
-					m_ExpirationTime = lease.endDate;
-				if (m_StoreLeases)
-				{	
-					auto ret = m_Leases.insert (std::make_shared<Lease>(lease));
-					if (!ret.second) *(*ret.first) = lease; // update existing
-					(*ret.first)->isUpdated = true;
-					// check if lease's gateway is in our netDb
-					if (!netdb.FindRouter (lease.tunnelGateway))
-					{
-						// if not found request it
-						LogPrint (eLogInfo, "LeaseSet: Lease's tunnel gateway not found, requesting");
-						netdb.RequestDestination (lease.tunnelGateway);
-					}
-				}	
-			}
-			else
-				LogPrint (eLogWarning, "LeaseSet: Lease is expired already ");
-		}	
-		if (!m_ExpirationTime)
-		{
-			LogPrint (eLogWarning, "LeaseSet: all leases are expired. Dropped");
-			m_IsValid = false;
-			return;
-		}	
-		m_ExpirationTime += LEASE_ENDDATE_THRESHOLD;
-		// delete old leases	
-		if (m_StoreLeases)
-		{	
-			for (auto it = m_Leases.begin (); it != m_Leases.end ();)
-			{	
-				if (!(*it)->isUpdated)
-				{
-					(*it)->endDate = 0; // somebody might still hold it
-					m_Leases.erase (it++);
-				}	
-				else
-					it++;
-			}
-		}
-
-		// verify
-		if (!m_Identity->Verify (m_Buffer, leases - m_Buffer, leases))
-		{
-			LogPrint (eLogWarning, "LeaseSet: verification failed");
-			m_IsValid = false;
-		}
-	}				
-
-	uint64_t LeaseSet::ExtractTimestamp (const uint8_t * buf, size_t len) const 
-	{
-		if (!m_Identity) return 0;
-		size_t size = m_Identity->GetFullLen ();
-		if (size > len) return 0;
-		size += 256; // encryption key
-		size += m_Identity->GetSigningPublicKeyLen (); // unused signing key
-		if (size > len) return 0;
-		uint8_t num = buf[size];
-		size++; // num
-		if (size + num*44 > len) return 0;
-		uint64_t timestamp= 0 ;
-		for (int i = 0; i < num; i++)
-		{
-			size += 36; // gateway (32) + tunnelId(4)
-			auto endDate = bufbe64toh (buf + size); 
-			size += 8; // end date
-			if (!timestamp || endDate < timestamp)
-				timestamp = endDate;
-		}	
-		return timestamp;
-	}	
-
-	bool LeaseSet::IsNewer (const uint8_t * buf, size_t len) const
-	{
-		return ExtractTimestamp (buf, len) > ExtractTimestamp (m_Buffer, m_BufferLen);
-	}	
-		
-	const std::vector<std::shared_ptr<const Lease> > LeaseSet::GetNonExpiredLeases (bool withThreshold) const
-	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		std::vector<std::shared_ptr<const Lease> > leases;
-		for (auto it: m_Leases)
-		{
-			auto endDate = it->endDate;
-			if (withThreshold)
-				endDate += LEASE_ENDDATE_THRESHOLD;
-			else
-				endDate -= LEASE_ENDDATE_THRESHOLD;
-			if (ts < endDate)
-				leases.push_back (it);
-		}	
-		return leases;	
-	}	
-
-	bool LeaseSet::HasExpiredLeases () const
- 	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		for (auto it: m_Leases)
-			if (ts >= it->endDate) return true;
-		return false;
- 	}	
-
-	bool LeaseSet::IsExpired () const
-	{
-		if (IsEmpty ()) return true;
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		return ts > m_ExpirationTime;
-	}	
-}		
-}	

LeaseSet.h

@@ -1,88 +0,0 @@
-#ifndef LEASE_SET_H__
-#define LEASE_SET_H__
-
-#include <inttypes.h>
-#include <string.h>
-#include <vector>
-#include <memory>
-#include "Identity.h"
-
-namespace i2p
-{
-
-namespace tunnel
-{
-	class TunnelPool;
-}
-
-namespace data
-{	
-	const int LEASE_ENDDATE_THRESHOLD = 51000; // in milliseconds
-	struct Lease
-	{
-		IdentHash tunnelGateway;
-		uint32_t tunnelID;
-		uint64_t endDate; // 0 means invalid
-		bool isUpdated; // trasient 
-	};	
-
-	struct LeaseCmp
-	{
-		bool operator() (std::shared_ptr<const Lease> l1, std::shared_ptr<const Lease> l2) const
-  		{	
-			if (l1->tunnelID != l2->tunnelID)
-				return l1->tunnelID < l2->tunnelID; 
-			else
-				return l1->tunnelGateway < l2->tunnelGateway; 
-		};
-	};	
-
-	const int MAX_LS_BUFFER_SIZE = 3072;
-	const uint8_t MAX_NUM_LEASES = 16;		
-	class LeaseSet: public RoutingDestination
-	{
-		public:
-
-			LeaseSet (const uint8_t * buf, size_t len, bool storeLeases = true);
-			LeaseSet (std::shared_ptr<const i2p::tunnel::TunnelPool> pool);
-			~LeaseSet () { delete[] m_Buffer; };
-			void Update (const uint8_t * buf, size_t len);
-			bool IsNewer (const uint8_t * buf, size_t len) const;
-			void PopulateLeases (); // from buffer
-			std::shared_ptr<const IdentityEx> GetIdentity () const { return m_Identity; };			
-
-			const uint8_t * GetBuffer () const { return m_Buffer; };
-			size_t GetBufferLen () const { return m_BufferLen; };	
-			bool IsValid () const { return m_IsValid; };
-			const std::vector<std::shared_ptr<const Lease> > GetNonExpiredLeases (bool withThreshold = true) const;
-			bool HasExpiredLeases () const;
-			bool IsExpired () const;
-			bool IsEmpty () const { return m_Leases.empty (); };
-			uint64_t GetExpirationTime () const { return m_ExpirationTime; };
-			bool operator== (const LeaseSet& other) const 
-			{ return m_BufferLen == other.m_BufferLen && !memcmp (m_Buffer, other.m_Buffer, m_BufferLen); }; 
-
-			// implements RoutingDestination
-			const IdentHash& GetIdentHash () const { return m_Identity->GetIdentHash (); };
-			const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionKey; };
-			bool IsDestination () const { return true; };
-
-		private:
-
-			void ReadFromBuffer (bool readIdentity = true);
-			uint64_t ExtractTimestamp (const uint8_t * buf, size_t len) const; // min expiration time
-			
-		private:
-
-			bool m_IsValid, m_StoreLeases; // we don't need to store leases for floodfill
-			std::set<std::shared_ptr<Lease>, LeaseCmp> m_Leases;
-			uint64_t m_ExpirationTime; // in milliseconds
-			std::shared_ptr<const IdentityEx> m_Identity;
-			uint8_t m_EncryptionKey[256];
-			uint8_t * m_Buffer;
-			size_t m_BufferLen;
-	};	
-}		
-}	
-
-#endif

LittleBigEndian.h

@@ -1,242 +0,0 @@
-// LittleBigEndian.h fixed for 64-bits added union
-//
-
-#ifndef LITTLEBIGENDIAN_H
-#define LITTLEBIGENDIAN_H
-
-// Determine Little-Endian or Big-Endian
-
-#define CURRENT_BYTE_ORDER       (*(int *)"\x01\x02\x03\x04")
-#define LITTLE_ENDIAN_BYTE_ORDER 0x04030201
-#define BIG_ENDIAN_BYTE_ORDER    0x01020304
-#define PDP_ENDIAN_BYTE_ORDER    0x02010403
-
-#define IS_LITTLE_ENDIAN (CURRENT_BYTE_ORDER == LITTLE_ENDIAN_BYTE_ORDER)
-#define IS_BIG_ENDIAN    (CURRENT_BYTE_ORDER == BIG_ENDIAN_BYTE_ORDER)
-#define IS_PDP_ENDIAN    (CURRENT_BYTE_ORDER == PDP_ENDIAN_BYTE_ORDER)
-
-// Forward declaration
-
-template<typename T>
-struct LittleEndian;
-
-template<typename T>
-struct BigEndian;
-
-// Little-Endian template
-
-#pragma pack(push,1)
-template<typename T>
-struct LittleEndian
-{
-    union
-    {
-        unsigned char bytes[sizeof(T)];
-        T raw_value;
-    };
-
-    LittleEndian(T t = T())
-    {
-        operator =(t);
-    }
-
-    LittleEndian(const LittleEndian<T> & t)
-    {
-        raw_value = t.raw_value;
-    }
-
-    LittleEndian(const BigEndian<T> & t)
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-            bytes[i] = t.bytes[sizeof(T)-1-i];
-    }
-
-    operator const T() const
-    {
-        T t = T();
-        for (unsigned i = 0; i < sizeof(T); i++)
-            t |= T(bytes[i]) << (i << 3);
-        return t;
-    }
-
-	const T operator = (const T t)
-	{
-		for (unsigned i = 0; i < sizeof(T); i++)
-			bytes[sizeof(T)-1 - i] = static_cast<unsigned char>(t >> (i << 3));
-		return t;
-	}
-
-    // operators
-
-    const T operator += (const T t)
-    {
-        return (*this = *this + t);
-    }
-
-    const T operator -= (const T t)
-    {
-        return (*this = *this - t);
-    }
-
-    const T operator *= (const T t)
-    {
-        return (*this = *this * t);
-    }
-
-    const T operator /= (const T t)
-    {
-        return (*this = *this / t);
-    }
-
-    const T operator %= (const T t)
-    {
-        return (*this = *this % t);
-    }
-
-    LittleEndian<T> operator ++ (int)
-    {
-        LittleEndian<T> tmp(*this);
-        operator ++ ();
-        return tmp;
-    }
-
-    LittleEndian<T> & operator ++ ()
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-        {
-            ++bytes[i];
-            if (bytes[i] != 0)
-                break;
-        }
-        return (*this);
-    }
-
-    LittleEndian<T> operator -- (int)
-    {
-        LittleEndian<T> tmp(*this);
-        operator -- ();
-        return tmp;
-    }
-
-    LittleEndian<T> & operator -- ()
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-        {
-            --bytes[i];
-            if (bytes[i] != (T)(-1))
-                break;
-        }
-        return (*this);
-    }
-};
-#pragma pack(pop)
-
-// Big-Endian template
-
-#pragma pack(push,1)
-template<typename T>
-struct BigEndian
-{
-    union
-    {
-        unsigned char bytes[sizeof(T)];
-        T raw_value;
-    };
-
-    BigEndian(T t = T())
-    {
-        operator =(t);
-    }
-
-    BigEndian(const BigEndian<T> & t)
-    {
-        raw_value = t.raw_value;
-    }
-
-    BigEndian(const LittleEndian<T> & t)
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-            bytes[i] = t.bytes[sizeof(T)-1-i];
-    }
-
-    operator const T() const
-    {
-        T t = T();
-        for (unsigned i = 0; i < sizeof(T); i++)
-            t |= T(bytes[sizeof(T) - 1 - i]) << (i << 3);
-        return t;
-    }
-
-    const T operator = (const T t)
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-            bytes[sizeof(T) - 1 - i] = t >> (i << 3);
-        return t;
-    }
-
-    // operators
-
-    const T operator += (const T t)
-    {
-        return (*this = *this + t);
-    }
-
-    const T operator -= (const T t)
-    {
-        return (*this = *this - t);
-    }
-
-    const T operator *= (const T t)
-    {
-        return (*this = *this * t);
-    }
-
-    const T operator /= (const T t)
-    {
-        return (*this = *this / t);
-    }
-
-    const T operator %= (const T t)
-    {
-        return (*this = *this % t);
-    }
-
-    BigEndian<T> operator ++ (int)
-    {
-        BigEndian<T> tmp(*this);
-        operator ++ ();
-        return tmp;
-    }
-
-    BigEndian<T> & operator ++ ()
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-        {
-            ++bytes[sizeof(T) - 1 - i];
-            if (bytes[sizeof(T) - 1 - i] != 0)
-                break;
-        }
-        return (*this);
-    }
-
-    BigEndian<T> operator -- (int)
-    {
-        BigEndian<T> tmp(*this);
-        operator -- ();
-        return tmp;
-    }
-
-    BigEndian<T> & operator -- ()
-    {
-        for (unsigned i = 0; i < sizeof(T); i++)
-        {
-            --bytes[sizeof(T) - 1 - i];
-            if (bytes[sizeof(T) - 1 - i] != (T)(-1))
-                break;
-        }
-        return (*this);
-    }
-};
-#pragma pack(pop)
-
-#endif // LITTLEBIGENDIAN_H

Log.cpp

@@ -1,86 +0,0 @@
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include "Log.h"
-
-Log * g_Log = nullptr;
-
-static const char * g_LogLevelStr[eNumLogLevels] =
-{
-	"error", // eLogError
-	"warn",  // eLogWarning
-	"info",  // eLogInfo
-	"debug"	 // eLogDebug 
-};
-
-void LogMsg::Process()
-{
-	auto stream = log ? log->GetLogStream () : nullptr;
-	auto& output = stream ? *stream : std::cout;	
-	if (log)	
-		output << log->GetTimestamp ();
-	else
-		output << boost::posix_time::second_clock::local_time().time_of_day ();
-	output << "/" << g_LogLevelStr[level] << " - ";
-	output << s.str();
-}
-
-const std::string& Log::GetTimestamp ()
-{
-#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__)	
-	auto ts = std::chrono::monotonic_clock::now ();	
-#else	
-	auto ts = std::chrono::steady_clock::now ();	
-#endif	
-	if (ts > m_LastTimestampUpdate + std::chrono::milliseconds (500)) // 0.5 second
-	{
-		m_LastTimestampUpdate = ts;
-		m_Timestamp = boost::posix_time::to_simple_string (boost::posix_time::second_clock::local_time().time_of_day ());
-	}		
-	return m_Timestamp;
-}
-
-void Log::Flush ()
-{
-	if (m_LogStream)
-		m_LogStream->flush();
-}
-
-void Log::SetLogFile (const std::string& fullFilePath, bool truncate)
-{
-	m_FullFilePath = fullFilePath;	
-	auto mode = std::ofstream::out | std::ofstream::binary;
-	mode |= truncate ? std::ofstream::trunc : std::ofstream::app;
-	auto logFile = std::make_shared<std::ofstream> (fullFilePath, mode);
-	if (logFile->is_open ())
-	{
-		SetLogStream (logFile);
-		LogPrint(eLogInfo, "Log: will send messages to ",  fullFilePath);
-	}	
-}
-
-void Log::ReopenLogFile ()
-{
-	if (m_FullFilePath.length () > 0)
-	{
-		SetLogFile (m_FullFilePath, false); // don't truncate
-		LogPrint(eLogInfo, "Log: file ", m_FullFilePath,  " reopen");
-	}
-}
-
-
-void Log::SetLogLevel (const std::string& level)
-{
-  if      (level == "error") { m_MinLevel = eLogError; }
-  else if (level == "warn")  { m_MinLevel = eLogWarning;  }
-  else if (level == "info")  { m_MinLevel = eLogInfo;  }
-  else if (level == "debug") { m_MinLevel = eLogDebug; }
-  else {
-		LogPrint(eLogError, "Log: Unknown loglevel: ", level);
-		return;
-  }
-  LogPrint(eLogInfo, "Log: min msg level set to ", level);
-}
-
-void Log::SetLogStream (std::shared_ptr<std::ostream> logStream)
-{
-	m_LogStream = logStream;
-}

Log.h

@@ -1,142 +0,0 @@
-#ifndef LOG_H__
-#define LOG_H__
-
-#include <string>
-#include <iostream>
-#include <sstream>
-#include <fstream>
-#include <functional>
-#include <chrono>
-#include <memory>
-#include "Queue.h"
-
-enum LogLevel
-{
-	eLogError = 0,
-	eLogWarning,
-	eLogInfo,
-	eLogDebug,	
-	eNumLogLevels
-};
-
-class Log;
-struct LogMsg
-{
-	std::stringstream s;
-	Log * log;	
-	LogLevel level;
-
-	LogMsg (Log * l = nullptr, LogLevel lv = eLogInfo): log (l), level (lv) {};
-	
-	void Process();
-};
-
-class Log: public i2p::util::MsgQueue<LogMsg>
-{
-	public:
-
-		Log () { SetOnEmpty (std::bind (&Log::Flush, this)); };
-		~Log () {};
-
-		void SetLogFile (const std::string& fullFilePath, bool truncate = true);
-		void ReopenLogFile ();
-		void SetLogLevel (const std::string& level);
-		void SetLogStream (std::shared_ptr<std::ostream> logStream);
-		std::shared_ptr<std::ostream> GetLogStream () const { return m_LogStream; };	
-		const std::string& GetTimestamp ();
-		LogLevel GetLogLevel () { return m_MinLevel; };
-
-	private:
-
-		void Flush ();
-
-	private:
-		
-		std::string m_FullFilePath; // empty if stream
-		std::shared_ptr<std::ostream> m_LogStream;
-		enum LogLevel m_MinLevel;
-		std::string m_Timestamp;
-#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__) // gcc 4.6
-		std::chrono::monotonic_clock::time_point m_LastTimestampUpdate;
-#else		
-		std::chrono::steady_clock::time_point m_LastTimestampUpdate;	
-#endif		
-};
-
-extern Log * g_Log;
-
-inline void StartLog (const std::string& fullFilePath)
-{
-	if (!g_Log)
-	{	
-		auto log = new Log ();
-		if (fullFilePath.length () > 0)
-			log->SetLogFile (fullFilePath);
-		g_Log = log;
-	}	
-}
-
-inline void StartLog (std::shared_ptr<std::ostream> s)
-{
-	if (!g_Log)
-	{	
-		auto log = new Log ();
-		if (s)
-			log->SetLogStream (s);
-		g_Log = log;
-	}	
-}
-
-inline void StopLog ()
-{
-	if (g_Log)
-	{
-		auto log = g_Log;
-		g_Log = nullptr;
-		log->Stop ();
-		delete log;
-	}		
-}
-
-inline void SetLogLevel (const std::string& level)
-{
-	if (g_Log)	
-		g_Log->SetLogLevel(level);
-}
-
-inline void ReopenLogFile ()
-{
-	if (g_Log)	
-		g_Log->ReopenLogFile ();
-}
-
-template<typename TValue>
-void LogPrint (std::stringstream& s, TValue arg) 
-{
-	s << arg;
-}
- 
-template<typename TValue, typename... TArgs>
-void LogPrint (std::stringstream& s, TValue arg, TArgs... args) 
-{
-	LogPrint (s, arg);
-	LogPrint (s, args...);
-}
-
-template<typename... TArgs>
-void LogPrint (LogLevel level, TArgs... args) 
-{
-	if (g_Log && level > g_Log->GetLogLevel ())
-		return;
-	LogMsg * msg = new LogMsg (g_Log, level);
-	LogPrint (msg->s, args...);
-	msg->s << std::endl;
-	if (g_Log) {
-		g_Log->Put (msg);
-	} else {
-		msg->Process ();
-		delete msg;
-	}
-}
-
-#endif

Makefile

@@ -1,42 +1,73 @@
-UNAME := $(shell uname -s)
+SYS := $(shell $(CXX) -dumpmachine)
 SHLIB := libi2pd.so
 ARLIB := libi2pd.a
 SHLIB_CLIENT := libi2pdclient.so
 ARLIB_CLIENT := libi2pdclient.a
-I2PD  := i2pd
-GREP := fgrep
-DEPS := obj/make.dep
+I2PD := i2pd
 
+LIB_SRC_DIR := libi2pd
+LIB_CLIENT_SRC_DIR := libi2pd_client
+DAEMON_SRC_DIR := daemon
+
+# import source files lists
 include filelist.mk
 
-USE_AESNI  := yes
-USE_STATIC := no
+USE_AESNI	:= yes
+USE_STATIC	:= no
+USE_MESHNET	:= no
+USE_UPNP	:= no
+DEBUG		:= yes
 
-ifeq ($(UNAME),Darwin)
-	DAEMON_SRC += DaemonLinux.cpp
-	include Makefile.osx
-else ifeq ($(shell echo $(UNAME) | $(GREP) -c FreeBSD),1)
-	DAEMON_SRC += DaemonLinux.cpp
-	include Makefile.bsd
-else ifeq ($(UNAME),Linux)
-	DAEMON_SRC += DaemonLinux.cpp
-	include Makefile.linux
-else # win32 mingw
-	DAEMON_SRC += DaemonWin32.cpp Win32/Win32Service.cpp
-	WINDIR := True
-	include Makefile.mingw
+ifeq ($(DEBUG),yes)
+	CXX_DEBUG = -g
+else
+	CXX_DEBUG = -Os
+	LD_DEBUG = -s
 endif
 
-all: mk_build_dir $(ARLIB) $(ARLIB_CLIENT) $(I2PD)
+ifneq (, $(findstring darwin, $(SYS)))
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	ifeq ($(HOMEBREW),1)
+		include Makefile.homebrew
+	else
+		include Makefile.osx
+	endif
+else ifneq (, $(findstring linux, $(SYS))$(findstring gnu, $(SYS)))
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	include Makefile.linux
+else ifneq (, $(findstring freebsd, $(SYS))$(findstring openbsd, $(SYS)))
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	include Makefile.bsd
+else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
+	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32App.cpp Win32/Win32NetState.cpp
+	include Makefile.mingw
+else # not supported
+	$(error Not supported platform)
+endif
 
-mk_build_dir:
-	mkdir -p obj
-     ifeq ($(WINDIR),True)
-	mkdir -p obj/Win32
-     endif
+ifeq ($(USE_MESHNET),yes)
+	NEEDED_CXXFLAGS += -DMESHNET
+endif
 
-api: mk_build_dir $(SHLIB) $(ARLIB)
-api_client: mk_build_dir $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
+NEEDED_CXXFLAGS += -MMD -MP -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR)
+
+LIB_OBJS        += $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
+LIB_CLIENT_OBJS += $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
+DAEMON_OBJS     += $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
+DEPS            += $(LIB_OBJS:.o=.d) $(LIB_CLIENT_OBJS:.o=.d) $(DAEMON_OBJS:.o=.d)
+
+all: mk_obj_dir $(ARLIB) $(ARLIB_CLIENT) $(I2PD)
+
+mk_obj_dir:
+	@mkdir -p obj
+	@mkdir -p obj/Win32
+	@mkdir -p obj/$(LIB_SRC_DIR)
+	@mkdir -p obj/$(LIB_CLIENT_SRC_DIR)
+	@mkdir -p obj/$(DAEMON_SRC_DIR)
+
+api: mk_obj_dir $(SHLIB) $(ARLIB)
+client: mk_obj_dir $(SHLIB_CLIENT) $(ARLIB_CLIENT)
+api_client: mk_obj_dir $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
 
 ## NOTE: The NEEDED_CXXFLAGS are here so that CXXFLAGS can be specified at build time
 ## **without** overwriting the CXXFLAGS which we need in order to build.
@@ -45,51 +76,60 @@ api_client: mk_build_dir $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
 ## -std=c++11. If you want to remove this variable please do so in a way that allows setting
 ## custom FLAGS to work at build-time.
 
-deps:
-	@mkdir -p obj
-	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) -MM *.cpp > $(DEPS)
-	@sed -i -e '/\.o:/ s/^/obj\//' $(DEPS)
-
-obj/%.o : %.cpp
-	@mkdir -p obj
-	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) $(INCFLAGS) $(CPU_FLAGS) -c -o $@ $<
+obj/%.o: %.cpp
+	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) $(INCFLAGS) -c -o $@ $<
 
 # '-' is 'ignore if missing' on first run
 -include $(DEPS)
 
-$(I2PD):  $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC)) $(ARLIB) $(ARLIB_CLIENT)
-	$(CXX) -o $@ $^ $(LDLIBS) $(LDFLAGS)
+$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT)
+	$(CXX) -o $@ $(LDFLAGS) $^ $(LDLIBS)
 
-$(SHLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
+$(SHLIB): $(LIB_OBJS)
 ifneq ($(USE_STATIC),yes)
-	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
+	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
 endif
 
-$(SHLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
-	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
+$(SHLIB_CLIENT): $(LIB_CLIENT_OBJS)
+ifneq ($(USE_STATIC),yes)
+	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS) $(SHLIB)
+endif
 
-$(ARLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
-	ar -r $@ $^
+$(ARLIB): $(LIB_OBJS)
+	$(AR) -r $@ $^
 
-$(ARLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
-	ar -r $@ $^
+$(ARLIB_CLIENT): $(LIB_CLIENT_OBJS)
+	$(AR) -r $@ $^
 
 clean:
-	rm -rf obj
+	$(RM) -r obj
+	$(RM) -r docs/generated
 	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
 
 strip: $(I2PD) $(SHLIB_CLIENT) $(SHLIB)
 	strip $^
 
-LATEST_TAG=$(shell git describe --tags --abbrev=0 master)
+LATEST_TAG=$(shell git describe --tags --abbrev=0 openssl)
+BRANCH=$(shell git rev-parse --abbrev-ref HEAD)
 dist:
 	git archive --format=tar.gz -9 --worktree-attributes \
 	    --prefix=i2pd_$(LATEST_TAG)/ $(LATEST_TAG) -o i2pd_$(LATEST_TAG).tar.gz
 
+last-dist:
+	git archive --format=tar.gz -9 --worktree-attributes \
+	    --prefix=i2pd_$(LATEST_TAG)/ $(BRANCH) -o ../i2pd_$(LATEST_TAG).orig.tar.gz
+
+doxygen:
+	doxygen -s docs/Doxyfile
+
 .PHONY: all
 .PHONY: clean
-.PHONY: deps
+.PHONY: doxygen
 .PHONY: dist
+.PHONY: last-dist
 .PHONY: api
 .PHONY: api_client
-.PHONY: mk_build_dir
+.PHONY: client
+.PHONY: mk_obj_dir
+.PHONY: install
+.PHONY: strip

Makefile.bsd

@@ -1,5 +1,5 @@
 CXX = clang++
-CXXFLAGS = -O2
+CXXFLAGS ?= ${CXX_DEBUG} -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-misleading-indentation
 ## NOTE: NEEDED_CXXFLAGS is here so that custom CXXFLAGS can be specified at build time
 ## **without** overwriting the CXXFLAGS which we need in order to build.
 ## For example, when adding 'hardening flags' to the build
@@ -8,5 +8,5 @@ CXXFLAGS = -O2
 ## custom FLAGS to work at build-time.
 NEEDED_CXXFLAGS = -std=c++11 -D_GLIBCXX_USE_NANOSLEEP=1
 INCFLAGS = -I/usr/include/ -I/usr/local/include/
-LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-LDLIBS = -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_regex -lboost_program_options -lpthread
+LDFLAGS = ${LD_DEBUG} -Wl,-rpath,/usr/local/lib -L/usr/local/lib
+LDLIBS = -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread

Makefile.homebrew

@@ -0,0 +1,51 @@
+# root directory holding homebrew
+BREWROOT = /usr/local
+BOOSTROOT = ${BREWROOT}/opt/boost
+SSLROOT = ${BREWROOT}/opt/openssl@1.1
+UPNPROOT = ${BREWROOT}/opt/miniupnpc
+CXXFLAGS = ${CXX_DEBUG} -Wall -std=c++11 -DMAC_OSX -Wno-overloaded-virtual
+INCFLAGS = -I${SSLROOT}/include -I${BOOSTROOT}/include
+LDFLAGS = ${LD_DEBUG}
+
+ifndef TRAVIS
+	CXX = clang++
+endif
+
+ifeq ($(USE_STATIC),yes)
+	LDLIBS = -lz ${SSLROOT}/lib/libcrypto.a ${SSLROOT}/lib/libssl.a ${BOOSTROOT}/lib/libboost_system.a ${BOOSTROOT}/lib/libboost_date_time.a ${BOOSTROOT}/lib/libboost_filesystem.a ${BOOSTROOT}/lib/libboost_program_options.a -lpthread
+else
+	LDFLAGS += -L${SSLROOT}/lib -L${BOOSTROOT}/lib
+	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
+endif
+
+ifeq ($(USE_UPNP),yes)
+	LDFLAGS += -ldl
+	CXXFLAGS += -DUSE_UPNP
+	INCFLAGS += -I${UPNPROOT}/include
+	ifeq ($(USE_STATIC),yes)
+		LDLIBS += ${UPNPROOT}/lib/libminiupnpc.a
+	else
+		LDFLAGS += -L${UPNPROOT}/lib
+		LDLIBS += -lminiupnpc
+	endif
+endif
+
+# OSX Notes
+# http://www.hutsby.net/2011/08/macs-with-aes-ni.html
+# Seems like all recent Mac's have AES-NI, after firmware upgrade 2.2
+# Found no good way to detect it from command line. TODO: Might be some osx sysinfo magic
+ifeq ($(USE_AESNI),yes)
+	CXXFLAGS += -D__AES__ -maes
+endif
+
+install: all
+	install -d ${PREFIX}/bin ${PREFIX}/etc/i2pd ${PREFIX}/share/doc/i2pd ${PREFIX}/share/i2pd ${PREFIX}/share/man/man1 ${PREFIX}/var/lib/i2pd
+	install -m 755 ${I2PD} ${PREFIX}/bin/
+	install -m 644 contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/etc/i2pd
+	@cp -R contrib/certificates ${PREFIX}/share/i2pd/
+	install -m 644 ChangeLog LICENSE README.md contrib/i2pd.conf contrib/subscriptions.txt contrib/tunnels.conf ${PREFIX}/share/doc/i2pd
+	@gzip debian/i2pd.1 && install debian/i2pd.1.gz ${PREFIX}/share/man/man1
+	@ln -sf ${PREFIX}/share/i2pd/certificates ${PREFIX}/var/lib/i2pd/
+	@ln -sf ${PREFIX}/etc/i2pd/i2pd.conf ${PREFIX}/var/lib/i2pd/i2pd.conf
+	@ln -sf ${PREFIX}/etc/i2pd/subscriptions.txt ${PREFIX}/var/lib/i2pd/subscriptions.txt
+	@ln -sf ${PREFIX}/etc/i2pd/tunnels.conf ${PREFIX}/var/lib/i2pd/tunnels.conf

Makefile.linux

@@ -1,13 +1,13 @@
 # set defaults instead redefine
-CXXFLAGS ?= -g -Wall
-INCFLAGS ?=
+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 FLAGS to work at build-time.
+## custom FDLAGS to work at build-time.
 
 # detect proper flag for c++11 support by compilers
 CXXVER := $(shell $(CXX) -dumpversion)
@@ -15,46 +15,50 @@ ifeq ($(shell expr match $(CXX) 'clang'),5)
 	NEEDED_CXXFLAGS += -std=c++11
 else ifeq ($(shell expr match ${CXXVER} "4\.[0-9][0-9]"),4) # gcc >= 4.10
 	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "4\.[7-9]"),3) # >= 4.7
+else ifeq ($(shell expr match ${CXXVER} "4\.[8-9]"),3) # gcc 4.8 - 4.9
 	NEEDED_CXXFLAGS += -std=c++11 -D_GLIBCXX_USE_NANOSLEEP=1
-else ifeq ($(shell expr match ${CXXVER} "4\.6"),3) # = 4.6
-	NEEDED_CXXFLAGS += -std=c++0x
-else ifeq ($(shell expr match ${CXXVER} "5\.[0-9]"),3) # gcc >= 5.0
+else ifeq ($(shell expr match ${CXXVER} "[5-6]"),1) # gcc 5 - 6
 	NEEDED_CXXFLAGS += -std=c++11
+	LDLIBS = -latomic
+else ifeq ($(shell expr match ${CXXVER} "[1,7-9]"),1) # gcc >= 7
+	NEEDED_CXXFLAGS += -std=c++17
+	LDLIBS = -latomic
 else # not supported
-	$(error Compiler too old)
+$(error Compiler too old)
 endif
 
 NEEDED_CXXFLAGS += -fPIC
 
 ifeq ($(USE_STATIC),yes)
-  LIBDIR := /usr/lib
-  LDLIBS  = $(LIBDIR)/libboost_system.a
-  LDLIBS += $(LIBDIR)/libboost_date_time.a
-  LDLIBS += $(LIBDIR)/libboost_filesystem.a
-  LDLIBS += $(LIBDIR)/libboost_regex.a
-  LDLIBS += $(LIBDIR)/libboost_program_options.a
-  LDLIBS += $(LIBDIR)/libcrypto.a
-  LDLIBS += $(LIBDIR)/libssl.a
-  LDLIBS += $(LIBDIR)/libz.a
-  LDLIBS += -lpthread -static-libstdc++ -static-libgcc
-  USE_AESNI := no
+# NOTE: on glibc you will get this warning:
+#   Using 'getaddrinfo' in statically linked applications requires at runtime
+#   the shared libraries from the glibc version used for linking
+	LIBDIR := /usr/lib/$(SYS)
+	LDLIBS += $(LIBDIR)/libboost_system.a
+	LDLIBS += $(LIBDIR)/libboost_date_time.a
+	LDLIBS += $(LIBDIR)/libboost_filesystem.a
+	LDLIBS += $(LIBDIR)/libboost_program_options.a
+	LDLIBS += $(LIBDIR)/libssl.a
+	LDLIBS += $(LIBDIR)/libcrypto.a
+	LDLIBS += $(LIBDIR)/libz.a
+ifeq ($(USE_UPNP),yes)
+	LDLIBS += $(LIBDIR)/libminiupnpc.a
+endif
+	LDLIBS += -lpthread -ldl
 else
-  LDLIBS = -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_regex -lboost_program_options -lpthread
+	LDLIBS += -lcrypto -lssl -lz -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
+ifeq ($(USE_UPNP),yes)
+	LDLIBS += -lminiupnpc
+endif
 endif
 
-# UPNP Support (miniupnpc 1.5 or 1.6)
-ifeq ($(USE_UPNP),1)
-  LDFLAGS += -ldl
-  CXXFLAGS += -DUSE_UPNP
+# UPNP Support (miniupnpc 1.5 and higher)
+ifeq ($(USE_UPNP),yes)
+	NEEDED_CXXFLAGS += -DUSE_UPNP
 endif
 
-IS_64 := $(shell $(CXX) -dumpmachine 2>&1 | $(GREP) -c "64")
 ifeq ($(USE_AESNI),yes)
-ifeq ($(IS_64),1)
-#check if AES-NI is supported by CPU
-ifneq ($(shell grep -c aes /proc/cpuinfo),0)
-	CPU_FLAGS = -maes -DAESNI
-endif
+ifneq (, $(findstring i386, $(SYS))$(findstring i686, $(SYS))$(findstring x86_64, $(SYS))) # only x86-based CPU supports that
+	NEEDED_CXXFLAGS += -D__AES__ -maes
 endif
 endif

Makefile.mingw

@@ -1,13 +1,65 @@
-CXX = g++
-CXXFLAGS = -O2 -D_MT -DWIN32 -D_WINDOWS -DWIN32_LEAN_AND_MEAN
-NEEDED_CXXFLAGS = -std=c++11
-BOOST_SUFFIX = -mt
-INCFLAGS = -I/usr/include/ -I/usr/local/include/
-LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib -L/c/dev/openssl -L/c/dev/boost/lib
-LDLIBS = -Wl,-Bstatic -lboost_system$(BOOST_SUFFIX) -Wl,-Bstatic -lboost_date_time$(BOOST_SUFFIX) -Wl,-Bstatic -lboost_filesystem$(BOOST_SUFFIX) -Wl,-Bstatic -lboost_regex$(BOOST_SUFFIX) -Wl,-Bstatic -lboost_program_options$(BOOST_SUFFIX) -Wl,-Bstatic -lssl -Wl,-Bstatic -lcrypto -Wl,-Bstatic -lz -Wl,-Bstatic -lwsock32 -Wl,-Bstatic -lws2_32 -Wl,-Bstatic -lgdi32 -Wl,-Bstatic -liphlpapi -static-libgcc -static-libstdc++ -Wl,-Bstatic -lstdc++ -Wl,-Bstatic -lpthread
-
-ifeq ($(USE_AESNI),1)
-	CPU_FLAGS = -maes -DAESNI
-else
-	CPU_FLAGS = -msse
-endif
+# Build application with GUI (tray, main window)
+USE_WIN32_APP := yes
+
+WINDRES = windres
+
+CXXFLAGS := $(CXX_DEBUG) -D_MT -DWIN32_LEAN_AND_MEAN -fPIC -msse
+INCFLAGS = -I$(DAEMON_SRC_DIR) -IWin32
+LDFLAGS := ${LD_DEBUG} -Wl,-Bstatic -static-libgcc
+
+# detect proper flag for c++11 support by compilers
+CXXVER := $(shell $(CXX) -dumpversion)
+ifeq ($(shell expr match ${CXXVER} "[4]\.[7-9]\|4\.1[0-9]\|[5-6]"),4) # gcc 4.7 - 6
+	NEEDED_CXXFLAGS += -std=c++11
+else ifeq ($(shell expr match ${CXXVER} "[1,7-9]"),1) # gcc >= 7
+	NEEDED_CXXFLAGS += -std=c++17
+else # not supported
+$(error Compiler too old)
+endif
+
+# Boost libraries suffix
+BOOST_SUFFIX = -mt
+
+# UPNP Support
+ifeq ($(USE_UPNP),yes)
+	CXXFLAGS += -DUSE_UPNP -DMINIUPNP_STATICLIB
+	LDLIBS = -lminiupnpc
+endif
+
+LDLIBS += \
+	-lboost_system$(BOOST_SUFFIX) \
+	-lboost_date_time$(BOOST_SUFFIX) \
+	-lboost_filesystem$(BOOST_SUFFIX) \
+	-lboost_program_options$(BOOST_SUFFIX) \
+	-lssl \
+	-lcrypto \
+	-lz \
+	-lwsock32 \
+	-lws2_32 \
+	-lgdi32 \
+	-liphlpapi \
+	-lole32 \
+	-luuid \
+	-lpthread
+
+ifeq ($(USE_WIN32_APP), yes)
+	NEEDED_CXXFLAGS += -DWIN32_APP
+	LDFLAGS += -mwindows
+	DAEMON_RC += Win32/Resource.rc
+	DAEMON_OBJS += $(patsubst %.rc,obj/%.o,$(DAEMON_RC))
+endif
+
+ifeq ($(USE_WINXP_FLAGS), yes)
+	NEEDED_CXXFLAGS += -DWINVER=0x0501 -D_WIN32_WINNT=0x0501
+endif
+
+ifeq ($(USE_AESNI),yes)
+	NEEDED_CXXFLAGS += -D__AES__ -maes
+endif
+
+ifeq ($(USE_ASLR),yes)
+	LDFLAGS += -Wl,--nxcompat -Wl,--high-entropy-va -Wl,--dynamicbase,--export-all-symbols
+endif
+
+obj/%.o : %.rc
+	$(WINDRES) -i $< -o $@

Makefile.osx

@@ -1,25 +1,29 @@
 CXX = clang++
-CXXFLAGS = -g -Wall -std=c++11 -DMAC_OSX
-#CXXFLAGS = -g -O2 -Wall -std=c++11
-INCFLAGS = -I/usr/local/include -I/usr/local/ssl/include
-LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib -L/usr/local/ssl/lib
-LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_regex -lboost_program_options -lpthread
+CXXFLAGS := ${CXX_DEBUG} -Wall -std=c++11 -DMAC_OSX
+INCFLAGS = -I/usr/local/include
+LDFLAGS := -Wl,-rpath,/usr/local/lib -L/usr/local/lib
+LDFLAGS += -Wl,-dead_strip
+LDFLAGS += -Wl,-dead_strip_dylibs
+LDFLAGS += -Wl,-bind_at_load
 
-ifeq ($(USE_UPNP),1)
-  LDFLAGS += -ldl
-  CXXFLAGS += -DUSE_UPNP
+ifeq ($(USE_STATIC),yes)
+	LDLIBS = -lz /usr/local/lib/libcrypto.a /usr/local/lib/libssl.a /usr/local/lib/libboost_system.a /usr/local/lib/libboost_date_time.a /usr/local/lib/libboost_filesystem.a /usr/local/lib/libboost_program_options.a -lpthread
+else
+	LDLIBS = -lz -lcrypto -lssl -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lpthread
+endif
+
+ifeq ($(USE_UPNP),yes)
+	LDFLAGS += -ldl
+	CXXFLAGS += -DUSE_UPNP
+	ifeq ($(USE_STATIC),yes)
+		LDLIBS += /usr/local/lib/libminiupnpc.a
+	else
+		LDLIBS += -lminiupnpc
+	endif
 endif
 
-# OSX Notes
-# http://www.hutsby.net/2011/08/macs-with-aes-ni.html
-# Seems like all recent Mac's have AES-NI, after firmware upgrade 2.2
-# Found no good way to detect it from command line. TODO: Might be some osx sysinfo magic
 ifeq ($(USE_AESNI),yes)
-  CXXFLAGS += -maes -DAESNI
+	CXXFLAGS += -D__AES__ -maes
+else
+	CXXFLAGS += -msse
 endif
-
-# Disabled, since it will be the default make rule. I think its better
-# to define the default rule in Makefile and not Makefile.<ostype> - torkel
-#install: all
-#	test -d ${PREFIX} || mkdir -p ${PREFIX}/
-#	cp -r i2p ${PREFIX}/

NTCPSession.cpp

@@ -1,971 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include <openssl/dh.h>
-#include <openssl/sha.h>
-#include <zlib.h>
-#include "I2PEndian.h"
-#include "Base.h"
-#include "Log.h"
-#include "Timestamp.h"
-#include "Crypto.h"
-#include "I2NPProtocol.h"
-#include "RouterContext.h"
-#include "Transports.h"
-#include "NetDb.h"
-#include "NTCPSession.h"
-
-using namespace i2p::crypto;
-
-namespace i2p
-{
-namespace transport
-{
-	NTCPSession::NTCPSession (NTCPServer& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter): 
-		TransportSession (in_RemoteRouter),	m_Server (server), m_Socket (m_Server.GetService ()), 
-		m_TerminationTimer (m_Server.GetService ()), m_IsEstablished (false), m_IsTerminated (false),
-		m_ReceiveBufferOffset (0), m_NextMessage (nullptr), m_IsSending (false)
-	{		
-		m_DHKeysPair = transports.GetNextDHKeysPair ();
-		m_Establisher = new Establisher;
-	}
-	
-	NTCPSession::~NTCPSession ()
-	{
-		delete m_Establisher;
-	}
-
-	void NTCPSession::CreateAESKey (uint8_t * pubKey, i2p::crypto::AESKey& key)
-	{
-		uint8_t sharedKey[256];
-		m_DHKeysPair->Agree (pubKey, sharedKey);
-		
-		uint8_t * aesKey = key;
-		if (sharedKey[0] & 0x80)
-		{
-			aesKey[0] = 0;
-			memcpy (aesKey + 1, sharedKey, 31);
-		}	
-		else if (sharedKey[0])	
-			memcpy (aesKey, sharedKey, 32);
-		else
-		{
-			// find first non-zero byte
-			uint8_t * nonZero = sharedKey + 1;
-			while (!*nonZero)
-			{
-				nonZero++;
-				if (nonZero - sharedKey > 32)
-				{
-					LogPrint (eLogWarning, "NTCP: First 32 bytes of shared key is all zeros, ignored");
-					return;
-				}	
-			}
-			memcpy (aesKey, nonZero, 32);
-		}
-	}	
-
-	void NTCPSession::Done ()
-	{
-		m_Server.GetService ().post (std::bind (&NTCPSession::Terminate, shared_from_this ()));  
-	}	
-		
-	void NTCPSession::Terminate ()
-	{
-		if (!m_IsTerminated)
-		{	
-			m_IsTerminated = true;
-			m_IsEstablished = false;
-			m_Socket.close ();
-			transports.PeerDisconnected (shared_from_this ());
-			m_Server.RemoveNTCPSession (shared_from_this ());
-			m_SendQueue.clear ();
-			m_NextMessage = nullptr;
-			m_TerminationTimer.cancel ();
-			LogPrint (eLogDebug, "NTCP: session terminated");
-		}	
-	}	
-
-	void NTCPSession::Connected ()
-	{
-		m_IsEstablished = true;
-
-		delete m_Establisher;
-		m_Establisher = nullptr;
-		
-		m_DHKeysPair = nullptr;	
-
-		SendTimeSyncMessage ();
-		m_SendQueue.push_back (CreateDatabaseStoreMsg ()); // we tell immediately who we are		
-
-		transports.PeerConnected (shared_from_this ());
-	}	
-		
-	void NTCPSession::ClientLogin ()
-	{
-		if (!m_DHKeysPair)
-			m_DHKeysPair = transports.GetNextDHKeysPair ();
-		// send Phase1
-		const uint8_t * x = m_DHKeysPair->GetPublicKey ();
-		memcpy (m_Establisher->phase1.pubKey, x, 256);
-		SHA256(x, 256, m_Establisher->phase1.HXxorHI);
-		const uint8_t * ident = m_RemoteIdentity->GetIdentHash ();
-		for (int i = 0; i < 32; i++)
-			m_Establisher->phase1.HXxorHI[i] ^= ident[i];
-		
-		boost::asio::async_write (m_Socket, boost::asio::buffer (&m_Establisher->phase1, sizeof (NTCPPhase1)), boost::asio::transfer_all (),
-        	std::bind(&NTCPSession::HandlePhase1Sent, shared_from_this (), std::placeholders::_1, std::placeholders::_2));
-		ScheduleTermination ();
-	}	
-
-	void NTCPSession::ServerLogin ()
-	{
-		boost::system::error_code ec;
-		auto ep = m_Socket.remote_endpoint(ec);	
-		if (!ec)
-		{	
-			m_ConnectedFrom = ep.address ();
-			// receive Phase1
-			boost::asio::async_read (m_Socket, boost::asio::buffer(&m_Establisher->phase1, sizeof (NTCPPhase1)), boost::asio::transfer_all (),                    
-				std::bind(&NTCPSession::HandlePhase1Received, shared_from_this (), 
-					std::placeholders::_1, std::placeholders::_2));
-			ScheduleTermination ();	
-		}
-	}	
-		
-	void NTCPSession::HandlePhase1Sent (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		(void) bytes_transferred;
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: couldn't send Phase 1 message: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			boost::asio::async_read (m_Socket, boost::asio::buffer(&m_Establisher->phase2, sizeof (NTCPPhase2)), boost::asio::transfer_all (),                 
-				std::bind(&NTCPSession::HandlePhase2Received, shared_from_this (), 
-					std::placeholders::_1, std::placeholders::_2));
-		}	
-	}	
-
-	void NTCPSession::HandlePhase1Received (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		(void) bytes_transferred;
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: phase 1 read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			// verify ident
-			uint8_t digest[32];
-			SHA256(m_Establisher->phase1.pubKey, 256, digest);
-			const uint8_t * ident = i2p::context.GetIdentHash ();
-			for (int i = 0; i < 32; i++)
-			{	
-				if ((m_Establisher->phase1.HXxorHI[i] ^ ident[i]) != digest[i])
-				{
-					LogPrint (eLogError, "NTCP: phase 1 error: ident mismatch");
-					Terminate ();
-					return;
-				}	
-			}	
-			
-			SendPhase2 ();
-		}	
-	}	
-
-	void NTCPSession::SendPhase2 ()
-	{
-		if (!m_DHKeysPair)
-			m_DHKeysPair = transports.GetNextDHKeysPair ();
-		const uint8_t * y = m_DHKeysPair->GetPublicKey ();
-		memcpy (m_Establisher->phase2.pubKey, y, 256);
-		uint8_t xy[512];
-		memcpy (xy, m_Establisher->phase1.pubKey, 256);
-		memcpy (xy + 256, y, 256);
-		SHA256(xy, 512, m_Establisher->phase2.encrypted.hxy); 
-		uint32_t tsB = htobe32 (i2p::util::GetSecondsSinceEpoch ());
-		memcpy (m_Establisher->phase2.encrypted.timestamp, &tsB, 4);
-		RAND_bytes (m_Establisher->phase2.encrypted.filler, 12);
-
-		i2p::crypto::AESKey aesKey;
-		CreateAESKey (m_Establisher->phase1.pubKey, aesKey);
-		m_Encryption.SetKey (aesKey);
-		m_Encryption.SetIV (y + 240);
-		m_Decryption.SetKey (aesKey);
-		m_Decryption.SetIV (m_Establisher->phase1.HXxorHI + 16);
-		
-		m_Encryption.Encrypt ((uint8_t *)&m_Establisher->phase2.encrypted, sizeof(m_Establisher->phase2.encrypted), (uint8_t *)&m_Establisher->phase2.encrypted);
-		boost::asio::async_write (m_Socket, boost::asio::buffer (&m_Establisher->phase2, sizeof (NTCPPhase2)), boost::asio::transfer_all (),
-        	std::bind(&NTCPSession::HandlePhase2Sent, shared_from_this (), std::placeholders::_1, std::placeholders::_2, tsB));
-
-	}	
-		
-	void NTCPSession::HandlePhase2Sent (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB)
-	{
-		(void) bytes_transferred;
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: Couldn't send Phase 2 message: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			boost::asio::async_read (m_Socket, boost::asio::buffer(m_ReceiveBuffer, NTCP_DEFAULT_PHASE3_SIZE), boost::asio::transfer_all (),                   
-				std::bind(&NTCPSession::HandlePhase3Received, shared_from_this (), 
-					std::placeholders::_1, std::placeholders::_2, tsB));
-		}	
-	}	
-		
-	void NTCPSession::HandlePhase2Received (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		(void) bytes_transferred;
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: Phase 2 read error: ", ecode.message (), ". Wrong ident assumed");
-			if (ecode != boost::asio::error::operation_aborted)
-			{
-				// this RI is not valid
-				i2p::data::netdb.SetUnreachable (GetRemoteIdentity ()->GetIdentHash (), true);
-				transports.ReuseDHKeysPair (m_DHKeysPair);
-				m_DHKeysPair = nullptr;
-				Terminate ();
-			}
-		}
-		else
-		{	
-			i2p::crypto::AESKey aesKey;
-			CreateAESKey (m_Establisher->phase2.pubKey, aesKey);
-			m_Decryption.SetKey (aesKey);
-			m_Decryption.SetIV (m_Establisher->phase2.pubKey + 240);
-			m_Encryption.SetKey (aesKey);
-			m_Encryption.SetIV (m_Establisher->phase1.HXxorHI + 16);
-			
-			m_Decryption.Decrypt((uint8_t *)&m_Establisher->phase2.encrypted, sizeof(m_Establisher->phase2.encrypted), (uint8_t *)&m_Establisher->phase2.encrypted);
-			// verify
-			uint8_t xy[512];
-			memcpy (xy, m_DHKeysPair->GetPublicKey (), 256);
-			memcpy (xy + 256, m_Establisher->phase2.pubKey, 256);
-			uint8_t digest[32];
-			SHA256 (xy, 512, digest);
-			if (memcmp(m_Establisher->phase2.encrypted.hxy, digest, 32)) 
-			{
-				LogPrint (eLogError, "NTCP: Phase 2 process error: incorrect hash");
-				transports.ReuseDHKeysPair (m_DHKeysPair);
-				m_DHKeysPair = nullptr;
-				Terminate ();
-				return ;
-			}	
-			SendPhase3 ();
-		}	
-	}	
-
-	void NTCPSession::SendPhase3 ()
-	{
-		auto keys = i2p::context.GetPrivateKeys ();
-		uint8_t * buf = m_ReceiveBuffer; 
-		htobe16buf (buf, keys.GetPublic ()->GetFullLen ());
-		buf += 2;
-		buf += i2p::context.GetIdentity ()->ToBuffer (buf, NTCP_BUFFER_SIZE);
-		uint32_t tsA = htobe32 (i2p::util::GetSecondsSinceEpoch ());
-		htobuf32(buf,tsA);
-		buf += 4;		
-		size_t signatureLen = keys.GetPublic ()->GetSignatureLen ();
-		size_t len = (buf - m_ReceiveBuffer) + signatureLen;
-		size_t paddingSize = len & 0x0F; // %16
-		if (paddingSize > 0) 
-		{
-			paddingSize = 16 - paddingSize;
-			// fill padding with random data
-			RAND_bytes(buf, paddingSize);
-			buf += paddingSize;
-			len += paddingSize;
-		}
-
-		SignedData s;
-		s.Insert (m_Establisher->phase1.pubKey, 256); // x
-		s.Insert (m_Establisher->phase2.pubKey, 256); // y
-		s.Insert (m_RemoteIdentity->GetIdentHash (), 32); // ident
- 		s.Insert (tsA);	// tsA
-		s.Insert (m_Establisher->phase2.encrypted.timestamp, 4); // tsB
-		s.Sign (keys, buf);
-
-		m_Encryption.Encrypt(m_ReceiveBuffer, len, m_ReceiveBuffer);		        
-		boost::asio::async_write (m_Socket, boost::asio::buffer (m_ReceiveBuffer, len), boost::asio::transfer_all (),
-        	std::bind(&NTCPSession::HandlePhase3Sent, shared_from_this (), std::placeholders::_1, std::placeholders::_2, tsA));				
-	}	
-		
-	void NTCPSession::HandlePhase3Sent (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsA)
-	{
-		(void) bytes_transferred; 
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: Couldn't send Phase 3 message: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			// wait for phase4 
-			auto signatureLen = m_RemoteIdentity->GetSignatureLen ();
-			size_t paddingSize = signatureLen & 0x0F; // %16
-			if (paddingSize > 0) signatureLen += (16 - paddingSize);	
-			boost::asio::async_read (m_Socket, boost::asio::buffer(m_ReceiveBuffer, signatureLen), boost::asio::transfer_all (),                  
-				std::bind(&NTCPSession::HandlePhase4Received, shared_from_this (), 
-					std::placeholders::_1, std::placeholders::_2, tsA));
-		}	
-	}	
-
-	void NTCPSession::HandlePhase3Received (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB)
-	{	
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: Phase 3 read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			m_Decryption.Decrypt (m_ReceiveBuffer, bytes_transferred, m_ReceiveBuffer);
-			uint8_t * buf = m_ReceiveBuffer;
-			uint16_t size = bufbe16toh (buf);
-			SetRemoteIdentity (std::make_shared<i2p::data::IdentityEx> (buf + 2, size));
-			if (m_Server.FindNTCPSession (m_RemoteIdentity->GetIdentHash ()))
-			{
-				LogPrint (eLogInfo, "NTCP: session already exists");
-				Terminate ();
-			}	
-			size_t expectedSize = size + 2/*size*/ + 4/*timestamp*/ + m_RemoteIdentity->GetSignatureLen ();
-			size_t paddingLen = expectedSize & 0x0F;
-			if (paddingLen) paddingLen = (16 - paddingLen);	
-			if (expectedSize > NTCP_DEFAULT_PHASE3_SIZE)
-			{
-				// we need more bytes for Phase3
-				expectedSize += paddingLen;	
-				boost::asio::async_read (m_Socket, boost::asio::buffer(m_ReceiveBuffer + NTCP_DEFAULT_PHASE3_SIZE, expectedSize - NTCP_DEFAULT_PHASE3_SIZE), boost::asio::transfer_all (),                   
-				std::bind(&NTCPSession::HandlePhase3ExtraReceived, shared_from_this (), 
-					std::placeholders::_1, std::placeholders::_2, tsB, paddingLen));
-			}
-			else
-				HandlePhase3 (tsB, paddingLen);
-		}	
-	}
-
-	void NTCPSession::HandlePhase3ExtraReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB, size_t paddingLen)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogInfo, "NTCP: Phase 3 extra read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{
-			m_Decryption.Decrypt (m_ReceiveBuffer + NTCP_DEFAULT_PHASE3_SIZE, bytes_transferred, m_ReceiveBuffer+ NTCP_DEFAULT_PHASE3_SIZE);
-			HandlePhase3 (tsB, paddingLen);
-		}		
-	}	
-
-	void NTCPSession::HandlePhase3 (uint32_t tsB, size_t paddingLen)
-	{
-		uint8_t * buf = m_ReceiveBuffer + m_RemoteIdentity->GetFullLen () + 2 /*size*/;
-		uint32_t tsA = buf32toh(buf); 
-		buf += 4;
-		buf += paddingLen;	
-
-		// check timestamp
-		auto ts = i2p::util::GetSecondsSinceEpoch ();
-		uint32_t tsA1 = be32toh (tsA);
-		if (tsA1 < ts - NTCP_CLOCK_SKEW || tsA1 > ts + NTCP_CLOCK_SKEW)
-		{
-			LogPrint (eLogError, "NTCP: Phase3 time difference ", ts - tsA1, " exceeds clock skew"); 
-			Terminate ();
-			return;
-		}	
-
-		// check signature
-		SignedData s;
-		s.Insert (m_Establisher->phase1.pubKey, 256); // x
-		s.Insert (m_Establisher->phase2.pubKey, 256); // y
-		s.Insert (i2p::context.GetRouterInfo ().GetIdentHash (), 32); // ident
-		s.Insert (tsA); // tsA
-		s.Insert (tsB); // tsB			
-		if (!s.Verify (m_RemoteIdentity, buf))
-		{	
-			LogPrint (eLogError, "NTCP: signature verification failed");
-			Terminate ();
-			return;
-		}	
-
-		SendPhase4 (tsA, tsB);
-	}
-
-	void NTCPSession::SendPhase4 (uint32_t tsA, uint32_t tsB)
-	{
-		SignedData s;
-		s.Insert (m_Establisher->phase1.pubKey, 256); // x
-		s.Insert (m_Establisher->phase2.pubKey, 256); // y
-		s.Insert (m_RemoteIdentity->GetIdentHash (), 32); // ident
-		s.Insert (tsA); // tsA
-		s.Insert (tsB); // tsB
-		auto keys = i2p::context.GetPrivateKeys ();
- 		auto signatureLen = keys.GetPublic ()->GetSignatureLen ();
-		s.Sign (keys, m_ReceiveBuffer);
-		size_t paddingSize = signatureLen & 0x0F; // %16
-		if (paddingSize > 0) signatureLen += (16 - paddingSize);		
-		m_Encryption.Encrypt (m_ReceiveBuffer, signatureLen, m_ReceiveBuffer);
-
-		boost::asio::async_write (m_Socket, boost::asio::buffer (m_ReceiveBuffer, signatureLen), boost::asio::transfer_all (),
-        	std::bind(&NTCPSession::HandlePhase4Sent, shared_from_this (), std::placeholders::_1, std::placeholders::_2));
-	}	
-
-	void NTCPSession::HandlePhase4Sent (const boost::system::error_code& ecode,  std::size_t bytes_transferred)
-	{
-		(void) bytes_transferred;
-		if (ecode)
-        {
-			LogPrint (eLogWarning, "NTCP: Couldn't send Phase 4 message: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			LogPrint (eLogInfo, "NTCP: Server session from ", m_Socket.remote_endpoint (), " connected");
-			m_Server.AddNTCPSession (shared_from_this ());
-
-			Connected ();
-			m_ReceiveBufferOffset = 0;
-			m_NextMessage = nullptr;
-			Receive ();
-		}	
-	}	
-		
-	void NTCPSession::HandlePhase4Received (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsA)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "NTCP: Phase 4 read error: ", ecode.message (), ". Check your clock");
-			if (ecode != boost::asio::error::operation_aborted)
-			{
-				 // this router doesn't like us	
-				i2p::data::netdb.SetUnreachable (GetRemoteIdentity ()->GetIdentHash (), true);
-				Terminate ();
-			}	
-		}
-		else
-		{	
-			m_Decryption.Decrypt(m_ReceiveBuffer, bytes_transferred, m_ReceiveBuffer);
-
-			// check timestamp
-			uint32_t tsB = bufbe32toh (m_Establisher->phase2.encrypted.timestamp);
-			auto ts = i2p::util::GetSecondsSinceEpoch ();
-			if (tsB < ts - NTCP_CLOCK_SKEW || tsB > ts + NTCP_CLOCK_SKEW)
-			{
-				LogPrint (eLogError, "NTCP: Phase4 time difference ", ts - tsB, " exceeds clock skew"); 
-				Terminate ();
-				return;
-			}	
-			
-			// verify signature
-			SignedData s;
-			s.Insert (m_Establisher->phase1.pubKey, 256); // x
-			s.Insert (m_Establisher->phase2.pubKey, 256); // y
-			s.Insert (i2p::context.GetIdentHash (), 32); // ident
-			s.Insert (tsA); // tsA
-			s.Insert (m_Establisher->phase2.encrypted.timestamp, 4); // tsB
-
-			if (!s.Verify (m_RemoteIdentity, m_ReceiveBuffer))
-			{	
-				LogPrint (eLogError, "NTCP: Phase 4 process error: signature verification failed");
-				Terminate ();
-				return;
-			}	
-			LogPrint (eLogDebug, "NTCP: session to ", m_Socket.remote_endpoint (), " connected");
-			Connected ();
-						
-			m_ReceiveBufferOffset = 0;
-			m_NextMessage = nullptr;
-			Receive ();
-		}
-	}
-
-	void NTCPSession::Receive ()
-	{
-		m_Socket.async_read_some (boost::asio::buffer(m_ReceiveBuffer + m_ReceiveBufferOffset, NTCP_BUFFER_SIZE - m_ReceiveBufferOffset),                
-			std::bind(&NTCPSession::HandleReceived, shared_from_this (), 
-			std::placeholders::_1, std::placeholders::_2));
-	}	
-		
-	void NTCPSession::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (ecode) {
-			if (ecode != boost::asio::error::operation_aborted)
-				LogPrint (eLogDebug, "NTCP: Read error: ", ecode.message ());
-			if (!m_NumReceivedBytes)
-				m_Server.Ban (m_ConnectedFrom);
-			//if (ecode != boost::asio::error::operation_aborted)
-			Terminate ();
-		}
-		else
-		{
-			m_NumReceivedBytes += bytes_transferred;
-			i2p::transport::transports.UpdateReceivedBytes (bytes_transferred);
-			m_ReceiveBufferOffset += bytes_transferred;
-
-			if (m_ReceiveBufferOffset >= 16)
-			{	
-				int numReloads = 0;
-				do
-				{	
-					uint8_t * nextBlock = m_ReceiveBuffer;
-					while (m_ReceiveBufferOffset >= 16)
-					{
-						if (!DecryptNextBlock (nextBlock)) // 16 bytes
-						{
-							Terminate ();
-							return; 
-						}	
-						nextBlock += 16;
-						m_ReceiveBufferOffset -= 16;
-					}	
-					if (m_ReceiveBufferOffset > 0)
-						memcpy (m_ReceiveBuffer, nextBlock, m_ReceiveBufferOffset);
-
-					// try to read more
-					if (numReloads < 5)
-					{	
-						boost::system::error_code ec;
-						size_t moreBytes = m_Socket.available(ec);
-						if (moreBytes)
-						{
-							if (moreBytes > NTCP_BUFFER_SIZE - m_ReceiveBufferOffset)
-								moreBytes = NTCP_BUFFER_SIZE - m_ReceiveBufferOffset;
-							moreBytes = m_Socket.read_some (boost::asio::buffer (m_ReceiveBuffer + m_ReceiveBufferOffset, moreBytes));
-							if (ec)
-							{
-								LogPrint (eLogInfo, "NTCP: Read more bytes error: ", ec.message ());
-								Terminate ();
-								return;
-							}	
-							m_NumReceivedBytes += moreBytes;
-							m_ReceiveBufferOffset += moreBytes;
-							numReloads++;
-						}	
-					}	
-				}	
-				while (m_ReceiveBufferOffset >= 16);
-				m_Handler.Flush ();
-			}	
-			
-			ScheduleTermination (); // reset termination timer
-			Receive ();
-		}	
-	}	
-
-	bool NTCPSession::DecryptNextBlock (const uint8_t * encrypted) // 16 bytes
-	{
-		if (!m_NextMessage) // new message, header expected
-		{	
-			// decrypt header and extract length
-			uint8_t buf[16];
-			m_Decryption.Decrypt (encrypted, buf);
-			uint16_t dataSize = bufbe16toh (buf);
-			if (dataSize)
-			{
-				// new message
-				if (dataSize + 16U > NTCP_MAX_MESSAGE_SIZE - 2) // + 6 + padding
-				{
-					LogPrint (eLogError, "NTCP: data size ", dataSize, " exceeds max size");
-					return false;
-				}
-				auto msg = (dataSize + 16U) <= I2NP_MAX_SHORT_MESSAGE_SIZE - 2 ? NewI2NPShortMessage () : NewI2NPMessage ();
-				m_NextMessage = msg;	
-				memcpy (m_NextMessage->buf, buf, 16);
-				m_NextMessageOffset = 16;
-				m_NextMessage->offset = 2; // size field
-				m_NextMessage->len = dataSize + 2; 
-			}	
-			else
-			{	
-				// timestamp
-				LogPrint (eLogDebug, "NTCP: Timestamp");
-				return true;
-			}	
-		}	
-		else // message continues
-		{	
-			m_Decryption.Decrypt (encrypted, m_NextMessage->buf + m_NextMessageOffset);
-			m_NextMessageOffset += 16;
-		}		
-		
-		if (m_NextMessageOffset >= m_NextMessage->len + 4) // +checksum
-		{	
-			// we have a complete I2NP message
-			uint8_t checksum[4];
-			htobe32buf (checksum, adler32 (adler32 (0, Z_NULL, 0), m_NextMessage->buf, m_NextMessageOffset - 4));
-			if (!memcmp (m_NextMessage->buf + m_NextMessageOffset - 4, checksum, 4))
-			{
-				if (!m_NextMessage->IsExpired ())
-					m_Handler.PutNextMessage (m_NextMessage);
-				else
-					LogPrint (eLogInfo, "NTCP: message expired");
-			}	
-			else
-				LogPrint (eLogWarning, "NTCP: Incorrect adler checksum of message, dropped");
-			m_NextMessage = nullptr;
-		}
-		return true;	
- 	}	
-
-	void NTCPSession::Send (std::shared_ptr<i2p::I2NPMessage> msg)
-	{
-		m_IsSending = true;
-		boost::asio::async_write (m_Socket, CreateMsgBuffer (msg), boost::asio::transfer_all (),                      
-        	std::bind(&NTCPSession::HandleSent, shared_from_this (), std::placeholders::_1, std::placeholders::_2, std::vector<std::shared_ptr<I2NPMessage> >{ msg }));	
-	}
-
-	boost::asio::const_buffers_1 NTCPSession::CreateMsgBuffer (std::shared_ptr<I2NPMessage> msg)
-	{
-		uint8_t * sendBuffer;
-		int len;
-
-		if (msg)
-		{	
-			// regular I2NP
-			if (msg->offset < 2)
-				LogPrint (eLogError, "NTCP: Malformed I2NP message"); // TODO:
-			sendBuffer = msg->GetBuffer () - 2; 
-			len = msg->GetLength ();
-			htobe16buf (sendBuffer, len);
-		}	
-		else
-		{
-			// prepare timestamp
-			sendBuffer = m_TimeSyncBuffer;
-			len = 4;
-			htobuf16(sendBuffer, 0);
-			htobe32buf (sendBuffer + 2, time (0));
-		}	
-		int rem = (len + 6) & 0x0F; // %16
-		int padding = 0;
-		if (rem > 0) {
-			padding = 16 - rem;
-			// fill with random padding
-			RAND_bytes(sendBuffer + len + 2, padding);
-		}
-		htobe32buf (sendBuffer + len + 2 + padding, adler32 (adler32 (0, Z_NULL, 0), sendBuffer, len + 2+ padding));
-
-		int l = len + padding + 6;
-		m_Encryption.Encrypt(sendBuffer, l, sendBuffer);	
-		return boost::asio::buffer ((const uint8_t *)sendBuffer, l);
-	}	
-
-
-	void NTCPSession::Send (const std::vector<std::shared_ptr<I2NPMessage> >& msgs)
-	{
-		m_IsSending = true;
-		std::vector<boost::asio::const_buffer> bufs;
-		for (auto it: msgs)
-			bufs.push_back (CreateMsgBuffer (it));
-		boost::asio::async_write (m_Socket, bufs, boost::asio::transfer_all (),                      
-        	std::bind(&NTCPSession::HandleSent, shared_from_this (), std::placeholders::_1, std::placeholders::_2, msgs));
-	}
-		
-	void NTCPSession::HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred, std::vector<std::shared_ptr<I2NPMessage> > msgs)
-	{
-		(void) msgs;
-		m_IsSending = false;
-		if (ecode)
-        {
-			LogPrint (eLogWarning, "NTCP: Couldn't send msgs: ", ecode.message ());
-			// we shouldn't call Terminate () here, because HandleReceive takes care
-			// TODO: 'delete this' statement in Terminate () must be eliminated later
-			// Terminate ();
-		}
-		else
-		{	
-			m_NumSentBytes += bytes_transferred;
-			i2p::transport::transports.UpdateSentBytes (bytes_transferred);
-			if (!m_SendQueue.empty())
-			{
-				Send (m_SendQueue);
-				m_SendQueue.clear ();
-			}	
-			else
-				ScheduleTermination (); // reset termination timer
-		}	
-	}	
-
-		
-	void NTCPSession::SendTimeSyncMessage ()
-	{
-		Send (nullptr);
-	}	
-
-
-	void NTCPSession::SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs)
-	{
-		m_Server.GetService ().post (std::bind (&NTCPSession::PostI2NPMessages, shared_from_this (), msgs));  
-	}	
-
-	void NTCPSession::PostI2NPMessages (std::vector<std::shared_ptr<I2NPMessage> > msgs)
-	{
-		if (m_IsTerminated) return;
-		if (m_IsSending)
-		{
-			for (auto it: msgs)
-				m_SendQueue.push_back (it);
-		}	
-		else	
-			Send (msgs);
-	}	
-		
-	void NTCPSession::ScheduleTermination ()
-	{
-		m_TerminationTimer.cancel ();
-		m_TerminationTimer.expires_from_now (boost::posix_time::seconds(NTCP_TERMINATION_TIMEOUT));
-		m_TerminationTimer.async_wait (std::bind (&NTCPSession::HandleTerminationTimer,
-			shared_from_this (), std::placeholders::_1));
-	}
-
-	void NTCPSession::HandleTerminationTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{	
-			LogPrint (eLogDebug, "NTCP: No activity for ", NTCP_TERMINATION_TIMEOUT, " seconds");
-			//Terminate ();
-			m_Socket.close ();// invoke Terminate () from HandleReceive 
-		}	
-	}	
-
-//-----------------------------------------
-	NTCPServer::NTCPServer ():
-		m_IsRunning (false), m_Thread (nullptr), m_Work (m_Service), 
-		m_NTCPAcceptor (nullptr), m_NTCPV6Acceptor (nullptr)
-	{
-	}
-		
-	NTCPServer::~NTCPServer ()
-	{
-		Stop ();
-	}	
-
-	void NTCPServer::Start ()
-	{
-		if (!m_IsRunning)
-		{	
-			m_IsRunning = true;
-			m_Thread = new std::thread (std::bind (&NTCPServer::Run, this));
-			// create acceptors
-			auto addresses = context.GetRouterInfo ().GetAddresses ();
-			for (auto& address : addresses)
-			{
-				if (address.transportStyle == i2p::data::RouterInfo::eTransportNTCP && address.host.is_v4 ())
-				{	
-					m_NTCPAcceptor = new boost::asio::ip::tcp::acceptor (m_Service,
-						boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), address.port));
-
-					LogPrint (eLogInfo, "NTCP: Start listening TCP port ", address.port);
-					auto conn = std::make_shared<NTCPSession>(*this);
-					m_NTCPAcceptor->async_accept(conn->GetSocket (), std::bind (&NTCPServer::HandleAccept, this, 
-						conn, std::placeholders::_1));	
-				
-					if (context.SupportsV6 ())
-					{
-						m_NTCPV6Acceptor = new boost::asio::ip::tcp::acceptor (m_Service);
-						m_NTCPV6Acceptor->open (boost::asio::ip::tcp::v6());
-						m_NTCPV6Acceptor->set_option (boost::asio::ip::v6_only (true));
-						m_NTCPV6Acceptor->bind (boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v6(), address.port));
-						m_NTCPV6Acceptor->listen ();
-
-						LogPrint (eLogInfo, "NTCP: Start listening V6 TCP port ", address.port);
-						auto conn = std::make_shared<NTCPSession> (*this);
-						m_NTCPV6Acceptor->async_accept(conn->GetSocket (), std::bind (&NTCPServer::HandleAcceptV6,
-							this, conn, std::placeholders::_1));
-					}	
-				}	
-			}	
-		}	
-	}
-		
-	void NTCPServer::Stop ()
-	{	
-		m_NTCPSessions.clear ();
-
-		if (m_IsRunning)
-		{	
-			m_IsRunning = false;
-			delete m_NTCPAcceptor;
-			m_NTCPAcceptor = nullptr;
-			delete m_NTCPV6Acceptor;
-			m_NTCPV6Acceptor = nullptr;
-
-			m_Service.stop ();
-			if (m_Thread)
-			{	
-				m_Thread->join (); 
-				delete m_Thread;
-				m_Thread = nullptr;
-			}	
-		}	
-	}	
-
-		
-	void NTCPServer::Run () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_Service.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "NTCP: runtime exception: ", ex.what ());
-			}	
-		}	
-	}	
-
-	bool NTCPServer::AddNTCPSession (std::shared_ptr<NTCPSession> session)
-	{
-		if (!session || !session->GetRemoteIdentity ()) return false;
-		auto& ident = session->GetRemoteIdentity ()->GetIdentHash ();
-		auto it = m_NTCPSessions.find (ident);
-		if (it != m_NTCPSessions.end ())
-		{
-			LogPrint (eLogWarning, "NTCP: session to ", ident.ToBase64 (), " already exists");
-			return false;
-		}
-		m_NTCPSessions.insert (std::pair<i2p::data::IdentHash, std::shared_ptr<NTCPSession> >(ident, session));
-		return true;
-	}	
-
-	void NTCPServer::RemoveNTCPSession (std::shared_ptr<NTCPSession> session)
-	{
-		if (session && session->GetRemoteIdentity ())
-			m_NTCPSessions.erase (session->GetRemoteIdentity ()->GetIdentHash ());
-	}	
-
-	std::shared_ptr<NTCPSession> NTCPServer::FindNTCPSession (const i2p::data::IdentHash& ident)
-	{
-		auto it = m_NTCPSessions.find (ident);
-		if (it != m_NTCPSessions.end ())
-			return it->second;
-		return nullptr;
-	}	
-		
-	void NTCPServer::HandleAccept (std::shared_ptr<NTCPSession> conn, const boost::system::error_code& error)
-	{		
-		if (!error)
-		{
-			boost::system::error_code ec;
-			auto ep = conn->GetSocket ().remote_endpoint(ec);	
-			if (!ec)
-			{
-				LogPrint (eLogDebug, "NTCP: Connected from ", ep);
-				auto it = m_BanList.find (ep.address ());
-				if (it != m_BanList.end ())
-				{
-					uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-					if (ts < it->second)
-					{
-						LogPrint (eLogWarning, "NTCP: ", ep.address (), " is banned for ", it->second - ts, " more seconds");
-						conn = nullptr;
-					}
-					else
-						m_BanList.erase (it);
-				}
-				if (conn)
-					conn->ServerLogin ();
-			}
-			else
-				LogPrint (eLogError, "NTCP: Connected from error ", ec.message ());
-		}
-		
-
-		if (error != boost::asio::error::operation_aborted)
-		{
-    		conn = std::make_shared<NTCPSession> (*this);
-			m_NTCPAcceptor->async_accept(conn->GetSocket (), std::bind (&NTCPServer::HandleAccept, this, 
-				conn, std::placeholders::_1));
-		}	
-	}
-
-	void NTCPServer::HandleAcceptV6 (std::shared_ptr<NTCPSession> conn, const boost::system::error_code& error)
-	{		
-		if (!error)
-		{
-			boost::system::error_code ec;
-			auto ep = conn->GetSocket ().remote_endpoint(ec);	
-			if (!ec)
-			{
-				LogPrint (eLogDebug, "NTCP: Connected from ", ep);
-				auto it = m_BanList.find (ep.address ());
-				if (it != m_BanList.end ())
-				{
-					uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-					if (ts < it->second)
-					{
-						LogPrint (eLogWarning, "NTCP: ", ep.address (), " is banned for ", it->second - ts, " more seconds");
-						conn = nullptr;
-					}
-					else
-						m_BanList.erase (it);
-				}
-				if (conn)
-					conn->ServerLogin ();
-			}
-			else
-				LogPrint (eLogError, "NTCP: Connected from error ", ec.message ());
-		}
-
-		if (error != boost::asio::error::operation_aborted)
-		{
-    		conn = std::make_shared<NTCPSession> (*this);
-			m_NTCPV6Acceptor->async_accept(conn->GetSocket (), std::bind (&NTCPServer::HandleAcceptV6, this, 
-				conn, std::placeholders::_1));
-		}	
-	}	
-
-	void NTCPServer::Connect (const boost::asio::ip::address& address, int port, std::shared_ptr<NTCPSession> conn)
-	{
-		LogPrint (eLogDebug, "NTCP: Connecting to ", address ,":",  port);
-		m_Service.post([=]()
-		{           
-			if (this->AddNTCPSession (conn))
-				conn->GetSocket ().async_connect (boost::asio::ip::tcp::endpoint (address, port), 
-					std::bind (&NTCPServer::HandleConnect, this, std::placeholders::_1, conn));	
-		});	
-	}
-
-	void NTCPServer::HandleConnect (const boost::system::error_code& ecode, std::shared_ptr<NTCPSession> conn)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "NTCP: Connect error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				i2p::data::netdb.SetUnreachable (conn->GetRemoteIdentity ()->GetIdentHash (), true);
-			conn->Terminate ();
-		}
-		else
-		{
-			LogPrint (eLogDebug, "NTCP: Connected to ", conn->GetSocket ().remote_endpoint ());
-			if (conn->GetSocket ().local_endpoint ().protocol () == boost::asio::ip::tcp::v6()) // ipv6
-				context.UpdateNTCPV6Address (conn->GetSocket ().local_endpoint ().address ());
-			conn->ClientLogin ();
-		}	
-	}	
-
-	void NTCPServer::Ban (const boost::asio::ip::address& addr)
-	{
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();	
-		m_BanList[addr] = ts + NTCP_BAN_EXPIRATION_TIMEOUT;
-		LogPrint (eLogWarning, "NTCP: ", addr, " has been banned for ", NTCP_BAN_EXPIRATION_TIMEOUT, " seconds");
-	}
-}	
-}	

NTCPSession.h

@@ -1,177 +0,0 @@
-#ifndef NTCP_SESSION_H__
-#define NTCP_SESSION_H__
-
-#include <inttypes.h>
-#include <map>
-#include <memory>
-#include <thread>
-#include <mutex>
-#include <boost/asio.hpp>
-#include "Crypto.h"
-#include "Identity.h"
-#include "RouterInfo.h"
-#include "I2NPProtocol.h"
-#include "TransportSession.h"
-
-namespace i2p
-{
-namespace transport
-{
-	struct NTCPPhase1
-	{
-		uint8_t pubKey[256];
-		uint8_t HXxorHI[32];
-	};	
-	
-	struct NTCPPhase2
-	{
-		uint8_t pubKey[256];
-		struct
-		{
-			uint8_t hxy[32];
-			uint8_t timestamp[4];
-			uint8_t filler[12];
-		} encrypted;	
-	};	
-
-	const size_t NTCP_MAX_MESSAGE_SIZE = 16384; 
-	const size_t NTCP_BUFFER_SIZE = 4160; // fits 4 tunnel messages (4*1028)
-	const int NTCP_TERMINATION_TIMEOUT = 120; // 2 minutes
-	const size_t NTCP_DEFAULT_PHASE3_SIZE = 2/*size*/ + i2p::data::DEFAULT_IDENTITY_SIZE/*387*/ + 4/*ts*/ + 15/*padding*/ + 40/*signature*/; // 448 	
-	const int NTCP_BAN_EXPIRATION_TIMEOUT = 70; // in second
-	const int NTCP_CLOCK_SKEW = 60; // in seconds 
-
-	class NTCPServer;
-	class NTCPSession: public TransportSession, public std::enable_shared_from_this<NTCPSession>
-	{
-		public:
-
-			NTCPSession (NTCPServer& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter = nullptr);
-			~NTCPSession ();
-			void Terminate ();
-			void Done ();
-
-			boost::asio::ip::tcp::socket& GetSocket () { return m_Socket; };
-			bool IsEstablished () const { return m_IsEstablished; };
-			
-			void ClientLogin ();
-			void ServerLogin ();
-			void SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs);
-			
-		private:
-
-			void PostI2NPMessages (std::vector<std::shared_ptr<I2NPMessage> > msgs);
-			void Connected ();
-			void SendTimeSyncMessage ();
-			void SetIsEstablished (bool isEstablished) { m_IsEstablished = isEstablished; }
-
-			void CreateAESKey (uint8_t * pubKey, i2p::crypto::AESKey& key);
-				
-			// client
-			void SendPhase3 ();
-			void HandlePhase1Sent (const boost::system::error_code& ecode,  std::size_t bytes_transferred);
-			void HandlePhase2Received (const boost::system::error_code& ecode, std::size_t bytes_transferred);
-			void HandlePhase3Sent (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsA);
-			void HandlePhase4Received (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsA);
-
-			//server
-			void SendPhase2 ();
-			void SendPhase4 (uint32_t tsA, uint32_t tsB);
-			void HandlePhase1Received (const boost::system::error_code& ecode, std::size_t bytes_transferred);
-			void HandlePhase2Sent (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB);
-			void HandlePhase3Received (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB);
-			void HandlePhase3ExtraReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred, uint32_t tsB, size_t paddingLen);
-			void HandlePhase3 (uint32_t tsB, size_t paddingLen);
-			void HandlePhase4Sent (const boost::system::error_code& ecode,  std::size_t bytes_transferred);
-			
-			// common
-			void Receive ();
-			void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);
-			bool DecryptNextBlock (const uint8_t * encrypted);	
-		
-			void Send (std::shared_ptr<i2p::I2NPMessage> msg);
-			boost::asio::const_buffers_1 CreateMsgBuffer (std::shared_ptr<I2NPMessage> msg);
-			void Send (const std::vector<std::shared_ptr<I2NPMessage> >& msgs);
-			void HandleSent (const boost::system::error_code& ecode, std::size_t bytes_transferred, std::vector<std::shared_ptr<I2NPMessage> > msgs);
-			
-			
-			// timer
-			void ScheduleTermination ();
-			void HandleTerminationTimer (const boost::system::error_code& ecode);
-			
-		private:
-
-			NTCPServer& m_Server;
-			boost::asio::ip::tcp::socket m_Socket;
-			boost::asio::deadline_timer m_TerminationTimer;
-			bool m_IsEstablished, m_IsTerminated;
-			
-			i2p::crypto::CBCDecryption m_Decryption;
-			i2p::crypto::CBCEncryption m_Encryption;
-
-			struct Establisher
-			{	
-				NTCPPhase1 phase1;
-				NTCPPhase2 phase2;
-			} * m_Establisher;	
-			
-			i2p::crypto::AESAlignedBuffer<NTCP_BUFFER_SIZE + 16> m_ReceiveBuffer;
-			i2p::crypto::AESAlignedBuffer<16> m_TimeSyncBuffer;
-			int m_ReceiveBufferOffset; 
-
-			std::shared_ptr<I2NPMessage> m_NextMessage;
-			size_t m_NextMessageOffset;
-			i2p::I2NPMessagesHandler m_Handler;
-
-			bool m_IsSending;
-			std::vector<std::shared_ptr<I2NPMessage> > m_SendQueue;
-			
-			boost::asio::ip::address m_ConnectedFrom; // for ban
-	};	
-
-	// TODO: move to NTCP.h/.cpp
-	class NTCPServer
-	{
-		public:
-
-			NTCPServer ();
-			~NTCPServer ();
-
-			void Start ();
-			void Stop ();
-
-			bool AddNTCPSession (std::shared_ptr<NTCPSession> session);
-			void RemoveNTCPSession (std::shared_ptr<NTCPSession> session);
-			std::shared_ptr<NTCPSession> FindNTCPSession (const i2p::data::IdentHash& ident);
-			void Connect (const boost::asio::ip::address& address, int port, std::shared_ptr<NTCPSession> conn);
-			
-			boost::asio::io_service& GetService () { return m_Service; };
-			void Ban (const boost::asio::ip::address& addr);			
-
-		private:
-
-			void Run ();
-			void HandleAccept (std::shared_ptr<NTCPSession> conn, const boost::system::error_code& error);
-			void HandleAcceptV6 (std::shared_ptr<NTCPSession> conn, const boost::system::error_code& error);
-
-			void HandleConnect (const boost::system::error_code& ecode, std::shared_ptr<NTCPSession> conn);
-			
-		private:	
-
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			boost::asio::io_service m_Service;
-			boost::asio::io_service::work m_Work;
-			boost::asio::ip::tcp::acceptor * m_NTCPAcceptor, * m_NTCPV6Acceptor;
-			std::map<i2p::data::IdentHash, std::shared_ptr<NTCPSession> > m_NTCPSessions; // access from m_Thread only
-			std::map<boost::asio::ip::address, uint32_t> m_BanList; // IP -> ban expiration time in seconds
-
-		public:
-
-			// for HTTP/I2PControl
-			const decltype(m_NTCPSessions)& GetNTCPSessions () const { return m_NTCPSessions; };
-	};	
-}	
-}	
-
-#endif

NetDb.cpp

@@ -1,976 +0,0 @@
-#include <string.h>
-#include <fstream>
-#include <vector>
-#include <boost/asio.hpp>
-#include <openssl/rand.h>
-#include <zlib.h>
-#include "I2PEndian.h"
-#include "Base.h"
-#include "Log.h"
-#include "Timestamp.h"
-#include "I2NPProtocol.h"
-#include "Tunnel.h"
-#include "Transports.h"
-#include "RouterContext.h"
-#include "Garlic.h"
-#include "NetDb.h"
-#include "util.h"
-
-using namespace i2p::transport;
-
-namespace i2p
-{
-namespace data
-{		
-	NetDb netdb;
-
-	NetDb::NetDb (): m_IsRunning (false), m_Thread (nullptr), m_Reseeder (nullptr), m_Storage("netDb", "r", "routerInfo-", "dat")
-	{
-	}
-	
-	NetDb::~NetDb ()
-	{
-		Stop ();	
-		delete m_Reseeder;
-	}	
-
-	void NetDb::Start ()
-	{	
-		m_Storage.SetPlace(i2p::fs::GetDataDir());
-		m_Storage.Init(i2p::data::GetBase64SubstitutionTable(), 64);
-		InitProfilesStorage ();
-		m_Families.LoadCertificates ();	
-		Load ();
-		if (m_RouterInfos.size () < 25) // reseed if # of router less than 50
-			Reseed ();
-
-		m_IsRunning = true;
-		m_Thread = new std::thread (std::bind (&NetDb::Run, this));
-	}
-	
-	void NetDb::Stop ()
-	{
-		if (m_IsRunning)
-		{	
-			for (auto it: m_RouterInfos)
-				it.second->SaveProfile ();
-			DeleteObsoleteProfiles ();
-			m_RouterInfos.clear ();
-			m_Floodfills.clear ();
-			if (m_Thread)
-			{	
-				m_IsRunning = false;
-				m_Queue.WakeUp ();
-				m_Thread->join (); 
-				delete m_Thread;
-				m_Thread = 0;
-			}
-			m_LeaseSets.clear();
-			m_Requests.Stop ();
-		}	
-	}	
-	
-	void NetDb::Run ()
-	{
-		uint32_t lastSave = 0, lastPublish = 0, lastExploratory = 0, lastManageRequest = 0;
-		while (m_IsRunning)
-		{	
-			try
-			{	
-				auto msg = m_Queue.GetNextWithTimeout (15000); // 15 sec
-				if (msg)
-				{	
-					int numMsgs = 0;	
-					while (msg)
-					{
-						LogPrint(eLogDebug, "NetDb: got request with type ", (int) msg->GetTypeID ());
-						switch (msg->GetTypeID ()) 
-						{
-							case eI2NPDatabaseStore:	
-								HandleDatabaseStoreMsg (msg);
-							break;
-							case eI2NPDatabaseSearchReply:
-								HandleDatabaseSearchReplyMsg (msg);
-							break;
-							case eI2NPDatabaseLookup:
-								HandleDatabaseLookupMsg (msg);
-							break;	
-							default: // WTF?
-								LogPrint (eLogError, "NetDb: unexpected message type ", (int) msg->GetTypeID ());
-								//i2p::HandleI2NPMessage (msg);
-						}	
-						if (numMsgs > 100) break;
-						msg = m_Queue.Get ();
-						numMsgs++;
-					}	
-				}			
-				if (!m_IsRunning) break;
-
-				uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-				if (ts - lastManageRequest >= 15) // manage requests every 15 seconds
-				{
-					m_Requests.ManageRequests ();
-					lastManageRequest = ts;
-				}	
-				if (ts - lastSave >= 60) // save routers, manage leasesets and validate subscriptions every minute
-				{
-					if (lastSave)
-					{
-						SaveUpdated ();
-						ManageLeaseSets ();
-					}	
-					lastSave = ts;
-				}	
-				if (ts - lastPublish >= 2400) // publish every 40 minutes
-				{
-					Publish ();
-					lastPublish = ts;
-				}	
-				if (ts - lastExploratory >= 30) // exploratory every 30 seconds
-				{	
-					auto numRouters = m_RouterInfos.size ();
-					if (numRouters == 0)
-					{
-						LogPrint(eLogError, "NetDb: no known routers, reseed seems to be totally failed");
-						break;
-					}
-					if (numRouters < 2500 || ts - lastExploratory >= 90)
-					{	
-						numRouters = 800/numRouters;
-						if (numRouters < 1) numRouters = 1;
-						if (numRouters > 9) numRouters = 9;	
-						m_Requests.ManageRequests ();					
-						Explore (numRouters);
-						lastExploratory = ts;
-					}	
-				}	
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "NetDb: runtime exception: ", ex.what ());
-			}	
-		}	
-	}	
-	
-	bool NetDb::AddRouterInfo (const uint8_t * buf, int len)
-	{
-		IdentityEx identity;
-		if (identity.FromBuffer (buf, len))
-			return AddRouterInfo (identity.GetIdentHash (), buf, len);	
-		return false;
-	}
-
-	bool NetDb::AddRouterInfo (const IdentHash& ident, const uint8_t * buf, int len)
-	{	
-		bool updated = true;	
-		auto r = FindRouter (ident);
-		if (r)
-		{
-			if (r->IsNewer (buf, len))
-			{
-				r->Update (buf, len);
-				LogPrint (eLogInfo, "NetDb: RouterInfo updated: ", ident.ToBase64());
-				// TODO: check if floodfill has been changed
-			}
-			else
-			{
-				LogPrint (eLogDebug, "NetDb: RouterInfo is older: ", ident.ToBase64());
-				updated = false;
-			}
-		}	
-		else	
-		{	
-			r = std::make_shared<RouterInfo> (buf, len);
-			if (!r->IsUnreachable ())
-			{
-				LogPrint (eLogInfo, "NetDb: RouterInfo added: ", ident.ToBase64());
-				{
-					std::unique_lock<std::mutex> l(m_RouterInfosMutex);
-					m_RouterInfos[r->GetIdentHash ()] = r;
-				}
-				if (r->IsFloodfill () && r->IsReachable ()) // floodfill must be reachable
-				{
-					std::unique_lock<std::mutex> l(m_FloodfillsMutex);
-					m_Floodfills.push_back (r);
-				}
-			}	
-			else
-				updated = false;
-		}	
-		// take care about requested destination
-		m_Requests.RequestComplete (ident, r);
-		return updated;
-	}	
-
-	bool NetDb::AddLeaseSet (const IdentHash& ident, const uint8_t * buf, int len,
-		std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		bool updated = false;
-		if (!from) // unsolicited LS must be received directly
-		{	
-			auto it = m_LeaseSets.find(ident);
-			if (it != m_LeaseSets.end ())
-			{
-				if (it->second->IsNewer (buf, len))
-				{
-					it->second->Update (buf, len); 
-					if (it->second->IsValid ())
-					{
-						LogPrint (eLogInfo, "NetDb: LeaseSet updated: ", ident.ToBase64());
-						updated = true;	
-					}
-					else
-					{
-						LogPrint (eLogWarning, "NetDb: LeaseSet update failed: ", ident.ToBase64());
-						m_LeaseSets.erase (it);
-					}	
-				}
-				else
-					LogPrint (eLogDebug, "NetDb: LeaseSet is older: ", ident.ToBase64());
-			}
-			else
-			{	
-				auto leaseSet = std::make_shared<LeaseSet> (buf, len, false); // we don't need leases in netdb 
-				if (leaseSet->IsValid ())
-				{
-					LogPrint (eLogInfo, "NetDb: LeaseSet added: ", ident.ToBase64());
-					m_LeaseSets[ident] = leaseSet;
-					updated = true;
-				}
-				else
-					LogPrint (eLogError, "NetDb: new LeaseSet validation failed: ", ident.ToBase64());
-			}	
-		}	
-		return updated;
-	}	
-
-	std::shared_ptr<RouterInfo> NetDb::FindRouter (const IdentHash& ident) const
-	{
-		std::unique_lock<std::mutex> l(m_RouterInfosMutex);
-		auto it = m_RouterInfos.find (ident);
-		if (it != m_RouterInfos.end ())
-			return it->second;
-		else
-			return nullptr;
-	}
-
-	std::shared_ptr<LeaseSet> NetDb::FindLeaseSet (const IdentHash& destination) const
-	{
-		auto it = m_LeaseSets.find (destination);
-		if (it != m_LeaseSets.end ())
-			return it->second;
-		else
-			return nullptr;
-	}
-
-	std::shared_ptr<RouterProfile> NetDb::FindRouterProfile (const IdentHash& ident) const
-	{
-		auto router = FindRouter (ident);
-		return router ? router->GetProfile () : nullptr;
-	}	
-	
-	void NetDb::SetUnreachable (const IdentHash& ident, bool unreachable)
-	{
-		auto it = m_RouterInfos.find (ident);
-		if (it != m_RouterInfos.end ())
-			return it->second->SetUnreachable (unreachable);
-	}
-
-	void NetDb::Reseed ()
-	{
-		if (!m_Reseeder)
-		{		
-			m_Reseeder = new Reseeder ();
-			m_Reseeder->LoadCertificates (); // we need certificates for SU3 verification
-		}
-		int reseedRetries = 0;	
-		while (reseedRetries < 10 && !m_Reseeder->ReseedNowSU3 ())
-			reseedRetries++;
-		if (reseedRetries >= 10)
-			LogPrint (eLogWarning, "NetDb: failed to reseed after 10 attempts");
-	}
-
-	bool NetDb::LoadRouterInfo (const std::string & path)
-	{
-		auto r = std::make_shared<RouterInfo>(path);
-		if (r->GetRouterIdentity () && !r->IsUnreachable () &&
-				(!r->UsesIntroducer () || m_LastLoad < r->GetTimestamp () + NETDB_INTRODUCEE_EXPIRATION_TIMEOUT*1000LL)) // 1 hour
-		{
-			r->DeleteBuffer ();
-			r->ClearProperties (); // properties are not used for regular routers
-			m_RouterInfos[r->GetIdentHash ()] = r;
-			if (r->IsFloodfill () && r->IsReachable ()) // floodfill must be reachable
-				m_Floodfills.push_back (r);
-		}	
-		else 
-		{
-			LogPrint(eLogWarning, "NetDb: RI from ", path, " is invalid. Delete");
-			i2p::fs::Remove(path);
-		}
-		return true;
-	}
-
-	void NetDb::Load ()
-	{
-		// make sure we cleanup netDb from previous attempts
-		m_RouterInfos.clear ();	
-		m_Floodfills.clear ();	
-
-		m_LastLoad = i2p::util::GetSecondsSinceEpoch();
-		std::vector<std::string> files;
-		m_Storage.Traverse(files);
-		for (auto path : files)
-			LoadRouterInfo(path);
-
-		LogPrint (eLogInfo, "NetDb: ", m_RouterInfos.size(), " routers loaded (", m_Floodfills.size (), " floodfils)");
-	}	
-
-	void NetDb::SaveUpdated ()
-	{	
-		int updatedCount = 0, deletedCount = 0;
-		auto total = m_RouterInfos.size ();
-		uint64_t expirationTimeout = NETDB_MAX_EXPIRATION_TIMEOUT*1000LL; 
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch();
-		// routers don't expire if less than 90 or uptime is less than 1 hour	
-		bool checkForExpiration = total > NETDB_MIN_ROUTERS && ts > (i2p::context.GetStartupTime () + 600)*1000LL; // 10 minutes	
-		if (checkForExpiration && ts > (i2p::context.GetStartupTime () + 3600)*1000LL) // 1 hour			
-			expirationTimeout = i2p::context.IsFloodfill () ? NETDB_FLOODFILL_EXPIRATION_TIMEOUT*1000LL :
-					NETDB_MIN_EXPIRATION_TIMEOUT*1000LL + (NETDB_MAX_EXPIRATION_TIMEOUT - NETDB_MIN_EXPIRATION_TIMEOUT)*1000LL*NETDB_MIN_ROUTERS/total;	
-
-		for (auto it: m_RouterInfos)
-		{	
-			std::string ident = it.second->GetIdentHashBase64();
-			std::string path  = m_Storage.Path(ident);
-			if (it.second->IsUpdated ()) 
-			{
-				it.second->SaveToFile (path);
-				it.second->SetUpdated (false);
-				it.second->SetUnreachable (false);
-				it.second->DeleteBuffer ();
-				updatedCount++;
-				continue;
-			}
-			// find & mark expired routers
-			if (it.second->UsesIntroducer ())
-			{
-				 if (ts > it.second->GetTimestamp () + NETDB_INTRODUCEE_EXPIRATION_TIMEOUT*1000LL) 
-				// RouterInfo expires after 1 hour if uses introducer
-					it.second->SetUnreachable (true);
-			}
-			else if (checkForExpiration && ts > it.second->GetTimestamp () + expirationTimeout) 
-					it.second->SetUnreachable (true);
-
-			if (it.second->IsUnreachable ()) 
-			{
-				// delete RI file
-				m_Storage.Remove(ident);
-				deletedCount++;
-				if (total - deletedCount < NETDB_MIN_ROUTERS) checkForExpiration = false;
-			}
-		} // m_RouterInfos iteration
-		
-		if (updatedCount > 0)
-			LogPrint (eLogInfo, "NetDb: saved ", updatedCount, " new/updated routers");
-		if (deletedCount > 0)
-		{
-			LogPrint (eLogInfo, "NetDb: deleting ", deletedCount, " unreachable routers");
-			// clean up RouterInfos table
-			{
-				std::unique_lock<std::mutex> l(m_RouterInfosMutex);
-				for (auto it = m_RouterInfos.begin (); it != m_RouterInfos.end ();)
-				{
-					if (it->second->IsUnreachable ()) 
-					{
-						it->second->SaveProfile ();
-						it = m_RouterInfos.erase (it);
-						continue;
-					}	
-					it++;
-				}
-			}	
-			// clean up expired floodfiils
-			{
-				std::unique_lock<std::mutex> l(m_FloodfillsMutex);
-				for (auto it = m_Floodfills.begin (); it != m_Floodfills.end ();)
-					if ((*it)->IsUnreachable ())
-						it = m_Floodfills.erase (it);
-					else
-						it++;
-			}	
-		}
-	}
-
-	void NetDb::RequestDestination (const IdentHash& destination, RequestedDestination::RequestComplete requestComplete)
-	{
-		auto dest = m_Requests.CreateRequest (destination, false, requestComplete); // non-exploratory
-		if (!dest)
-		{
-			LogPrint (eLogWarning, "NetDb: destination ", destination.ToBase64(), " is requested already");
-			return;			
-		}
-
-		auto floodfill = GetClosestFloodfill (destination, dest->GetExcludedPeers ());
-		if (floodfill)
-			transports.SendMessage (floodfill->GetIdentHash (), dest->CreateRequestMessage (floodfill->GetIdentHash ()));	
-		else
-		{
-			LogPrint (eLogError, "NetDb: ", destination.ToBase64(), " destination requested, but no floodfills found");
-			m_Requests.RequestComplete (destination, nullptr);
-		}	
-	}	
-	
-	void NetDb::HandleDatabaseStoreMsg (std::shared_ptr<const I2NPMessage> m)
-	{	
-		const uint8_t * buf = m->GetPayload ();
-		size_t len = m->GetSize ();		
-		IdentHash ident (buf + DATABASE_STORE_KEY_OFFSET);
-		if (ident.IsZero ())
-		{
-			LogPrint (eLogError, "NetDb: database store with zero ident, dropped");
-			return;
-		}	
-		uint32_t replyToken = bufbe32toh (buf + DATABASE_STORE_REPLY_TOKEN_OFFSET);
-		size_t offset = DATABASE_STORE_HEADER_SIZE;
-		if (replyToken)
-		{
-			auto deliveryStatus = CreateDeliveryStatusMsg (replyToken);			
-			uint32_t tunnelID = bufbe32toh (buf + offset);
-			offset += 4;
-			if (!tunnelID) // send response directly
-				transports.SendMessage (buf + offset, deliveryStatus);
-			else
-			{
-				auto pool = i2p::tunnel::tunnels.GetExploratoryPool ();
-				auto outbound = pool ? pool->GetNextOutboundTunnel () : nullptr;
-				if (outbound)
-					outbound->SendTunnelDataMsg (buf + offset, tunnelID, deliveryStatus);
-				else
-					LogPrint (eLogError, "NetDb: no outbound tunnels for DatabaseStore reply found");
-			}		
-			offset += 32;
-		}
-		size_t payloadOffset = offset;		
-
-		bool updated = false;
-		if (buf[DATABASE_STORE_TYPE_OFFSET]) // type
-		{
-			LogPrint (eLogDebug, "NetDb: store request: LeaseSet");
-			updated = AddLeaseSet (ident, buf + offset, len - offset, m->from);
-		}	
-		else
-		{
-			LogPrint (eLogDebug, "NetDb: store request: RouterInfo");
-			size_t size = bufbe16toh (buf + offset);
-			offset += 2;
-			if (size > 2048 || size > len - offset)
-			{
-				LogPrint (eLogError, "NetDb: invalid RouterInfo length ", (int)size);
-				return;
-			}	
-			uint8_t uncompressed[2048];
-			size_t uncompressedSize = m_Inflator.Inflate (buf + offset, size, uncompressed, 2048);
-			if (uncompressedSize)
-				updated = AddRouterInfo (ident, uncompressed, uncompressedSize);
-		}	
-
-		if (replyToken && context.IsFloodfill () && updated)
-		{
-			// flood updated
-			auto floodMsg = NewI2NPShortMessage ();
-			uint8_t * payload = floodMsg->GetPayload ();		
-			memcpy (payload, buf, 33); // key + type
-			htobe32buf (payload + DATABASE_STORE_REPLY_TOKEN_OFFSET, 0); // zero reply token
-			auto msgLen = len - payloadOffset;
-			floodMsg->len += DATABASE_STORE_HEADER_SIZE + msgLen;
-			if (floodMsg->len < floodMsg->maxLen)
-			{	
-				memcpy (payload + DATABASE_STORE_HEADER_SIZE, buf + payloadOffset, msgLen);
-				floodMsg->FillI2NPMessageHeader (eI2NPDatabaseStore); 
-				std::set<IdentHash> excluded;
-				for (int i = 0; i < 3; i++)
-				{
-					auto floodfill = GetClosestFloodfill (ident, excluded);
-					if (floodfill)
-						transports.SendMessage (floodfill->GetIdentHash (), floodMsg);
-					else
-						break;
-				}	
-			}	
-			else
-				LogPrint (eLogError, "Database store message is too long ", floodMsg->len);
-		}	
-	}	
-
-	void NetDb::HandleDatabaseSearchReplyMsg (std::shared_ptr<const I2NPMessage> msg)
-	{
-		const uint8_t * buf = msg->GetPayload ();
-		char key[48];
-		int l = i2p::data::ByteStreamToBase64 (buf, 32, key, 48);
-		key[l] = 0;
-		int num = buf[32]; // num
-		LogPrint (eLogDebug, "NetDb: DatabaseSearchReply for ", key, " num=", num);
-		IdentHash ident (buf);
-		auto dest = m_Requests.FindRequest (ident); 
-		if (dest)
-		{	
-			bool deleteDest = true;
-			if (num > 0)
-			{	
-				auto pool = i2p::tunnel::tunnels.GetExploratoryPool ();
-				auto outbound = pool ? pool->GetNextOutboundTunnel () : nullptr;
-				auto inbound = pool ? pool->GetNextInboundTunnel () : nullptr;
-				if (!dest->IsExploratory ())
-				{
-					// reply to our destination. Try other floodfills
-					if (outbound && inbound )
-					{
-						std::vector<i2p::tunnel::TunnelMessageBlock> msgs;
-						auto count = dest->GetExcludedPeers ().size ();
-						if (count < 7)
-						{	
-							auto nextFloodfill = GetClosestFloodfill (dest->GetDestination (), dest->GetExcludedPeers ());
-							if (nextFloodfill)
-							{	
-								// tell floodfill about us 
-								msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-									{ 
-										i2p::tunnel::eDeliveryTypeRouter,
-										nextFloodfill->GetIdentHash (), 0,
-										CreateDatabaseStoreMsg () 
-									});  
-								
-								// request destination
-								LogPrint (eLogDebug, "NetDb: Try ", key, " at ", count, " floodfill ", nextFloodfill->GetIdentHash ().ToBase64 ());
-								auto msg = dest->CreateRequestMessage (nextFloodfill, inbound);
-								msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-									{ 
-										i2p::tunnel::eDeliveryTypeRouter,
-										nextFloodfill->GetIdentHash (), 0, msg
-									});
-								deleteDest = false;
-							}	
-						}
-						else
-							LogPrint (eLogWarning, "NetDb: ", key, " was not found on ", count, " floodfills");
-
-						if (msgs.size () > 0)
-							outbound->SendTunnelDataMsg (msgs);	
-					}	
-				}	
-
-				if (deleteDest)
-					// no more requests for the destinationation. delete it
-					m_Requests.RequestComplete (ident, nullptr);
-			}
-			else
-				// no more requests for detination possible. delete it
-				m_Requests.RequestComplete (ident, nullptr);
-		}
-		else	
-			LogPrint (eLogWarning, "NetDb: requested destination for ", key, " not found");
-
-		// try responses
-		for (int i = 0; i < num; i++)
-		{
-			const uint8_t * router = buf + 33 + i*32;
-			char peerHash[48];
-			int l1 = i2p::data::ByteStreamToBase64 (router, 32, peerHash, 48);
-			peerHash[l1] = 0;
-			LogPrint (eLogDebug, "NetDb: ", i, ": ", peerHash);
-
-			auto r = FindRouter (router); 
-			if (!r || i2p::util::GetMillisecondsSinceEpoch () > r->GetTimestamp () + 3600*1000LL) 
-			{	
-				// router with ident not found or too old (1 hour)
-				LogPrint (eLogDebug, "NetDb: found new/outdated router. Requesting RouterInfo ...");
-				RequestDestination (router);
-			}
-			else
-				LogPrint (eLogDebug, "NetDb: [:|||:]");
-		}	
-	}	
-	
-	void NetDb::HandleDatabaseLookupMsg (std::shared_ptr<const I2NPMessage> msg)
-	{
-		const uint8_t * buf = msg->GetPayload ();
-		IdentHash ident (buf);
-		if (ident.IsZero ())
-		{
-			LogPrint (eLogError, "NetDb: DatabaseLookup for zero ident. Ignored");
-			return;
-		}	
-		char key[48];
-		int l = i2p::data::ByteStreamToBase64 (buf, 32, key, 48);
-		key[l] = 0;
-		uint8_t flag = buf[64];
-		LogPrint (eLogDebug, "NetDb: DatabaseLookup for ", key, " recieved flags=", (int)flag);
-		uint8_t lookupType = flag & DATABASE_LOOKUP_TYPE_FLAGS_MASK;
-		const uint8_t * excluded = buf + 65;		
-		uint32_t replyTunnelID = 0;
-		if (flag & DATABASE_LOOKUP_DELIVERY_FLAG) //reply to tunnel
-		{
-			replyTunnelID = bufbe32toh (buf + 64);
-			excluded += 4;
-		}
-		uint16_t numExcluded = bufbe16toh (excluded);	
-		excluded += 2;
-		if (numExcluded > 512)
-		{
-			LogPrint (eLogWarning, "NetDb: number of excluded peers", numExcluded, " exceeds 512");
-			numExcluded = 0; // TODO:
-		} 
-		
-		std::shared_ptr<I2NPMessage> replyMsg;
-		if (lookupType == DATABASE_LOOKUP_TYPE_EXPLORATORY_LOOKUP)
-		{
-			LogPrint (eLogInfo, "NetDb: exploratory close to  ", key, " ", numExcluded, " excluded");
-			std::set<IdentHash> excludedRouters;
-			for (int i = 0; i < numExcluded; i++)
-			{
-				excludedRouters.insert (excluded);
-				excluded += 32;
-			}	
-			std::vector<IdentHash> routers;
-			for (int i = 0; i < 3; i++)
-			{
-				auto r = GetClosestNonFloodfill (ident, excludedRouters);
-				if (r)
-				{	
-					routers.push_back (r->GetIdentHash ());
-					excludedRouters.insert (r->GetIdentHash ());
-				}	
-			}	
-			replyMsg = CreateDatabaseSearchReply (ident, routers);
-		}	
-		else
-		{	
-			if (lookupType == DATABASE_LOOKUP_TYPE_ROUTERINFO_LOOKUP  ||
-			    lookupType == DATABASE_LOOKUP_TYPE_NORMAL_LOOKUP)
-			{	
-				auto router = FindRouter (ident);
-				if (router)
-				{
-					LogPrint (eLogDebug, "NetDb: requested RouterInfo ", key, " found");
-					router->LoadBuffer ();
-					if (router->GetBuffer ()) 
-						replyMsg = CreateDatabaseStoreMsg (router);
-				}
-			}
-			
-			if (!replyMsg && (lookupType == DATABASE_LOOKUP_TYPE_LEASESET_LOOKUP  ||
-			    lookupType == DATABASE_LOOKUP_TYPE_NORMAL_LOOKUP))
-			{
-				auto leaseSet = FindLeaseSet (ident);
-				if (leaseSet && !leaseSet->IsExpired ()) // we don't send back our LeaseSets
-				{
-					LogPrint (eLogDebug, "NetDb: requested LeaseSet ", key, " found");
-					replyMsg = CreateDatabaseStoreMsg (leaseSet);
-				}
-			}
-			
-			if (!replyMsg)
-			{
-				LogPrint (eLogWarning, "NetDb: Requested ", key, " not found. ", numExcluded, " excluded");
-				std::set<IdentHash> excludedRouters;	
-				for (int i = 0; i < numExcluded; i++)
-				{
-					excludedRouters.insert (excluded);
-					excluded += 32;
-				}
-				replyMsg = CreateDatabaseSearchReply (ident, GetClosestFloodfills (ident, 3, excludedRouters, true));
-			}
-		}
-		
-		if (replyMsg)
-		{	
-			if (replyTunnelID)
-			{
-				// encryption might be used though tunnel only
-				if (flag & DATABASE_LOOKUP_ENCYPTION_FLAG) // encrypted reply requested
-				{
-					const uint8_t * sessionKey = excluded;
-					uint8_t numTags = sessionKey[32];
-					if (numTags > 0) 
-					{
-						const uint8_t * sessionTag = sessionKey + 33; // take first tag
-						i2p::garlic::GarlicRoutingSession garlic (sessionKey, sessionTag);
-						replyMsg = garlic.WrapSingleMessage (replyMsg);
-					}
-				}	
-				auto exploratoryPool = i2p::tunnel::tunnels.GetExploratoryPool ();
-				auto outbound = exploratoryPool ? exploratoryPool->GetNextOutboundTunnel () : nullptr;
-				if (outbound)
-					outbound->SendTunnelDataMsg (buf+32, replyTunnelID, replyMsg);
-				else
-					transports.SendMessage (buf+32, i2p::CreateTunnelGatewayMsg (replyTunnelID, replyMsg));
-			}
-			else
-				transports.SendMessage (buf+32, replyMsg);
-		}
-	}	
-
-	void NetDb::Explore (int numDestinations)
-	{	
-		// new requests
-		auto exploratoryPool = i2p::tunnel::tunnels.GetExploratoryPool ();
-		auto outbound = exploratoryPool ? exploratoryPool->GetNextOutboundTunnel () : nullptr;
-		auto inbound = exploratoryPool ? exploratoryPool->GetNextInboundTunnel () : nullptr;
-		bool throughTunnels = outbound && inbound;
-		
-		uint8_t randomHash[32];
-		std::vector<i2p::tunnel::TunnelMessageBlock> msgs;
-		std::set<const RouterInfo *> floodfills;
-		LogPrint (eLogInfo, "NetDb: exploring new ", numDestinations, " routers ...");
-		for (int i = 0; i < numDestinations; i++)
-		{	
-			RAND_bytes (randomHash, 32);
-			auto dest = m_Requests.CreateRequest (randomHash, true); // exploratory
-			if (!dest)
-			{	
-				LogPrint (eLogWarning, "NetDb: exploratory destination is requested already");
-				return; 	
-			}	
-			auto floodfill = GetClosestFloodfill (randomHash, dest->GetExcludedPeers ());
-			if (floodfill && !floodfills.count (floodfill.get ())) // request floodfill only once
-			{	
-				floodfills.insert (floodfill.get ());
-				if (i2p::transport::transports.IsConnected (floodfill->GetIdentHash ()))
-					throughTunnels = false;
-				if (throughTunnels)
-				{	
-					msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-						{ 
-							i2p::tunnel::eDeliveryTypeRouter,
-							floodfill->GetIdentHash (), 0,
-							CreateDatabaseStoreMsg () // tell floodfill about us 
-						});  
-					msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-						{ 
-							i2p::tunnel::eDeliveryTypeRouter,
-							floodfill->GetIdentHash (), 0, 
-							dest->CreateRequestMessage (floodfill, inbound) // explore
-						}); 
-				}	
-				else
-					i2p::transport::transports.SendMessage (floodfill->GetIdentHash (), dest->CreateRequestMessage (floodfill->GetIdentHash ()));
-			}	
-			else
-				m_Requests.RequestComplete (randomHash, nullptr);
-		}	
-		if (throughTunnels && msgs.size () > 0)
-			outbound->SendTunnelDataMsg (msgs);		
-	}	
-
-	void NetDb::Publish ()
-	{
-		i2p::context.UpdateStats (); // for floodfill
-		std::set<IdentHash> excluded; // TODO: fill up later
-		for (int i = 0; i < 2; i++)
-		{	
-			auto floodfill = GetClosestFloodfill (i2p::context.GetRouterInfo ().GetIdentHash (), excluded);
-			if (floodfill)
-			{
-				uint32_t replyToken;
-				RAND_bytes ((uint8_t *)&replyToken, 4);
-				LogPrint (eLogInfo, "NetDb: Publishing our RouterInfo to ", i2p::data::GetIdentHashAbbreviation(floodfill->GetIdentHash ()), ". reply token=", replyToken);
-				transports.SendMessage (floodfill->GetIdentHash (), CreateDatabaseStoreMsg (i2p::context.GetSharedRouterInfo (), replyToken));	
-				excluded.insert (floodfill->GetIdentHash ());
-			}
-		}	
-	}		
-
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomRouter () const
-	{
-		return GetRandomRouter (
-			[](std::shared_ptr<const RouterInfo> router)->bool 
-			{ 
-				return !router->IsHidden (); 
-			});
-	}	
-	
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith) const
-	{
-		return GetRandomRouter (
-			[compatibleWith](std::shared_ptr<const RouterInfo> router)->bool 
-			{ 
-				return !router->IsHidden () && router != compatibleWith && 
-					router->IsCompatible (*compatibleWith); 
-			});
-	}	
-
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomPeerTestRouter () const
-	{
-		return GetRandomRouter (
-			[](std::shared_ptr<const RouterInfo> router)->bool 
-			{ 
-				return !router->IsHidden () && router->IsPeerTesting (); 
-			});
-	}
-
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomIntroducer () const
-	{
-		return GetRandomRouter (
-			[](std::shared_ptr<const RouterInfo> router)->bool 
-			{ 
-				return !router->IsHidden () && router->IsIntroducer (); 
-			});
-	}	
-	
-	std::shared_ptr<const RouterInfo> NetDb::GetHighBandwidthRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith) const
-	{
-		return GetRandomRouter (
-			[compatibleWith](std::shared_ptr<const RouterInfo> router)->bool 
-			{ 
-				return !router->IsHidden () && router != compatibleWith &&
-					router->IsCompatible (*compatibleWith) && 
-					(router->GetCaps () & RouterInfo::eHighBandwidth);
-			});
-	}	
-	
-	template<typename Filter>
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomRouter (Filter filter) const
-	{
-		if (!m_RouterInfos.size ()) return 0;
-		uint32_t ind = rand () % m_RouterInfos.size ();	
-		for (int j = 0; j < 2; j++)
-		{	
-			uint32_t i = 0;
-			std::unique_lock<std::mutex> l(m_RouterInfosMutex);
-			for (auto it: m_RouterInfos)
-			{	
-				if (i >= ind)
-				{	
-					if (!it.second->IsUnreachable () && filter (it.second))
-						return it.second;
-				}	
-				else 
-					i++;
-			}
-			// we couldn't find anything, try second pass
-			ind = 0;
-		}	
-		return nullptr; // seems we have too few routers
-	}	
-	
-	void NetDb::PostI2NPMsg (std::shared_ptr<const I2NPMessage> msg)
-	{
-		if (msg) m_Queue.Put (msg);	
-	}	
-
-	std::shared_ptr<const RouterInfo> NetDb::GetClosestFloodfill (const IdentHash& destination, 
-		const std::set<IdentHash>& excluded, bool closeThanUsOnly) const
-	{
-		std::shared_ptr<const RouterInfo> r;
-		XORMetric minMetric;
-		IdentHash destKey = CreateRoutingKey (destination);
-		if (closeThanUsOnly)
-			minMetric = destKey ^ i2p::context.GetIdentHash ();
-		else	
-			minMetric.SetMax ();
-		std::unique_lock<std::mutex> l(m_FloodfillsMutex);
-		for (auto it: m_Floodfills)
-		{	
-			if (!it->IsUnreachable ())
-			{	
-				XORMetric m = destKey ^ it->GetIdentHash ();
-				if (m < minMetric && !excluded.count (it->GetIdentHash ()))
-				{
-					minMetric = m;
-					r = it;
-				}
-			}	
-		}	
-		return r;
-	}	
-
-	std::vector<IdentHash> NetDb::GetClosestFloodfills (const IdentHash& destination, size_t num,
-		std::set<IdentHash>& excluded, bool closeThanUsOnly) const
-	{
-		struct Sorted
-		{
-			std::shared_ptr<const RouterInfo> r;
-			XORMetric metric;
-			bool operator< (const Sorted& other) const { return metric < other.metric; };
-		};
-
-		std::set<Sorted> sorted;
-		IdentHash destKey = CreateRoutingKey (destination);
-		XORMetric ourMetric;
-		if (closeThanUsOnly) ourMetric = destKey ^ i2p::context.GetIdentHash ();
-		{
-			std::unique_lock<std::mutex> l(m_FloodfillsMutex);
-			for (auto it: m_Floodfills)
-			{
-				if (!it->IsUnreachable ())
-				{	
-					XORMetric m = destKey ^ it->GetIdentHash ();
-					if (closeThanUsOnly && ourMetric < m) continue;
-					if (sorted.size () < num)
-						sorted.insert ({it, m});
-					else if (m < sorted.rbegin ()->metric)
-					{
-						sorted.insert ({it, m});
-						sorted.erase (std::prev (sorted.end ()));
-					}
-				}
-			}
-		}
-
-		std::vector<IdentHash> res;	
-		size_t i = 0;			
-		for (auto it: sorted)
-		{
-			if (i < num)
-			{
-				auto& ident = it.r->GetIdentHash ();
-				if (!excluded.count (ident))
-				{	
-					res.push_back (ident);
-					i++;
-				}
-			}
-			else
-				break;
-		}	
-		return res;
-	}
-
-	std::shared_ptr<const RouterInfo> NetDb::GetClosestNonFloodfill (const IdentHash& destination, 
-		const std::set<IdentHash>& excluded) const
-	{
-		std::shared_ptr<const RouterInfo> r;
-		XORMetric minMetric;
-		IdentHash destKey = CreateRoutingKey (destination);
-		minMetric.SetMax ();
-		// must be called from NetDb thread only
-		for (auto it: m_RouterInfos)
-		{	
-			if (!it.second->IsFloodfill ())
-			{	
-				XORMetric m = destKey ^ it.first;
-				if (m < minMetric && !excluded.count (it.first))
-				{
-					minMetric = m;
-					r = it.second;
-				}
-			}	
-		}	
-		return r;
-	}	
-	
-	void NetDb::ManageLeaseSets ()
-	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		for (auto it = m_LeaseSets.begin (); it != m_LeaseSets.end ();)
-		{
-			if (ts > it->second->GetExpirationTime () - LEASE_ENDDATE_THRESHOLD) 
-			{
-				LogPrint (eLogInfo, "NetDb: LeaseSet ", it->second->GetIdentHash ().ToBase64 (), " expired");
-				it = m_LeaseSets.erase (it);
-			}	
-			else 
-				it++;
-		}
-	}
-}
-}

NetDb.h

@@ -1,117 +0,0 @@
-#ifndef NETDB_H__
-#define NETDB_H__
-
-#include <inttypes.h>
-#include <set>
-#include <map>
-#include <list>
-#include <string>
-#include <thread>
-#include <mutex>
-#include "Base.h"
-#include "FS.h"
-#include "Queue.h"
-#include "I2NPProtocol.h"
-#include "RouterInfo.h"
-#include "LeaseSet.h"
-#include "Tunnel.h"
-#include "TunnelPool.h"
-#include "Reseed.h"
-#include "NetDbRequests.h"
-#include "Family.h"
-
-namespace i2p
-{
-namespace data
-{		
-	const int NETDB_MIN_ROUTERS = 90;
-	const int NETDB_FLOODFILL_EXPIRATION_TIMEOUT = 60*60; // 1 hour, in seconds
-	const int NETDB_INTRODUCEE_EXPIRATION_TIMEOUT = 65*60;
-	const int NETDB_MIN_EXPIRATION_TIMEOUT = 90*60; // 1.5 hours
-	const int NETDB_MAX_EXPIRATION_TIMEOUT = 27*60*60; // 27 hours
-	
-	class NetDb
-	{
-		public:
-
-			NetDb ();
-			~NetDb ();
-
-			void Start ();
-			void Stop ();
-			
-			bool AddRouterInfo (const uint8_t * buf, int len);
-			bool AddRouterInfo (const IdentHash& ident, const uint8_t * buf, int len);
-			bool AddLeaseSet (const IdentHash& ident, const uint8_t * buf, int len, std::shared_ptr<i2p::tunnel::InboundTunnel> from);
-			std::shared_ptr<RouterInfo> FindRouter (const IdentHash& ident) const;
-			std::shared_ptr<LeaseSet> FindLeaseSet (const IdentHash& destination) const;
-			std::shared_ptr<RouterProfile> FindRouterProfile (const IdentHash& ident) const;
-
-			void RequestDestination (const IdentHash& destination, RequestedDestination::RequestComplete requestComplete = nullptr);			
-			
-			void HandleDatabaseStoreMsg (std::shared_ptr<const I2NPMessage> msg);
-			void HandleDatabaseSearchReplyMsg (std::shared_ptr<const I2NPMessage> msg);
-			void HandleDatabaseLookupMsg (std::shared_ptr<const I2NPMessage> msg);			
-
-			std::shared_ptr<const RouterInfo> GetRandomRouter () const;
-			std::shared_ptr<const RouterInfo> GetRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith) const;
-			std::shared_ptr<const RouterInfo> GetHighBandwidthRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith) const;
-			std::shared_ptr<const RouterInfo> GetRandomPeerTestRouter () const;
-			std::shared_ptr<const RouterInfo> GetRandomIntroducer () const;
-			std::shared_ptr<const RouterInfo> GetClosestFloodfill (const IdentHash& destination, const std::set<IdentHash>& excluded, bool closeThanUsOnly = false) const;
-			std::vector<IdentHash> GetClosestFloodfills (const IdentHash& destination, size_t num,
-				std::set<IdentHash>& excluded, bool closeThanUsOnly = false) const;
-			std::shared_ptr<const RouterInfo> GetClosestNonFloodfill (const IdentHash& destination, const std::set<IdentHash>& excluded) const;
-			void SetUnreachable (const IdentHash& ident, bool unreachable);			
-
-			void PostI2NPMsg (std::shared_ptr<const I2NPMessage> msg);
-
-			void Reseed ();
-			Families& GetFamilies () { return m_Families; };
-
-			// for web interface
-			int GetNumRouters () const { return m_RouterInfos.size (); };
-			int GetNumFloodfills () const { return m_Floodfills.size (); };
-			int GetNumLeaseSets () const { return m_LeaseSets.size (); };
-			
-		private:
-
-			void Load ();
-			bool LoadRouterInfo (const std::string & path);
-			void SaveUpdated ();
-			void Run (); // exploratory thread
-			void Explore (int numDestinations);	
-			void Publish ();
-			void ManageLeaseSets ();
-			void ManageRequests ();
-
-			template<typename Filter>
-			std::shared_ptr<const RouterInfo> GetRandomRouter (Filter filter) const;	
-		
-		private:
-
-			std::map<IdentHash, std::shared_ptr<LeaseSet> > m_LeaseSets;
-			mutable std::mutex m_RouterInfosMutex;
-			std::map<IdentHash, std::shared_ptr<RouterInfo> > m_RouterInfos;
-			mutable std::mutex m_FloodfillsMutex;
-			std::list<std::shared_ptr<RouterInfo> > m_Floodfills;
-			
-			bool m_IsRunning;
-			uint64_t m_LastLoad;
-			std::thread * m_Thread;	
-			i2p::util::Queue<std::shared_ptr<const I2NPMessage> > m_Queue; // of I2NPDatabaseStoreMsg
-
-			GzipInflator m_Inflator;
-			Reseeder * m_Reseeder;
-			Families m_Families;
-			i2p::fs::HashedStorage m_Storage;
-
-			friend class NetDbRequests; 
-			NetDbRequests m_Requests;
-	};
-
-	extern NetDb netdb;
-}
-}
-
-#endif

README.md

@@ -1,41 +1,102 @@
+[![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)
+
+*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
 ====
 
-Independent C++ implementation of I2P router
+[Русская версия](https://github.com/PurpleI2P/i2pd_docs_ru/blob/master/README.md)
+
+i2pd (I2P Daemon) is a full-featured C++ implementation of I2P client.  
+
+I2P (Invisible Internet Protocol) is a universal anonymous network layer.  
+All communications over I2P are anonymous and end-to-end encrypted, participants
+don't reveal their real IP addresses.  
+
+I2P client is a software used for building and using anonymous I2P
+networks. Such networks are commonly used for anonymous peer-to-peer
+applications (filesharing, cryptocurrencies) and anonymous client-server
+applications (websites, instant messengers, chat-servers).  
+
+I2P allows people from all around the world to communicate and share information
+without restrictions.  
+
+Features
+--------
+
+* Distributed anonymous networking framework  
+* End-to-end encrypted communications  
+* Small footprint, simple dependencies, fast performance  
+* Rich set of APIs for developers of secure applications  
+
+Resources
+---------
+
+* [Website](http://i2pd.website)
+* [Documentation](https://i2pd.readthedocs.io/en/latest/)
+* [Wiki](https://github.com/PurpleI2P/i2pd/wiki)
+* [Tickets/Issues](https://github.com/PurpleI2P/i2pd/issues)
+* [Specifications](https://geti2p.net/spec)
+* [Twitter](https://twitter.com/hashtag/i2pd)
+
+Installing
+----------
+
+The easiest way to install i2pd is by using precompiled packages and binaries.
+You can fetch most of them on [release](https://github.com/PurpleI2P/i2pd/releases/latest) page.  
+Please see [documentation](https://i2pd.readthedocs.io/en/latest/user-guide/install/) for more info.
+
+Building
+--------
+See [documentation](https://i2pd.readthedocs.io/en/latest/) for how to build
+i2pd from source on your OS.  
+
+note: i2pd with Qt GUI can be found in [i2pd-qt](https://github.com/PurpleI2P/i2pd-qt) repository and for android in [i2pd-android](https://github.com/PurpleI2P/i2pd-android) repository.
+
+
+Build instructions:
+
+* [unix](https://i2pd.readthedocs.io/en/latest/devs/building/unix/)
+* [windows](https://i2pd.readthedocs.io/en/latest/devs/building/windows/)
+* [iOS](https://i2pd.readthedocs.io/en/latest/devs/building/ios/)
+* [android](https://i2pd.readthedocs.io/en/latest/devs/building/android/)
+
+
+**Supported systems:**
+
+* GNU/Linux - [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
+  * CentOS / Fedora / Mageia - [![Build Status](https://copr.fedorainfracloud.org/coprs/supervillain/i2pd/package/i2pd-git/status_image/last_build.png)](https://copr.fedorainfracloud.org/coprs/supervillain/i2pd/package/i2pd-git/)
+  * Alpine, ArchLinux, openSUSE, Gentoo, Debian, Ubuntu, etc.
+* Windows - [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)
+* Mac OS X - [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)
+* Docker image - [![Build Status](https://img.shields.io/docker/cloud/build/purplei2p/i2pd)](https://hub.docker.com/r/purplei2p/i2pd/builds/)
+* Snap
+* FreeBSD
+* Android
+* iOS
+
+Using i2pd
+----------
+
+See [documentation](https://i2pd.readthedocs.io/en/latest/user-guide/run/) and
+[example config file](https://github.com/PurpleI2P/i2pd/blob/openssl/contrib/i2pd.conf).
+
+Donations
+---------
+
+BTC: 3MDoGJW9TLMTCDGrR9bLgWXfm6sjmgy86f  
+LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59  
+ETH: 0x9e5bac70d20d1079ceaa111127f4fb3bccce379d  
+DASH: Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF  
+ZEC: t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ  
+GST: GbD2JSQHBHCKLa9WTHmigJRpyFgmBj4woG  
 
 License
 -------
 
 This project is licensed under the BSD 3-clause license, which can be found in the file
-LICENSE in the root of the project source code.
-
-Donations
----------
-
-BTC: 1K7Ds6KUeR8ya287UC4rYTjvC96vXyZbDY  
-LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59  
-ANC: AQJYweYYUqM1nVfLqfoSMpUMfzxvS4Xd7z  
-
-Downloads
-------------
-
-Official binary releases could be found at:  
-http://i2pd.website/releases/  
-older releases  
-http://download.i2p.io/purplei2p/i2pd/releases/  
-
-Supported OS
-------------
-
-* Linux x86/x64  - [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)  
-* Windows        - [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)  
-* Mac OS X
-* FreeBSD
-
-More documentation
-------------------
-
-* [Building from source / unix](docs/build_notes_unix.md)  
-* [Building from source / windows](docs/build_notes_windows.md)  
-* [Configuring your i2pd](docs/configuration.md)  
-* [Github wiki](https://github.com/PurpleI2P/i2pd/wiki/)  
+LICENSE in the root of the project source code.  

Reseed.cpp

@@ -1,421 +0,0 @@
-#include <string.h>
-#include <fstream>
-#include <sstream>
-#include <boost/regex.hpp>
-#include <boost/asio.hpp>
-#include <boost/asio/ssl.hpp>
-#include <openssl/bn.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#include <zlib.h>
-
-#include "I2PEndian.h"
-#include "Reseed.h"
-#include "FS.h"
-#include "Log.h"
-#include "Identity.h"
-#include "Crypto.h"
-#include "NetDb.h"
-#include "util.h"
-
-
-namespace i2p
-{
-namespace data
-{
-	static std::vector<std::string> httpsReseedHostList = 
-	{
-		"https://reseed.i2p-projekt.de/", // Only HTTPS
-        //"https://i2pseed.zarrenspry.info/", // Only HTTPS and SU3 (v3) support
-        "https://i2p.mooo.com/netDb/",
-        "https://netdb.i2p2.no/", // Only SU3 (v3) support, SNI required
-		"https://us.reseed.i2p2.no:444/",	
-        "https://uk.reseed.i2p2.no:444/",
-		"https://www.torontocrypto.org:8443/",
-		"https://i2p-0.manas.ca:8443/"
-        "https://reseed.i2p.vzaws.com:8443/", // Only SU3 (v3) support
-        "https://user.mx24.eu/", // Only HTTPS and SU3 (v3) support
-        "https://download.xxlspeed.com/" // Only HTTPS and SU3 (v3) support
-	};
-	
-	Reseeder::Reseeder()
-	{
-	}
-
-	Reseeder::~Reseeder()
-	{
-	}
-
-	int Reseeder::ReseedNowSU3 ()
-	{
-		auto ind = rand () % httpsReseedHostList.size ();
-		std::string& reseedHost = httpsReseedHostList[ind];
-		return ReseedFromSU3 (reseedHost);
-	}
-
-	int Reseeder::ReseedFromSU3 (const std::string& host)
-	{
-		std::string url = host + "i2pseeds.su3";
-		LogPrint (eLogInfo, "Reseed: Downloading SU3 from ", host);
-		std::string su3 = HttpsRequest (url);
-		if (su3.length () > 0)
-		{
-			std::stringstream s(su3);
-			return ProcessSU3Stream (s);
-		}
-		else
-		{
-			LogPrint (eLogWarning, "Reseed: SU3 download failed");
-			return 0;
-		}
-	}
-	
-	int Reseeder::ProcessSU3File (const char * filename)
-	{
-		std::ifstream s(filename, std::ifstream::binary);
-		if (s.is_open ())	
-			return ProcessSU3Stream (s);
-		else
-		{
-			LogPrint (eLogError, "Reseed: Can't open file ", filename);
-			return 0;
-		}
-	}
-
-	const char SU3_MAGIC_NUMBER[]="I2Psu3";	
-	const uint32_t ZIP_HEADER_SIGNATURE = 0x04034B50;
-	const uint32_t ZIP_CENTRAL_DIRECTORY_HEADER_SIGNATURE = 0x02014B50;	
-	const uint16_t ZIP_BIT_FLAG_DATA_DESCRIPTOR = 0x0008;	
-	int Reseeder::ProcessSU3Stream (std::istream& s)
-	{
-		char magicNumber[7];
-		s.read (magicNumber, 7); // magic number and zero byte 6
-		if (strcmp (magicNumber, SU3_MAGIC_NUMBER))
-		{
-			LogPrint (eLogError, "Reseed: Unexpected SU3 magic number");
-			return 0;
-		}			
-		s.seekg (1, std::ios::cur); // su3 file format version
-		SigningKeyType signatureType;
-		s.read ((char *)&signatureType, 2);  // signature type
-		signatureType = be16toh (signatureType);
-		uint16_t signatureLength;
-		s.read ((char *)&signatureLength, 2);  // signature length
-		signatureLength = be16toh (signatureLength);
-		s.seekg (1, std::ios::cur); // unused
-		uint8_t versionLength;
-		s.read ((char *)&versionLength, 1);  // version length	
-		s.seekg (1, std::ios::cur); // unused
-		uint8_t signerIDLength;
-		s.read ((char *)&signerIDLength, 1);  // signer ID length	
-		uint64_t contentLength;
-		s.read ((char *)&contentLength, 8);  // content length	
-		contentLength = be64toh (contentLength);
-		s.seekg (1, std::ios::cur); // unused
-		uint8_t fileType;
-		s.read ((char *)&fileType, 1);  // file type	
-		if (fileType != 0x00) //  zip file
-		{
-			LogPrint (eLogError, "Reseed: Can't handle file type ", (int)fileType);
-			return 0;
-		}
-		s.seekg (1, std::ios::cur); // unused
-		uint8_t contentType;
-		s.read ((char *)&contentType, 1);  // content type	
-		if (contentType != 0x03) // reseed data
-		{
-			LogPrint (eLogError, "Reseed: Unexpected content type ", (int)contentType);
-			return 0;
-		}
-		s.seekg (12, std::ios::cur); // unused
-
-		s.seekg (versionLength, std::ios::cur); // skip version
-		char signerID[256];
-		s.read (signerID, signerIDLength); // signerID
-		signerID[signerIDLength] = 0;
-		
-		//try to verify signature
-		auto it = m_SigningKeys.find (signerID);
-		if (it != m_SigningKeys.end ())
-		{
-			// TODO: implement all signature types
-			if (signatureType == SIGNING_KEY_TYPE_RSA_SHA512_4096)
-			{
-				size_t pos = s.tellg ();
-				size_t tbsLen = pos + contentLength;
-				uint8_t * tbs = new uint8_t[tbsLen];
-				s.seekg (0, std::ios::beg);
-				s.read ((char *)tbs, tbsLen);
-				uint8_t * signature = new uint8_t[signatureLength];
-				s.read ((char *)signature, signatureLength);
-				// RSA-raw
-				{
-					// calculate digest
-					uint8_t digest[64];
-					SHA512 (tbs, tbsLen, digest);
-					// encrypt signature
-					BN_CTX * bnctx = BN_CTX_new ();
-					BIGNUM * s = BN_new (), * n = BN_new ();
-					BN_bin2bn (signature, signatureLength, s);
-					BN_bin2bn (it->second, i2p::crypto::RSASHA5124096_KEY_LENGTH, n);
-					BN_mod_exp (s, s, i2p::crypto::GetRSAE (), n, bnctx); // s = s^e mod n 
-					uint8_t * enSigBuf = new uint8_t[signatureLength];
-					i2p::crypto::bn2buf (s, enSigBuf, signatureLength);
-					// digest is right aligned
-					// we can't use RSA_verify due wrong padding in SU3
-					if (memcmp (enSigBuf + (signatureLength - 64), digest, 64))
-						LogPrint (eLogWarning, "Reseed: SU3 signature verification failed");
-					delete[] enSigBuf;
-					BN_free (s); BN_free (n);
-					BN_CTX_free (bnctx);
-				}	
-					
-				delete[] signature;
-				delete[] tbs;
-				s.seekg (pos, std::ios::beg);
-			}
-			else
-				LogPrint (eLogWarning, "Reseed: Signature type ", signatureType, " is not supported");
-		}
-		else
-			LogPrint (eLogWarning, "Reseed: Certificate for ", signerID, " not loaded");
-		
-		// handle content
-		int numFiles = 0;
-		size_t contentPos = s.tellg ();
-		while (!s.eof ())
-		{	
-			uint32_t signature;
-			s.read ((char *)&signature, 4);
-			signature = le32toh (signature);
-			if (signature == ZIP_HEADER_SIGNATURE)
-			{
-				// next local file
-				s.seekg (2, std::ios::cur); // version
-				uint16_t bitFlag;
-				s.read ((char *)&bitFlag, 2);	
-				bitFlag = le16toh (bitFlag);
-				uint16_t compressionMethod;
-				s.read ((char *)&compressionMethod, 2);	
-				compressionMethod = le16toh (compressionMethod);
-				s.seekg (4, std::ios::cur); // skip fields we don't care about
-				uint32_t compressedSize, uncompressedSize; 
-				uint32_t crc_32;
-				s.read ((char *)&crc_32, 4);
-				crc_32 = le32toh (crc_32);
-				s.read ((char *)&compressedSize, 4);	
-				compressedSize = le32toh (compressedSize);	
-				s.read ((char *)&uncompressedSize, 4);
-				uncompressedSize = le32toh (uncompressedSize);	
-				uint16_t fileNameLength, extraFieldLength; 
-				s.read ((char *)&fileNameLength, 2);	
-				fileNameLength = le16toh (fileNameLength);
-				if ( fileNameLength > 255 ) {
-					// too big
-					LogPrint(eLogError, "Reseed: SU3 fileNameLength too large: ", fileNameLength);
-					return numFiles;
-				}
-				s.read ((char *)&extraFieldLength, 2);
-				extraFieldLength = le16toh (extraFieldLength);
-				char localFileName[255];
-				s.read (localFileName, fileNameLength);
-				localFileName[fileNameLength] = 0;
-				s.seekg (extraFieldLength, std::ios::cur);
-				// take care about data desriptor if presented
-				if (bitFlag & ZIP_BIT_FLAG_DATA_DESCRIPTOR)
-				{
-					size_t pos = s.tellg ();
-					if (!FindZipDataDescriptor (s))
-					{
-						LogPrint (eLogError, "Reseed: SU3 archive data descriptor not found");
-						return numFiles;
-					}									
-					s.read ((char *)&crc_32, 4);	
-					crc_32 = le32toh (crc_32);
-					s.read ((char *)&compressedSize, 4);	
-					compressedSize = le32toh (compressedSize) + 4; // ??? we must consider signature as part of compressed data
-					s.read ((char *)&uncompressedSize, 4);
-					uncompressedSize = le32toh (uncompressedSize);	
-
-					// now we know compressed and uncompressed size
-					s.seekg (pos, std::ios::beg); // back to compressed data
-				}
-
-				LogPrint (eLogDebug, "Reseed: Proccessing file ", localFileName, " ", compressedSize, " bytes");
-				if (!compressedSize)
-				{
-					LogPrint (eLogWarning, "Reseed: Unexpected size 0. Skipped");
-					continue;
-				}	
-				
-				uint8_t * compressed = new uint8_t[compressedSize];
-				s.read ((char *)compressed, compressedSize);
-				if (compressionMethod) // we assume Deflate
-				{
-					z_stream inflator;
-					memset (&inflator, 0, sizeof (inflator));
-					inflateInit2 (&inflator, -MAX_WBITS); // no zlib header
-					uint8_t * uncompressed = new uint8_t[uncompressedSize];
-					inflator.next_in = compressed;
-					inflator.avail_in = compressedSize;
-					inflator.next_out = uncompressed;
-					inflator.avail_out = uncompressedSize; 
-					int err;
-					if ((err = inflate (&inflator, Z_SYNC_FLUSH)) >= 0)
-					{	
-						uncompressedSize -= inflator.avail_out;
-						if (crc32 (0, uncompressed, uncompressedSize) == crc_32)
-						{
-							i2p::data::netdb.AddRouterInfo (uncompressed, uncompressedSize);
-							numFiles++;
-						}	
-						else
-							LogPrint (eLogError, "Reseed: CRC32 verification failed");
-					}	
-					else
-						LogPrint (eLogError, "Reseed: SU3 decompression error ", err);
-					delete[] uncompressed;      
-					inflateEnd (&inflator);
-				}
-				else // no compression
-				{
-					i2p::data::netdb.AddRouterInfo (compressed, compressedSize);
-					numFiles++;
-				}	
-				delete[] compressed;
-				if (bitFlag & ZIP_BIT_FLAG_DATA_DESCRIPTOR)
-					s.seekg (12, std::ios::cur); // skip data descriptor section if presented (12 = 16 - 4)
-			}
-			else
-			{
-				if (signature != ZIP_CENTRAL_DIRECTORY_HEADER_SIGNATURE)
-					LogPrint (eLogWarning, "Reseed: Missing zip central directory header");
-				break; // no more files
-			}
-			size_t end = s.tellg ();
-			if (end - contentPos >= contentLength)
-				break; // we are beyond contentLength
-		}
-		return numFiles;
-	}
-
-	const uint8_t ZIP_DATA_DESCRIPTOR_SIGNATURE[] = { 0x50, 0x4B, 0x07, 0x08 };	
-	bool Reseeder::FindZipDataDescriptor (std::istream& s)
-	{
-		size_t nextInd = 0;	
-		while (!s.eof ())
-		{
-			uint8_t nextByte;
-			s.read ((char *)&nextByte, 1);
-			if (nextByte == ZIP_DATA_DESCRIPTOR_SIGNATURE[nextInd])	
-			{
-				nextInd++;
-				if (nextInd >= sizeof (ZIP_DATA_DESCRIPTOR_SIGNATURE))
-					return true;
-			}
-			else
-				nextInd = 0;
-		}
-		return false;
-	}
-
-	void Reseeder::LoadCertificate (const std::string& filename)
-	{
-		SSL_CTX * ctx = SSL_CTX_new (TLSv1_method ());
-		int ret = SSL_CTX_use_certificate_file (ctx, filename.c_str (), SSL_FILETYPE_PEM); 
-		if (ret)
-		{	
-			SSL * ssl = SSL_new (ctx);
-			X509 * cert = SSL_get_certificate (ssl);
-			// verify
-			if (cert)
-			{	
-				// extract issuer name
-				char name[100];
-				X509_NAME_oneline (X509_get_issuer_name(cert), name, 100);
-				// extract RSA key (we need n only, e = 65537)
-				RSA * key = X509_get_pubkey (cert)->pkey.rsa;
-				PublicKey value;
-				i2p::crypto::bn2buf (key->n, value, 512);
-				m_SigningKeys[name] = value;
-			}	
-			SSL_free (ssl);			
-		}	
-		else
-			LogPrint (eLogError, "Reseed: Can't open certificate file ", filename);
-		SSL_CTX_free (ctx);		
-	}
-
-	void Reseeder::LoadCertificates ()
-	{
-		std::string certDir = i2p::fs::DataDirPath("certificates", "reseed");
-		std::vector<std::string> files;
-		int numCertificates = 0;
-
-		if (!i2p::fs::ReadDir(certDir, files)) {
-			LogPrint(eLogWarning, "Reseed: Can't load reseed certificates from ", certDir);
-			return;
-		}
-
-		for (const std::string & file : files) {
-			if (file.compare(file.size() - 4, 4, ".crt") != 0) {
-				LogPrint(eLogWarning, "Reseed: ignoring file ", file);
-				continue;
-			}
-			LoadCertificate (file);
-			numCertificates++;
-		}	
-		LogPrint (eLogInfo, "Reseed: ", numCertificates, " certificates loaded");
-	}	
-
-	std::string Reseeder::HttpsRequest (const std::string& address)
-	{
-		i2p::util::http::url u(address);
-		if (u.port_ == 80) u.port_ = 443; 
-
-		boost::asio::io_service service;
-		boost::system::error_code ecode;
-    	auto it = boost::asio::ip::tcp::resolver(service).resolve (
-			 boost::asio::ip::tcp::resolver::query (u.host_, std::to_string (u.port_)), ecode);
-		if (!ecode)
-		{
-			boost::asio::ssl::context ctx(service, boost::asio::ssl::context::sslv23);
-			ctx.set_verify_mode(boost::asio::ssl::context::verify_none);
-			boost::asio::ssl::stream<boost::asio::ip::tcp::socket> s(service, ctx);
-			s.lowest_layer().connect (*it, ecode);
-			if (!ecode)
-			{
-				s.handshake (boost::asio::ssl::stream_base::client, ecode);
-				if (!ecode)
-				{
-					LogPrint (eLogInfo, "Reseed: Connected to ", u.host_, ":", u.port_);
-					// send request		
-					std::stringstream ss;
-					ss << "GET " << u.path_ << " HTTP/1.1\r\nHost: " << u.host_
-					<< "\r\nAccept: */*\r\n" << "User-Agent: Wget/1.11.4\r\n" << "Connection: close\r\n\r\n";	
-					s.write_some (boost::asio::buffer (ss.str ()));
-					// read response
-					std::stringstream rs;
-					char response[1024]; size_t l = 0;
-					do
-					{
-						l = s.read_some (boost::asio::buffer (response, 1024), ecode);
-						if (l) rs.write (response, l);
-					}
-					while (!ecode && l);
-					// process response
-					return i2p::util::http::GetHttpContent (rs);
-				}
-				else
-					LogPrint (eLogError, "Reseed: SSL handshake failed: ", ecode.message ());
-			}
-			else
-				LogPrint (eLogError, "Reseed: Couldn't connect to ", u.host_, ": ", ecode.message ());
-		}
-		else
-			LogPrint (eLogError, "Reseed: Couldn't resolve address ", u.host_, ": ", ecode.message ());
-		return "";
-	}	
-}
-}
-

Reseed.h

@@ -1,47 +0,0 @@
-#ifndef RESEED_H
-#define RESEED_H
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <map>
-#include "Identity.h"
-#include "Crypto.h"
-
-namespace i2p
-{
-namespace data
-{
-
-	class Reseeder
-	{
-		typedef Tag<512> PublicKey;	
-		
-		public:
-		
-			Reseeder();
-			~Reseeder();
-			int ReseedNowSU3 ();
-
-			void LoadCertificates ();
-			
-		private:
-
-			void LoadCertificate (const std::string& filename);
-						
-			int ReseedFromSU3 (const std::string& host);
-			int ProcessSU3File (const char * filename);	
-			int ProcessSU3Stream (std::istream& s);	
-
-			bool FindZipDataDescriptor (std::istream& s);
-			
-			std::string HttpsRequest (const std::string& address);
-
-		private:	
-
-			std::map<std::string, PublicKey> m_SigningKeys;
-	};
-}
-}
-
-#endif

RouterContext.cpp

@@ -1,387 +0,0 @@
-#include <fstream>
-#include <boost/lexical_cast.hpp>
-#include "Config.h"
-#include "Crypto.h"
-#include "Timestamp.h"
-#include "I2NPProtocol.h"
-#include "NetDb.h"
-#include "FS.h"
-#include "util.h"
-#include "version.h"
-#include "Log.h"
-#include "Family.h"
-#include "RouterContext.h"
-
-namespace i2p
-{
-	RouterContext context;
-
-	RouterContext::RouterContext ():
-		m_LastUpdateTime (0), m_AcceptsTunnels (true), m_IsFloodfill (false), 
-		m_StartupTime (0), m_Status (eRouterStatusOK )
-	{
-	}
-
-	void RouterContext::Init ()
-	{
-		srand (i2p::util::GetMillisecondsSinceEpoch () % 1000);
-		m_StartupTime = i2p::util::GetSecondsSinceEpoch ();
-		if (!Load ())
-			CreateNewRouter ();
-		UpdateRouterInfo ();
-	}
-
-	void RouterContext::CreateNewRouter ()
-	{
-#if defined(__x86_64__) || defined(__i386__) || defined(_MSC_VER)			
-		m_Keys = i2p::data::PrivateKeys::CreateRandomKeys (i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519);
-#else
-		m_Keys = i2p::data::PrivateKeys::CreateRandomKeys (i2p::data::SIGNING_KEY_TYPE_DSA_SHA1);
-#endif		
-		SaveKeys ();
-		NewRouterInfo ();
-	}
-
-	void RouterContext::NewRouterInfo ()
-	{
-		i2p::data::RouterInfo routerInfo;
-		routerInfo.SetRouterIdentity (GetIdentity ());
-		uint16_t port; i2p::config::GetOption("port", port);
-		if (!port)
-			port = rand () % (30777 - 9111) + 9111; // I2P network ports range
-		std::string host; i2p::config::GetOption("host", host);
-		if (i2p::config::IsDefault("host"))
-			host = "127.0.0.1"; // replace default address with safe value
-		routerInfo.AddSSUAddress  (host.c_str(), port, routerInfo.GetIdentHash ());
-		routerInfo.AddNTCPAddress (host.c_str(), port);
-		routerInfo.SetCaps (i2p::data::RouterInfo::eReachable | 
-			i2p::data::RouterInfo::eSSUTesting | i2p::data::RouterInfo::eSSUIntroducer); // LR, BC
-		routerInfo.SetProperty ("netId", std::to_string (I2PD_NET_ID));
-		routerInfo.SetProperty ("router.version", I2P_VERSION);
-		routerInfo.CreateBuffer (m_Keys);
-		m_RouterInfo.SetRouterIdentity (GetIdentity ());
-		m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
-	}
-
-	void RouterContext::UpdateRouterInfo ()
-	{
-		m_RouterInfo.CreateBuffer (m_Keys);
-		m_RouterInfo.SaveToFile (i2p::fs::DataDirPath (ROUTER_INFO));
-		m_LastUpdateTime = i2p::util::GetSecondsSinceEpoch ();
-	}	
-
-	void RouterContext::SetStatus (RouterStatus status) 
-	{ 
-		if (status != m_Status)
-		{	
-			m_Status = status;
-			switch (m_Status)
-			{	
-				case eRouterStatusOK:
-					SetReachable ();
-				break;
-				case eRouterStatusFirewalled:
-					SetUnreachable ();
-				break;	
-				default:
-					;
-			}
-		}	
-	}
-		
-	void RouterContext::UpdatePort (int port)
-	{
-		bool updated = false;
-		for (auto& address : m_RouterInfo.GetAddresses ())
-		{
-			if (address.port != port)
-			{	
-				address.port = port;
-				updated = true;
-			}	
-		}	
-		if (updated)
-			UpdateRouterInfo ();
-	}
-
-	void RouterContext::UpdateAddress (const boost::asio::ip::address& host)
-	{
-		bool updated = false;
-		for (auto& address : m_RouterInfo.GetAddresses ())
-		{
-			if (address.host != host && address.IsCompatible (host))
-			{	
-				address.host = host;
-				updated = true;
-			}	
-		}	
-		auto ts = i2p::util::GetSecondsSinceEpoch ();
-		if (updated || ts > m_LastUpdateTime + ROUTER_INFO_UPDATE_INTERVAL)
-			UpdateRouterInfo ();
-	}
-
-	bool RouterContext::AddIntroducer (const i2p::data::RouterInfo::Introducer& introducer)
-	{
-		bool ret = m_RouterInfo.AddIntroducer (introducer);
-		if (ret)
-			UpdateRouterInfo ();	
-		return ret;
-	}	
-
-	void RouterContext::RemoveIntroducer (const boost::asio::ip::udp::endpoint& e)
-	{
-		if (m_RouterInfo.RemoveIntroducer (e))
-			UpdateRouterInfo ();
-	}	
-	
-	void RouterContext::SetFloodfill (bool floodfill)
-	{
-		m_IsFloodfill = floodfill;
-		if (floodfill)
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () | i2p::data::RouterInfo::eFloodfill);
-		else
-		{
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () & ~i2p::data::RouterInfo::eFloodfill);
-			// we don't publish number of routers and leaseset for non-floodfill
-			m_RouterInfo.DeleteProperty (i2p::data::ROUTER_INFO_PROPERTY_LEASESETS);
-			m_RouterInfo.DeleteProperty (i2p::data::ROUTER_INFO_PROPERTY_ROUTERS);
-		}
-		UpdateRouterInfo ();
-	}
-
-	void RouterContext::SetFamily (const std::string& family)
-	{
-		std::string signature;
-		if (family.length () > 0)
-			signature = i2p::data::CreateFamilySignature (family, GetIdentHash ());
-		if (signature.length () > 0)
-		{
-			m_RouterInfo.SetProperty (i2p::data::ROUTER_INFO_PROPERTY_FAMILY, family);
-			m_RouterInfo.SetProperty (i2p::data::ROUTER_INFO_PROPERTY_FAMILY_SIG, signature);
-		}	
-		else
-		{
-			m_RouterInfo.DeleteProperty (i2p::data::ROUTER_INFO_PROPERTY_FAMILY);
-			m_RouterInfo.DeleteProperty (i2p::data::ROUTER_INFO_PROPERTY_FAMILY_SIG);
-		}	
-	}	
-		
-	void RouterContext::SetHighBandwidth ()
-	{
-		if (!m_RouterInfo.IsHighBandwidth () || m_RouterInfo.IsExtraBandwidth ())
-		{
-			m_RouterInfo.SetCaps ((m_RouterInfo.GetCaps () | i2p::data::RouterInfo::eHighBandwidth) & ~i2p::data::RouterInfo::eExtraBandwidth);
-			UpdateRouterInfo ();
-		}
-	}
-
-	void RouterContext::SetLowBandwidth ()
-	{
-		if (m_RouterInfo.IsHighBandwidth () || m_RouterInfo.IsExtraBandwidth ())
-		{
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () & ~i2p::data::RouterInfo::eHighBandwidth & ~i2p::data::RouterInfo::eExtraBandwidth);
-			UpdateRouterInfo ();
-		}
-	}
-
-	void RouterContext::SetExtraBandwidth ()
-	{	
-		if (!m_RouterInfo.IsExtraBandwidth () || !m_RouterInfo.IsHighBandwidth ())
-		{
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () | i2p::data::RouterInfo::eExtraBandwidth | i2p::data::RouterInfo::eHighBandwidth);
-			UpdateRouterInfo ();
-		}
-	}
-		
-	bool RouterContext::IsUnreachable () const
-	{
-		return m_RouterInfo.GetCaps () & i2p::data::RouterInfo::eUnreachable;
-	}	
-		
-	void RouterContext::SetUnreachable ()
-	{
-		// set caps
-		m_RouterInfo.SetCaps (i2p::data::RouterInfo::eUnreachable | i2p::data::RouterInfo::eSSUTesting); // LU, B
-		// remove NTCP address
-		auto& addresses = m_RouterInfo.GetAddresses ();
-		for (size_t i = 0; i < addresses.size (); i++)
-		{
-			if (addresses[i].transportStyle == i2p::data::RouterInfo::eTransportNTCP)
-			{
-				addresses.erase (addresses.begin () + i);
-				break;
-			}
-		}	
-		// delete previous introducers
-		for (auto& addr : addresses)
-			addr.introducers.clear ();
-	
-		// update
-		UpdateRouterInfo ();
-	}
-
-	void RouterContext::SetReachable ()
-	{
-		// update caps
-		uint8_t caps = m_RouterInfo.GetCaps ();
-		caps &= ~i2p::data::RouterInfo::eUnreachable;
-		caps |= i2p::data::RouterInfo::eReachable;
-		caps |= i2p::data::RouterInfo::eSSUIntroducer;
-		if (m_IsFloodfill)
-			caps |= i2p::data::RouterInfo::eFloodfill;
-		m_RouterInfo.SetCaps (caps);
-		
-		// insert NTCP back
-		auto& addresses = m_RouterInfo.GetAddresses ();
-		for (size_t i = 0; i < addresses.size (); i++)
-		{
-			if (addresses[i].transportStyle == i2p::data::RouterInfo::eTransportSSU)
-			{
-				// insert NTCP address with host/port from SSU
-				m_RouterInfo.AddNTCPAddress (addresses[i].host.to_string ().c_str (), addresses[i].port);
-				break;
-			}
-		}		
-		// delete previous introducers
-		for (auto& addr : addresses)
-			addr.introducers.clear ();
-		
-		// update
-		UpdateRouterInfo ();
-	}	
-		
-	void RouterContext::SetSupportsV6 (bool supportsV6)
-	{
-		if (supportsV6)
-			m_RouterInfo.EnableV6 ();
-		else
-			m_RouterInfo.DisableV6 ();
-		UpdateRouterInfo ();
-	}	
-
-	void RouterContext::UpdateNTCPV6Address (const boost::asio::ip::address& host)
-	{
-		bool updated = false, found = false;	
-		int port = 0;
-		auto& addresses = m_RouterInfo.GetAddresses ();
-		for (auto& addr : addresses)
-		{
-			if (addr.host.is_v6 () && addr.transportStyle == i2p::data::RouterInfo::eTransportNTCP)
-			{
-				if (addr.host != host)
-				{
-					addr.host = host;
-					updated = true;
-				}
-				found = true;	
-			}	
-			else
-				port = addr.port;	
-		}	
-		if (!found)
-		{
-			// create new address
-			m_RouterInfo.AddNTCPAddress (host.to_string ().c_str (), port);
-			auto mtu = i2p::util::net::GetMTU (host);
-			if (mtu)
-			{	
-				LogPrint (eLogDebug, "Router: Our v6 MTU=", mtu);
-				if (mtu > 1472) { // TODO: magic constant
-					mtu = 1472;
-					LogPrint(eLogWarning, "Router: MTU dropped to upper limit of 1472 bytes");
-				}
-			}	
-			m_RouterInfo.AddSSUAddress (host.to_string ().c_str (), port, GetIdentHash (), mtu ? mtu : 1472); // TODO
-			updated = true;
-		}
-		if (updated)
-			UpdateRouterInfo ();
-	}
-
-	void RouterContext::UpdateStats ()
-	{
-		if (m_IsFloodfill)
-		{
-			// update routers and leasesets
-			m_RouterInfo.SetProperty (i2p::data::ROUTER_INFO_PROPERTY_LEASESETS, boost::lexical_cast<std::string>(i2p::data::netdb.GetNumLeaseSets ()));
-			m_RouterInfo.SetProperty (i2p::data::ROUTER_INFO_PROPERTY_ROUTERS, boost::lexical_cast<std::string>(i2p::data::netdb.GetNumRouters ()));
-			UpdateRouterInfo (); 
-		}
-	}
-		
-	bool RouterContext::Load ()
-	{
-		std::ifstream fk (i2p::fs::DataDirPath (ROUTER_KEYS), std::ifstream::in | std::ifstream::binary);
-		if (!fk.is_open ())	return false;
-		fk.seekg (0, std::ios::end);
-		size_t len = fk.tellg();
-		fk.seekg (0, std::ios::beg);		
-
-		if (len == sizeof (i2p::data::Keys)) // old keys file format
-		{
-			i2p::data::Keys keys;	
-			fk.read ((char *)&keys, sizeof (keys));
-			m_Keys = keys;
-		}
-		else // new keys file format
-		{
-			uint8_t * buf = new uint8_t[len];
-			fk.read ((char *)buf, len);
-			m_Keys.FromBuffer (buf, len);
-			delete[] buf;
-		}
-
-		i2p::data::RouterInfo routerInfo(i2p::fs::DataDirPath (ROUTER_INFO)); // TODO
-		m_RouterInfo.SetRouterIdentity (GetIdentity ());
-		m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
-		m_RouterInfo.SetProperty ("coreVersion", I2P_VERSION);
-		m_RouterInfo.SetProperty ("router.version", I2P_VERSION);
-
-		// Migration to 0.9.24. TODO: remove later
-		m_RouterInfo.DeleteProperty ("coreVersion");
-		m_RouterInfo.DeleteProperty ("stat_uptime");
-		
-		if (IsUnreachable ())
-			SetReachable (); // we assume reachable until we discover firewall through peer tests
-		
-		return true;
-	}
-
-	void RouterContext::SaveKeys ()
-	{	
-		// save in the same format as .dat files
-		std::ofstream fk (i2p::fs::DataDirPath (ROUTER_KEYS), std::ofstream::binary | std::ofstream::out);
-		size_t len = m_Keys.GetFullLen ();
-		uint8_t * buf = new uint8_t[len];
-		m_Keys.ToBuffer (buf, len);
-		fk.write ((char *)buf, len);
-		delete[] buf;
-	}
-
-	std::shared_ptr<i2p::tunnel::TunnelPool> RouterContext::GetTunnelPool () const
-	{
-		return i2p::tunnel::tunnels.GetExploratoryPool (); 
-	}	
-		
-	void RouterContext::HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		i2p::HandleI2NPMessage (CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from));
-	}
-
-	void RouterContext::ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		std::unique_lock<std::mutex> l(m_GarlicMutex);
-		i2p::garlic::GarlicDestination::ProcessGarlicMessage (msg);
-	}	
-			
-	void RouterContext::ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg)
-	{
-		std::unique_lock<std::mutex> l(m_GarlicMutex);
-		i2p::garlic::GarlicDestination::ProcessDeliveryStatusMessage (msg);
-	}	
-		
-	uint32_t RouterContext::GetUptime () const
-	{
-		return i2p::util::GetSecondsSinceEpoch () - m_StartupTime;
-	}	
-}

RouterContext.h

@@ -1,108 +0,0 @@
-#ifndef ROUTER_CONTEXT_H__
-#define ROUTER_CONTEXT_H__
-
-#include <inttypes.h>
-#include <string>
-#include <memory>
-#include <mutex>
-#include <boost/asio.hpp>
-#include "Identity.h"
-#include "RouterInfo.h"
-#include "Garlic.h"
-
-namespace i2p
-{
-	const char ROUTER_INFO[] = "router.info";
-	const char ROUTER_KEYS[] = "router.keys";	
-	const int ROUTER_INFO_UPDATE_INTERVAL = 1800; // 30 minutes
-
-	enum RouterStatus
-	{
-		eRouterStatusOK = 0,
-		eRouterStatusTesting = 1,
-		eRouterStatusFirewalled = 2
-	};	
-
-	class RouterContext: public i2p::garlic::GarlicDestination 
-	{
-		public:
-
-			RouterContext ();
-			void Init ();
-
-			i2p::data::RouterInfo& GetRouterInfo () { return m_RouterInfo; };
-			std::shared_ptr<const i2p::data::RouterInfo> GetSharedRouterInfo () const 
-			{ 
-				return std::shared_ptr<const i2p::data::RouterInfo> (&m_RouterInfo, 
-					[](const i2p::data::RouterInfo *) {});
-			}
-			std::shared_ptr<i2p::garlic::GarlicDestination> GetSharedDestination () 
-			{
-				return std::shared_ptr<i2p::garlic::GarlicDestination> (this, 
-					[](i2p::garlic::GarlicDestination *) {});
-			}
-
-			uint32_t GetUptime () const;
-			uint32_t GetStartupTime () const { return m_StartupTime; };
-			uint64_t GetLastUpdateTime () const { return m_LastUpdateTime; };
-			RouterStatus GetStatus () const { return m_Status; };
-			void SetStatus (RouterStatus status);
-
-			void UpdatePort (int port); // called from Daemon
-			void UpdateAddress (const boost::asio::ip::address& host);	// called from SSU or Daemon
-			bool AddIntroducer (const i2p::data::RouterInfo::Introducer& introducer);
-			void RemoveIntroducer (const boost::asio::ip::udp::endpoint& e);
-			bool IsUnreachable () const;
-			void SetUnreachable ();		
-			void SetReachable ();
-			bool IsFloodfill () const { return m_IsFloodfill; };	
-			void SetFloodfill (bool floodfill);	
-			void SetFamily (const std::string& family);
-			void SetHighBandwidth ();
-			void SetLowBandwidth ();
-			void SetExtraBandwidth ();
-			bool AcceptsTunnels () const { return m_AcceptsTunnels; };
-			void SetAcceptsTunnels (bool acceptsTunnels) { m_AcceptsTunnels = acceptsTunnels; };
-			bool SupportsV6 () const { return m_RouterInfo.IsV6 (); };
-			void SetSupportsV6 (bool supportsV6);
-			void UpdateNTCPV6Address (const boost::asio::ip::address& host); // called from NTCP session		
-			void UpdateStats ();		
-
-			// implements LocalDestination
-			const i2p::data::PrivateKeys& GetPrivateKeys () const { return m_Keys; };
-			const uint8_t * GetEncryptionPrivateKey () const { return m_Keys.GetPrivateKey (); };
-			const uint8_t * GetEncryptionPublicKey () const { return GetIdentity ()->GetStandardIdentity ().publicKey; };
-			void SetLeaseSetUpdated () {};
-
-			// implements GarlicDestination
-			std::shared_ptr<const i2p::data::LeaseSet> GetLeaseSet () { return nullptr; };
-			std::shared_ptr<i2p::tunnel::TunnelPool> GetTunnelPool () const;
-			void HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from);
-
-			// override GarlicDestination
-			void ProcessGarlicMessage (std::shared_ptr<I2NPMessage> msg);
-			void ProcessDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);	
-			
-		private:
-
-			void CreateNewRouter ();
-			void NewRouterInfo ();
-			void UpdateRouterInfo ();
-			bool Load ();
-			void SaveKeys ();
-			
-		private:
-
-			i2p::data::RouterInfo m_RouterInfo;
-			i2p::data::PrivateKeys m_Keys; 
-			uint64_t m_LastUpdateTime;
-			bool m_AcceptsTunnels, m_IsFloodfill;
-			uint64_t m_StartupTime; // in seconds since epoch
-			RouterStatus m_Status;
-			std::mutex m_GarlicMutex;
-	};
-
-	extern RouterContext context;
-}	
-
-#endif

RouterInfo.cpp

@@ -1,729 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include "I2PEndian.h"
-#include <fstream>
-#include <boost/lexical_cast.hpp>
-#include "version.h"
-#include "Crypto.h"
-#include "Base.h"
-#include "Timestamp.h"
-#include "Log.h"
-#include "NetDb.h"
-#include "RouterInfo.h"
-
-namespace i2p
-{
-namespace data
-{		
-	RouterInfo::RouterInfo (const std::string& fullPath):
-		m_FullPath (fullPath), m_IsUpdated (false), m_IsUnreachable (false), 
-		m_SupportedTransports (0), m_Caps (0)
-	{
-		m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-		ReadFromFile ();
-	}	
-
-	RouterInfo::RouterInfo (const uint8_t * buf, int len):
-		m_IsUpdated (true), m_IsUnreachable (false), m_SupportedTransports (0), m_Caps (0)
-	{
-		m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer (true);
-	}	
-
-	RouterInfo::~RouterInfo ()
-	{
-		delete[] m_Buffer;
-	}	
-		
-	void RouterInfo::Update (const uint8_t * buf, int len)
-	{
-		// verify signature since we have indentity already
-		int l = len - m_RouterIdentity->GetSignatureLen ();
-		if (m_RouterIdentity->Verify (buf, l, buf + l))
-		{
-			// clean up
-			m_IsUpdated = true;
-			m_IsUnreachable = false;
-			m_SupportedTransports = 0;
-			m_Caps = 0;
-			m_Addresses.clear ();
-			m_Properties.clear ();
-			// copy buffer
-			if (!m_Buffer)	
-				m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-			memcpy (m_Buffer, buf, len);
-			m_BufferLen = len;
-			// skip identity
-			size_t identityLen = m_RouterIdentity->GetFullLen ();
-			// read new RI	
-			std::stringstream str (std::string ((char *)m_Buffer + identityLen, m_BufferLen - identityLen));
-			ReadFromStream (str);
-			// don't delete buffer until saved to the file
-		}
-		else
-		{	
-			LogPrint (eLogError, "RouterInfo: signature verification failed");
-			m_IsUnreachable = true;
-		}
-	}	
-		
-	void RouterInfo::SetRouterIdentity (std::shared_ptr<const IdentityEx> identity)
-	{	
-		m_RouterIdentity = identity;
-		m_Timestamp = i2p::util::GetMillisecondsSinceEpoch ();
-	}
-	
-	bool RouterInfo::LoadFile ()
-	{
-		std::ifstream s(m_FullPath.c_str (), std::ifstream::binary);
-		if (s.is_open ())	
-		{	
-			s.seekg (0,std::ios::end);
-			m_BufferLen = s.tellg ();
-			if (m_BufferLen < 40 || m_BufferLen > MAX_RI_BUFFER_SIZE)
-			{
-				LogPrint(eLogError, "RouterInfo: File", m_FullPath, " is malformed");
-				return false;
-			}
-			s.seekg(0, std::ios::beg);
-			if (!m_Buffer)
-				m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-			s.read((char *)m_Buffer, m_BufferLen);
-		}	
-		else
-		{
-			LogPrint (eLogError, "RouterInfo: Can't open file ", m_FullPath);
-			return false;		
-		}
-		return true;
-	}	
-
-	void RouterInfo::ReadFromFile ()
-	{
-		if (LoadFile ())
-			ReadFromBuffer (false); 
-	}	
-
-	void RouterInfo::ReadFromBuffer (bool verifySignature)
-	{
-		m_RouterIdentity = std::make_shared<IdentityEx>(m_Buffer, m_BufferLen);
-		size_t identityLen = m_RouterIdentity->GetFullLen ();
-		if (identityLen >= m_BufferLen)
-		{
-			LogPrint (eLogError, "RouterInfo: identity length ", identityLen, " exceeds buffer size ", m_BufferLen);
-			m_IsUnreachable = true;
-			return;
-		}
-		std::stringstream str (std::string ((char *)m_Buffer + identityLen, m_BufferLen - identityLen));
-		ReadFromStream (str);
-		if (!str)
-		{
-			LogPrint (eLogError, "RouterInfo: malformed message");
-			m_IsUnreachable = true;
-			return;
-		}
-		if (verifySignature)
-		{	
-			// verify signature
-			int l = m_BufferLen - m_RouterIdentity->GetSignatureLen ();	
-			if (l < 0 || !m_RouterIdentity->Verify ((uint8_t *)m_Buffer, l, (uint8_t *)m_Buffer + l))
-			{	
-				LogPrint (eLogError, "RouterInfo: signature verification failed");
-				m_IsUnreachable = true;
-			}
-			m_RouterIdentity->DropVerifier ();
-		}	
-	}	
-	
-	void RouterInfo::ReadFromStream (std::istream& s)
-	{
-		s.read ((char *)&m_Timestamp, sizeof (m_Timestamp));
-		m_Timestamp = be64toh (m_Timestamp);
-		// read addresses
-		uint8_t numAddresses;
-		s.read ((char *)&numAddresses, sizeof (numAddresses)); if (!s) return;	
-		bool introducers = false;
-		for (int i = 0; i < numAddresses; i++)
-		{
-			uint8_t supportedTransports = 0;
-			bool isValidAddress = true;
-			Address address;
-			s.read ((char *)&address.cost, sizeof (address.cost));
-			s.read ((char *)&address.date, sizeof (address.date));
-			char transportStyle[5];
-			ReadString (transportStyle, s);
-			if (!strcmp (transportStyle, "NTCP"))
-				address.transportStyle = eTransportNTCP;
-			else if (!strcmp (transportStyle, "SSU"))
-				address.transportStyle = eTransportSSU;
-			else
-				address.transportStyle = eTransportUnknown;
-			address.port = 0;
-			address.mtu = 0;
-			uint16_t size, r = 0;
-			s.read ((char *)&size, sizeof (size)); if (!s) return;
-			size = be16toh (size);
-			while (r < size)
-			{
-				char key[500], value[500];
-				r += ReadString (key, s);
-				s.seekg (1, std::ios_base::cur); r++; // =
-				r += ReadString (value, s); 
-				s.seekg (1, std::ios_base::cur); r++; // ;
-				if (!strcmp (key, "host"))
-				{	
-					boost::system::error_code ecode;
-					address.host = boost::asio::ip::address::from_string (value, ecode);
-					if (ecode)
-					{	
-						if (address.transportStyle == eTransportNTCP)
-						{
-							supportedTransports |= eNTCPV4; // TODO:
-							address.addressString = value;
-						}
-						else
-						{	
-							supportedTransports |= eSSUV4; // TODO:
-							address.addressString = value;
-						}	
-					}	
-					else
-					{
-						// add supported protocol
-						if (address.host.is_v4 ())
-							supportedTransports |= (address.transportStyle == eTransportNTCP) ? eNTCPV4 : eSSUV4;	
-						else
-							supportedTransports |= (address.transportStyle == eTransportNTCP) ? eNTCPV6 : eSSUV6;
- 					}	
-				}	
-				else if (!strcmp (key, "port"))
-					address.port = boost::lexical_cast<int>(value);
-				else if (!strcmp (key, "mtu"))
-					address.mtu = boost::lexical_cast<int>(value);
-				else if (!strcmp (key, "key"))
-					Base64ToByteStream (value, strlen (value), address.key, 32);
-				else if (!strcmp (key, "caps"))
-					ExtractCaps (value);
-				else if (key[0] == 'i')
-				{	
-					// introducers
-					introducers = true;
-					size_t l = strlen(key); 	
-					unsigned char index = key[l-1] - '0'; // TODO:
-					key[l-1] = 0;
-					if (index >= address.introducers.size ())
-						address.introducers.resize (index + 1); 
-					Introducer& introducer = address.introducers.at (index);
-					if (!strcmp (key, "ihost"))
-					{
-						boost::system::error_code ecode;
-						introducer.iHost = boost::asio::ip::address::from_string (value, ecode);
-					}	
-					else if (!strcmp (key, "iport"))
-						introducer.iPort = boost::lexical_cast<int>(value);
-					else if (!strcmp (key, "itag"))
-						introducer.iTag = boost::lexical_cast<uint32_t>(value);
-					else if (!strcmp (key, "ikey"))
-						Base64ToByteStream (value, strlen (value), introducer.iKey, 32);
-				}
-				if (!s) return;
-			}	
-			if (isValidAddress)
-			{
-				m_Addresses.push_back(address);
-				m_SupportedTransports |= supportedTransports;
-			}
-		}	
-		// read peers
-		uint8_t numPeers;
-		s.read ((char *)&numPeers, sizeof (numPeers)); if (!s) return;
-		s.seekg (numPeers*32, std::ios_base::cur); // TODO: read peers
-		// read properties
-		uint16_t size, r = 0;
-		s.read ((char *)&size, sizeof (size)); if (!s) return;
-		size = be16toh (size);
-		while (r < size)
-		{
-#ifdef _WIN32			
-			char key[500], value[500];
-			// TODO: investigate why properties get read as one long string under Windows
-			// length should not be more than 44
-#else
-			char key[50], value[50];
-#endif			
-			r += ReadString (key, s);
-			s.seekg (1, std::ios_base::cur); r++; // =
-			r += ReadString (value, s); 
-			s.seekg (1, std::ios_base::cur); r++; // ;
-			m_Properties[key] = value;
-			
-			// extract caps	
-			if (!strcmp (key, "caps"))
-				ExtractCaps (value);
-			// check netId
-			else if (!strcmp (key, ROUTER_INFO_PROPERTY_NETID) && atoi (value) != I2PD_NET_ID)
-			{
-				LogPrint (eLogError, "Unexpected ", ROUTER_INFO_PROPERTY_NETID, "=", value);
-				m_IsUnreachable = true;		
-			}	
-			// family
-			else if (!strcmp (key, ROUTER_INFO_PROPERTY_FAMILY))
-			{
-				m_Family = value;
-				boost::to_lower (m_Family);
-			}
-			else if (!strcmp (key, ROUTER_INFO_PROPERTY_FAMILY_SIG))
-			{
-				if (!netdb.GetFamilies ().VerifyFamily (m_Family, GetIdentHash (), value))
-				{
-					LogPrint (eLogWarning, "RouterInfo: family signature verification failed");
-					m_Family.clear ();
-				}
-			}				
-
-			if (!s) return;
-		}		
-
-		if (!m_SupportedTransports || !m_Addresses.size() || (UsesIntroducer () && !introducers))
-			SetUnreachable (true);
-	}	
-
-	void RouterInfo::ExtractCaps (const char * value)
-	{
-		const char * cap = value;
-		while (*cap)
-		{
-			switch (*cap)
-			{
-				case CAPS_FLAG_FLOODFILL:
-					m_Caps |= Caps::eFloodfill;
-				break;
-				case CAPS_FLAG_HIGH_BANDWIDTH1:
-				case CAPS_FLAG_HIGH_BANDWIDTH2:
-				case CAPS_FLAG_HIGH_BANDWIDTH3:
-					m_Caps |= Caps::eHighBandwidth;
-				break;
-				case CAPS_FLAG_EXTRA_BANDWIDTH1:
-				case CAPS_FLAG_EXTRA_BANDWIDTH2:
-					m_Caps |= Caps::eExtraBandwidth;
-				break;	
-				case CAPS_FLAG_HIDDEN:
-					m_Caps |= Caps::eHidden;
-				break;	
-				case CAPS_FLAG_REACHABLE:
-					m_Caps |= Caps::eReachable;
-				break;
-				case CAPS_FLAG_UNREACHABLE:
-					m_Caps |= Caps::eUnreachable;
-				break;	
-				case CAPS_FLAG_SSU_TESTING:
-					m_Caps |= Caps::eSSUTesting;
-				break;	
-				case CAPS_FLAG_SSU_INTRODUCER:
-					m_Caps |= Caps::eSSUIntroducer;
-				break;	
-				default: ;
-			}	
-			cap++;
-		}
-	}
-
-	void RouterInfo::UpdateCapsProperty ()
-	{	
-		std::string caps;
-		if (m_Caps & eFloodfill) 
-		{
-			if (m_Caps & eExtraBandwidth) caps += CAPS_FLAG_EXTRA_BANDWIDTH1; // 'P'
-			caps += CAPS_FLAG_HIGH_BANDWIDTH3; // 'O'
-			caps += CAPS_FLAG_FLOODFILL; // floodfill  
-		}	
-		else
-		{
-			if (m_Caps & eExtraBandwidth) caps += CAPS_FLAG_EXTRA_BANDWIDTH1;
-			caps += (m_Caps & eHighBandwidth) ? CAPS_FLAG_HIGH_BANDWIDTH3 : CAPS_FLAG_LOW_BANDWIDTH2; // bandwidth	
-		}	
-		if (m_Caps & eHidden) caps += CAPS_FLAG_HIDDEN; // hidden
-		if (m_Caps & eReachable) caps += CAPS_FLAG_REACHABLE; // reachable
-		if (m_Caps & eUnreachable) caps += CAPS_FLAG_UNREACHABLE; // unreachable
-
-		SetProperty ("caps", caps.c_str ());
-	}
-		
-	void RouterInfo::WriteToStream (std::ostream& s)
-	{
-		uint64_t ts = htobe64 (m_Timestamp);
-		s.write ((char *)&ts, sizeof (ts));
-
-		// addresses
-		uint8_t numAddresses = m_Addresses.size ();
-		s.write ((char *)&numAddresses, sizeof (numAddresses));
-		for (auto& address : m_Addresses)
-		{
-			s.write ((char *)&address.cost, sizeof (address.cost));
-			s.write ((char *)&address.date, sizeof (address.date));
-			std::stringstream properties;
-			if (address.transportStyle == eTransportNTCP)
-				WriteString ("NTCP", s);
-			else if (address.transportStyle == eTransportSSU)
-			{	
-				WriteString ("SSU", s);
-				// caps
-				WriteString ("caps", properties);
-				properties << '=';
-				std::string caps;
-				if (IsPeerTesting ()) caps += CAPS_FLAG_SSU_TESTING;
-				if (IsIntroducer ()) caps += CAPS_FLAG_SSU_INTRODUCER;
-				WriteString (caps, properties);
-				properties << ';';
-			}	
-			else
-				WriteString ("", s);
-
-			WriteString ("host", properties);
-			properties << '=';
-			WriteString (address.host.to_string (), properties);
-			properties << ';';
-			if (address.transportStyle == eTransportSSU)
-			{
-				// write introducers if any
-				if (address.introducers.size () > 0)
-				{	
-					int i = 0;
-					for (auto introducer: address.introducers)
-					{
-						WriteString ("ihost" + boost::lexical_cast<std::string>(i), properties);
-						properties << '=';
-						WriteString (introducer.iHost.to_string (), properties);
-						properties << ';';
-						i++;
-					}	
-					i = 0;
-					for (auto introducer: address.introducers)
-					{
-						WriteString ("ikey" + boost::lexical_cast<std::string>(i), properties);
-						properties << '=';
-						char value[64];
-						size_t l = ByteStreamToBase64 (introducer.iKey, 32, value, 64);
-						value[l] = 0;
-						WriteString (value, properties);
-						properties << ';';
-						i++;
-					}	
-					i = 0;
-					for (auto introducer: address.introducers)
-					{
-						WriteString ("iport" + boost::lexical_cast<std::string>(i), properties);
-						properties << '=';
-						WriteString (boost::lexical_cast<std::string>(introducer.iPort), properties);
-						properties << ';';
-						i++;
-					}	
-					i = 0;
-					for (auto introducer: address.introducers)
-					{
-						WriteString ("itag" + boost::lexical_cast<std::string>(i), properties);
-						properties << '=';
-						WriteString (boost::lexical_cast<std::string>(introducer.iTag), properties);
-						properties << ';';
-						i++;
-					}	
-				}	
-				// write intro key
-				WriteString ("key", properties);
-				properties << '=';
-				char value[64];
-				size_t l = ByteStreamToBase64 (address.key, 32, value, 64);
-				value[l] = 0;
-				WriteString (value, properties);
-				properties << ';';
-				// write mtu
-				if (address.mtu)
-				{
-					WriteString ("mtu", properties);
-					properties << '=';
-					WriteString (boost::lexical_cast<std::string>(address.mtu), properties);
-					properties << ';';
-				}	
-			}	
-			WriteString ("port", properties);
-			properties << '=';
-			WriteString (boost::lexical_cast<std::string>(address.port), properties);
-			properties << ';';
-			
-			uint16_t size = htobe16 (properties.str ().size ());
-			s.write ((char *)&size, sizeof (size));
-			s.write (properties.str ().c_str (), properties.str ().size ());
-		}	
-
-		// peers
-		uint8_t numPeers = 0;
-		s.write ((char *)&numPeers, sizeof (numPeers));
-
-		// properties
-		std::stringstream properties;
-		for (auto& p : m_Properties)
-		{
-			WriteString (p.first, properties);
-			properties << '=';
-			WriteString (p.second, properties);
-			properties << ';';
-		}	
-		uint16_t size = htobe16 (properties.str ().size ());
-		s.write ((char *)&size, sizeof (size));
-		s.write (properties.str ().c_str (), properties.str ().size ());
-	}	
-
-	bool RouterInfo::IsNewer (const uint8_t * buf, size_t len) const
-	{
-		if (!m_RouterIdentity) return false;
-		size_t size = m_RouterIdentity->GetFullLen ();
-		if (size + 8 > len) return false;
-		return bufbe64toh (buf + size) > m_Timestamp; 
-	}
-
-	const uint8_t * RouterInfo::LoadBuffer ()
-	{
-		if (!m_Buffer)
-		{
-			if (LoadFile ())
-				LogPrint (eLogDebug, "RouterInfo: Buffer for ", GetIdentHashAbbreviation (GetIdentHash ()), " loaded from file");
-		} 
-		return m_Buffer; 
-	}
-
-	void RouterInfo::CreateBuffer (const PrivateKeys& privateKeys)
-	{
-		m_Timestamp = i2p::util::GetMillisecondsSinceEpoch (); // refresh timstamp
-		std::stringstream s;
-		uint8_t ident[1024];
-		auto identLen = privateKeys.GetPublic ()->ToBuffer (ident, 1024);
-		s.write ((char *)ident, identLen);			
-		WriteToStream (s);
-		m_BufferLen = s.str ().size ();
-		if (!m_Buffer)
-			m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-		memcpy (m_Buffer, s.str ().c_str (), m_BufferLen);
-		// signature
-		privateKeys.Sign ((uint8_t *)m_Buffer, m_BufferLen, (uint8_t *)m_Buffer + m_BufferLen);
-		m_BufferLen += privateKeys.GetPublic ()->GetSignatureLen ();
-	}	
-
-	void RouterInfo::SaveToFile (const std::string& fullPath)
-	{
-		m_FullPath = fullPath;
-		if (m_Buffer)
-		{	
-			std::ofstream f (fullPath, std::ofstream::binary | std::ofstream::out);
-			if (f.is_open ())
-				f.write ((char *)m_Buffer, m_BufferLen);
-			else
-				LogPrint(eLogError, "RouterInfo: Can't save to ", fullPath);
-		}
-		else
-			LogPrint (eLogError, "RouterInfo: Can't save, m_Buffer == NULL");
-	}
-	
-	size_t RouterInfo::ReadString (char * str, std::istream& s)
-	{
-		uint8_t len;
-		s.read ((char *)&len, 1);
-		s.read (str, len);
-		str[len] = 0;
-		return len+1;
-	}	
-
-	void RouterInfo::WriteString (const std::string& str, std::ostream& s)
-	{
-		uint8_t len = str.size ();
-		s.write ((char *)&len, 1);
-		s.write (str.c_str (), len);
-	}	
-
-	void RouterInfo::AddNTCPAddress (const char * host, int port)
-	{
-		Address addr;
-		addr.host = boost::asio::ip::address::from_string (host);
-		addr.port = port;
-		addr.transportStyle = eTransportNTCP;
-		addr.cost = 2;
-		addr.date = 0;
-		addr.mtu = 0;
-		for (auto it: m_Addresses) // don't insert same address twice
-			if (it == addr) return;
-		m_Addresses.push_back(addr);	
-		m_SupportedTransports |= addr.host.is_v6 () ? eNTCPV6 : eNTCPV4;
-	}	
-
-	void RouterInfo::AddSSUAddress (const char * host, int port, const uint8_t * key, int mtu)
-	{
-		Address addr;
-		addr.host = boost::asio::ip::address::from_string (host);
-		addr.port = port;
-		addr.transportStyle = eTransportSSU;
-		addr.cost = 10; // NTCP should have priority over SSU
-		addr.date = 0;
-		addr.mtu = mtu; 
-		memcpy (addr.key, key, 32);
-		for (auto it: m_Addresses) // don't insert same address twice
-			if (it == addr) return;
-		m_Addresses.push_back(addr);	
-		m_SupportedTransports |= addr.host.is_v6 () ? eSSUV6 : eSSUV4;
-		m_Caps |= eSSUTesting; 
-		m_Caps |= eSSUIntroducer; 
-	}	
-
-	bool RouterInfo::AddIntroducer (const Introducer& introducer)
-	{
-		for (auto& addr : m_Addresses)
-		{
-			if (addr.transportStyle == eTransportSSU && addr.host.is_v4 ())
-			{	
-				for (auto intro: addr.introducers)
-					if (intro.iTag == introducer.iTag) return false; // already presented
-				addr.introducers.push_back (introducer);
-				return true;
-			}	
-		}	
-		return false;
-	}	
-
-	bool RouterInfo::RemoveIntroducer (const boost::asio::ip::udp::endpoint& e)
-	{		
-		for (auto& addr : m_Addresses)
-		{
-			if (addr.transportStyle == eTransportSSU && addr.host.is_v4 ())
-			{	
-				for (std::vector<Introducer>::iterator it = addr.introducers.begin (); it != addr.introducers.end (); it++)
-					if ( boost::asio::ip::udp::endpoint (it->iHost, it->iPort) == e) 
-					{
-						addr.introducers.erase (it);
-						return true;
-					}	
-			}	
-		}	
-		return false;
-	}
-
-	void RouterInfo::SetCaps (uint8_t caps)
-	{
-		m_Caps = caps;
-		UpdateCapsProperty ();
-	}
-		
-	void RouterInfo::SetCaps (const char * caps)
-	{
-		SetProperty ("caps", caps);
-		m_Caps = 0;
-		ExtractCaps (caps);
-	}	
-		
-	void RouterInfo::SetProperty (const std::string& key, const std::string& value)
-	{
-		m_Properties[key] = value;
-	}	
-
-	void RouterInfo::DeleteProperty (const std::string& key)
-	{
-		m_Properties.erase (key);
-	}
-
-	bool RouterInfo::IsNTCP (bool v4only) const
-	{
-		if (v4only)
-			return m_SupportedTransports & eNTCPV4;
-		else
-			return m_SupportedTransports & (eNTCPV4 | eNTCPV6);
-	}		
-
-	bool RouterInfo::IsSSU (bool v4only) const
-	{
-		if (v4only)
-			return m_SupportedTransports & eSSUV4;
-		else
-			return m_SupportedTransports & (eSSUV4 | eSSUV6);
-	}
-
-	bool RouterInfo::IsV6 () const
-	{
-		return m_SupportedTransports & (eNTCPV6 | eSSUV6);
-	}
-
-	void RouterInfo::EnableV6 ()
-	{
-		if (!IsV6 ())
-			m_SupportedTransports |= eNTCPV6 | eSSUV6;
-	}
-		
-	void RouterInfo::DisableV6 ()
-	{		
-		if (IsV6 ())
-		{	
-			// NTCP
-			m_SupportedTransports &= ~eNTCPV6; 
-			for (size_t i = 0; i < m_Addresses.size (); i++)
-			{
-				if (m_Addresses[i].transportStyle == i2p::data::RouterInfo::eTransportNTCP &&
-					m_Addresses[i].host.is_v6 ())
-				{
-					m_Addresses.erase (m_Addresses.begin () + i);
-					break;
-				}
-			}	
-			
-			// SSU
-			m_SupportedTransports &= ~eSSUV6; 
-			for (size_t i = 0; i < m_Addresses.size (); i++)
-			{
-				if (m_Addresses[i].transportStyle == i2p::data::RouterInfo::eTransportSSU &&
-					m_Addresses[i].host.is_v6 ())
-				{
-					m_Addresses.erase (m_Addresses.begin () + i);
-					break;
-				}
-			}	
-		}	
-	}
-		
-	bool RouterInfo::UsesIntroducer () const
-	{
-		return m_Caps & Caps::eUnreachable; // non-reachable
-	}		
-		
-	const RouterInfo::Address * RouterInfo::GetNTCPAddress (bool v4only) const
-	{
-		return GetAddress (eTransportNTCP, v4only);
-	}	
-
-	const RouterInfo::Address * RouterInfo::GetSSUAddress (bool v4only) const 
-	{
-		return GetAddress (eTransportSSU, v4only);
-	}	
-
-	const RouterInfo::Address * RouterInfo::GetSSUV6Address () const 
-	{
-		return GetAddress (eTransportSSU, false, true);
-	}	
-		
-	const RouterInfo::Address * RouterInfo::GetAddress (TransportStyle s, bool v4only, bool v6only) const
-	{
-		for (auto& address : m_Addresses)
-		{
-			if (address.transportStyle == s)
-			{	
-				if ((!v4only || address.host.is_v4 ()) && (!v6only || address.host.is_v6 ()))
-					return &address;
-			}	
-		}	
-		return nullptr;
-	}	
-
-	std::shared_ptr<RouterProfile> RouterInfo::GetProfile () const 
-	{
-		if (!m_Profile)
-			m_Profile = GetRouterProfile (GetIdentHash ());
-		return m_Profile;
-	}	
-}
-}

RouterInfo.h

@@ -1,204 +0,0 @@
-#ifndef ROUTER_INFO_H__
-#define ROUTER_INFO_H__
-
-#include <inttypes.h>
-#include <string>
-#include <map>
-#include <vector>
-#include <iostream>
-#include <boost/asio.hpp>
-#include "Identity.h"
-#include "Profiling.h"
-
-namespace i2p
-{
-namespace data
-{
-	const char ROUTER_INFO_PROPERTY_LEASESETS[] = "netdb.knownLeaseSets";
-	const char ROUTER_INFO_PROPERTY_ROUTERS[] = "netdb.knownRouters";	
-	const char ROUTER_INFO_PROPERTY_NETID[] = "netId";
-	const char ROUTER_INFO_PROPERTY_FAMILY[] = "family";	
-	const char ROUTER_INFO_PROPERTY_FAMILY_SIG[] = "family.sig";
-	
-	const char CAPS_FLAG_FLOODFILL = 'f';
-	const char CAPS_FLAG_HIDDEN = 'H';
-	const char CAPS_FLAG_REACHABLE = 'R';
-	const char CAPS_FLAG_UNREACHABLE = 'U';	
-	const char CAPS_FLAG_LOW_BANDWIDTH1 = 'K';		
-	const char CAPS_FLAG_LOW_BANDWIDTH2 = 'L';	
-	const char CAPS_FLAG_HIGH_BANDWIDTH1 = 'M';	
-	const char CAPS_FLAG_HIGH_BANDWIDTH2 = 'N';
-	const char CAPS_FLAG_HIGH_BANDWIDTH3 = 'O';
-	const char CAPS_FLAG_EXTRA_BANDWIDTH1 = 'P';
-	const char CAPS_FLAG_EXTRA_BANDWIDTH2 = 'X';
-	
-	const char CAPS_FLAG_SSU_TESTING = 'B';
-	const char CAPS_FLAG_SSU_INTRODUCER = 'C';
-
-	const int MAX_RI_BUFFER_SIZE = 2048;
-	class RouterInfo: public RoutingDestination
-	{
-		public:
-
-			enum SupportedTranports
-			{	
-				eNTCPV4 = 0x01,
-				eNTCPV6 = 0x02,
-				eSSUV4 = 0x04,
-				eSSUV6 = 0x08
-			};
-			
-			enum Caps
-			{
-				eFloodfill = 0x01,
-				eHighBandwidth = 0x02,
-				eExtraBandwidth = 0x04,
-				eReachable = 0x08,
-				eSSUTesting = 0x10,
-				eSSUIntroducer = 0x20,
-				eHidden = 0x40,
-				eUnreachable = 0x80
-			};
-
-			enum TransportStyle
-			{
-				eTransportUnknown = 0,
-				eTransportNTCP,
-				eTransportSSU
-			};
-
-			typedef Tag<32> IntroKey; // should be castable to MacKey and AESKey
-			struct Introducer			
-			{
-				boost::asio::ip::address iHost;
-				int iPort;
-				IntroKey iKey;
-				uint32_t iTag;
-			};
-
-			struct Address
-			{
-				TransportStyle transportStyle;
-				boost::asio::ip::address host;
-				std::string addressString;
-				int port, mtu;
-				uint64_t date;
-				uint8_t cost;
-				// SSU only
-				IntroKey key; // intro key for SSU
-				std::vector<Introducer> introducers;
-
-				bool IsCompatible (const boost::asio::ip::address& other) const 
-				{
-					return (host.is_v4 () && other.is_v4 ()) ||
-						(host.is_v6 () && other.is_v6 ());
-				}	
-
-				bool operator==(const Address& other) const
-				{
-					return transportStyle == other.transportStyle && host == other.host && port == other.port;
-				}	
-
-				bool operator!=(const Address& other) const
-				{
-					return !(*this == other);
-				}	
-			};
-			
-			RouterInfo (const std::string& fullPath);
-			RouterInfo (): m_Buffer (nullptr) { };
-			RouterInfo (const RouterInfo& ) = default;
-			RouterInfo& operator=(const RouterInfo& ) = default;
-			RouterInfo (const uint8_t * buf, int len);
-			~RouterInfo ();
-			
-			std::shared_ptr<const IdentityEx> GetRouterIdentity () const { return m_RouterIdentity; };
-			void SetRouterIdentity (std::shared_ptr<const IdentityEx> identity);
-			std::string GetIdentHashBase64 () const { return GetIdentHash ().ToBase64 (); };
-			uint64_t GetTimestamp () const { return m_Timestamp; };
-			std::vector<Address>& GetAddresses () { return m_Addresses; };
-			const Address * GetNTCPAddress (bool v4only = true) const;
-			const Address * GetSSUAddress (bool v4only = true) const;
-			const Address * GetSSUV6Address () const;
-			
-			void AddNTCPAddress (const char * host, int port);
-			void AddSSUAddress (const char * host, int port, const uint8_t * key, int mtu = 0);
-			bool AddIntroducer (const Introducer& introducer);
-			bool RemoveIntroducer (const boost::asio::ip::udp::endpoint& e);
-			void SetProperty (const std::string& key, const std::string& value); // called from RouterContext only
-			void DeleteProperty (const std::string& key); // called from RouterContext only
-			void ClearProperties () { m_Properties.clear (); };
-			bool IsFloodfill () const { return m_Caps & Caps::eFloodfill; };
-			bool IsReachable () const { return m_Caps & Caps::eReachable; };
-			bool IsNTCP (bool v4only = true) const;
-			bool IsSSU (bool v4only = true) const;
-			bool IsV6 () const;
-			void EnableV6 ();
-			void DisableV6 ();
-			bool IsCompatible (const RouterInfo& other) const { return m_SupportedTransports & other.m_SupportedTransports; };
-			bool UsesIntroducer () const;
-			bool IsIntroducer () const { return m_Caps & eSSUIntroducer; };
-			bool IsPeerTesting () const { return m_Caps & eSSUTesting; };
-			bool IsHidden () const { return m_Caps & eHidden; };
-			bool IsHighBandwidth () const { return m_Caps & RouterInfo::eHighBandwidth; };
-			bool IsExtraBandwidth () const { return m_Caps & RouterInfo::eExtraBandwidth; };	
-			
-			uint8_t GetCaps () const { return m_Caps; };	
-			void SetCaps (uint8_t caps);
-			void SetCaps (const char * caps);
-
-			void SetUnreachable (bool unreachable) { m_IsUnreachable = unreachable; }; 
-			bool IsUnreachable () const { return m_IsUnreachable; };
-
-			const uint8_t * GetBuffer () const { return m_Buffer; };
-			const uint8_t * LoadBuffer (); // load if necessary
-			int GetBufferLen () const { return m_BufferLen; };			
-			void CreateBuffer (const PrivateKeys& privateKeys);
-
-			bool IsUpdated () const { return m_IsUpdated; };
-			void SetUpdated (bool updated) { m_IsUpdated = updated; }; 
-			void SaveToFile (const std::string& fullPath);
-
-			std::shared_ptr<RouterProfile> GetProfile () const;
-			void SaveProfile () { if (m_Profile) m_Profile->Save (); };
-			
-			void Update (const uint8_t * buf, int len);
-			void DeleteBuffer () { delete[] m_Buffer; m_Buffer = nullptr; };
-			bool IsNewer (const uint8_t * buf, size_t len) const;			
-
-			// implements RoutingDestination
-			const IdentHash& GetIdentHash () const { return m_RouterIdentity->GetIdentHash (); };
-			const uint8_t * GetEncryptionPublicKey () const { return m_RouterIdentity->GetStandardIdentity ().publicKey; };
-			bool IsDestination () const { return false; };
-
-			
-		private:
-
-			bool LoadFile ();
-			void ReadFromFile ();
-			void ReadFromStream (std::istream& s);
-			void ReadFromBuffer (bool verifySignature);
-			void WriteToStream (std::ostream& s);
-			size_t ReadString (char * str, std::istream& s);
-			void WriteString (const std::string& str, std::ostream& s);
-			void ExtractCaps (const char * value);
-			const Address * GetAddress (TransportStyle s, bool v4only, bool v6only = false) const;
-			void UpdateCapsProperty ();			
-
-		private:
-
-			std::string m_FullPath, m_Family;
-			std::shared_ptr<const IdentityEx> m_RouterIdentity;
-			uint8_t * m_Buffer;
-			size_t m_BufferLen;
-			uint64_t m_Timestamp;
-			std::vector<Address> m_Addresses;
-			std::map<std::string, std::string> m_Properties;
-			bool m_IsUpdated, m_IsUnreachable;
-			uint8_t m_SupportedTransports, m_Caps;
-			mutable std::shared_ptr<RouterProfile> m_Profile;
-	};	
-}	
-}
-
-#endif

SAM.cpp

@@ -1,878 +0,0 @@
-#include <string.h>
-#include <stdio.h>
-#ifdef _MSC_VER
-#include <stdlib.h>
-#endif
-#include <boost/lexical_cast.hpp>
-#include "Base.h"
-#include "Identity.h"
-#include "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 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 (eLogError, "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 (eLogDebug, "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 (eLogError, "SAM: handshake mismatch");
-				Terminate ();
-			}
-		}
-	}
-
-	void SAMSocket::HandleHandshakeReplySent (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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 bytes_transferred, bool close)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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 (eLogError, "SAM: read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else if (m_SocketType == eSAMSocketTypeStream)
-			HandleReceived (ecode, bytes_transferred);
-		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 len)
-	{
-		LogPrint (eLogDebug, "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 ();
-				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::data::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 len)
-	{
-		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)
-		{
-			auto dest = std::make_shared<i2p::data::IdentityEx> ();
-			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 (eLogError, "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 len)
-	{
-		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 len)
-	{
-		LogPrint (eLogDebug, "SAM: naming lookup: ", buf);
-		std::map<std::string, std::string> params;
-		ExtractParams (buf, params);
-		std::string& name = params[SAM_PARAM_NAME];
-		std::shared_ptr<const i2p::data::IdentityEx> identity;
-		i2p::data::IdentHash ident;
-		if (name == "ME")
-			SendNamingLookupReply (m_Session->localDestination->GetIdentity ());
-		else if ((identity = context.GetAddressBook ().GetAddress (name)) != nullptr)
-			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 (eLogError, "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 (eLogError, "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 (std::shared_ptr<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, "SAM: 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 (eLogError, "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 (eLogError, "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 (eLogError, "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 (eLogDebug, "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)
-			{
-				// get remote peer address
-				auto ident_ptr = stream->GetRemoteIdentity();
-				const size_t ident_len = ident_ptr->GetFullLen();
-				uint8_t* ident = new uint8_t[ident_len];
-
-				// send remote peer address as base64 
-				const size_t l = ident_ptr->ToBuffer (ident, ident_len);
-				const size_t l1 = i2p::data::ByteStreamToBase64 (ident, l, (char *)m_StreamBuffer, SAM_SOCKET_BUFFER_SIZE);
-				delete[] ident;
-				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 (eLogWarning, "SAM: I2P acceptor has been reset");
-	}	
-
-	void SAMSocket::HandleI2PDatagramReceive (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
-	{
-		LogPrint (eLogDebug, "SAM: datagram received ", len);
-		auto base64 = from.ToBase64 ();
-#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)
-	{
-	}
-
-	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 (eLogError, "SAM: runtime exception: ", 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 (eLogDebug, "SAM: new connection from ", ep);
-				socket->ReceiveHandshake ();
-			}
-			else
-				LogPrint (eLogError, "SAM: incoming connection error ", ec.message ());
-		}
-		else
-			LogPrint (eLogError, "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 (eLogWarning, "SAM: 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 (eLogDebug, "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 (eLogError, "SAM: Session ", sessionID, " not found");
-				}
-				else
-					LogPrint (eLogError, "SAM: Missing destination key");
-			}
-			else
-				LogPrint (eLogError, "SAM: Missing sessionID");
-			ReceiveDatagram ();
-		}
-		else
-			LogPrint (eLogError, "SAM: datagram receive error: ", ecode.message ());
-	}
-}
-}

SAM.h

@@ -1,192 +0,0 @@
-#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_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,
-		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 (std::shared_ptr<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::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;
-
-		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);
-
-		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];
-
-		public:
-
-			// for HTTP
-			const decltype(m_Sessions)& GetSessions () const { return m_Sessions; };
-	};		
-}
-}
-
-#endif
-

SSU.cpp

@@ -1,604 +0,0 @@
-#include <string.h>
-#include <boost/bind.hpp>
-#include "Log.h"
-#include "Timestamp.h"
-#include "RouterContext.h"
-#include "NetDb.h"
-#include "SSU.h"
-
-namespace i2p
-{
-namespace transport
-{
-	SSUServer::SSUServer (int port): m_Thread (nullptr), m_ThreadV6 (nullptr), m_ReceiversThread (nullptr),
-		m_Work (m_Service), m_WorkV6 (m_ServiceV6), m_ReceiversWork (m_ReceiversService), 
-		m_Endpoint (boost::asio::ip::udp::v4 (), port), m_EndpointV6 (boost::asio::ip::udp::v6 (), port), 
-		m_Socket (m_ReceiversService, m_Endpoint), m_SocketV6 (m_ReceiversService), 
-		m_IntroducersUpdateTimer (m_Service), m_PeerTestsCleanupTimer (m_Service)	
-	{
-		m_Socket.set_option (boost::asio::socket_base::receive_buffer_size (65535));
-		m_Socket.set_option (boost::asio::socket_base::send_buffer_size (65535));
-		if (context.SupportsV6 ())
-		{
-			m_SocketV6.open (boost::asio::ip::udp::v6());
-			m_SocketV6.set_option (boost::asio::ip::v6_only (true));
-			m_SocketV6.set_option (boost::asio::socket_base::receive_buffer_size (65535));
-			m_SocketV6.set_option (boost::asio::socket_base::send_buffer_size (65535));
-			m_SocketV6.bind (m_EndpointV6);
-		}
-	}
-	
-	SSUServer::~SSUServer ()
-	{
-	}
-
-	void SSUServer::Start ()
-	{
-		m_IsRunning = true;
-		m_ReceiversThread = new std::thread (std::bind (&SSUServer::RunReceivers, this)); 
-		m_Thread = new std::thread (std::bind (&SSUServer::Run, this));
-		m_ReceiversService.post (std::bind (&SSUServer::Receive, this));  
-		if (context.SupportsV6 ())
-		{	
-			m_ThreadV6 = new std::thread (std::bind (&SSUServer::RunV6, this));
-			m_ReceiversService.post (std::bind (&SSUServer::ReceiveV6, this));  
-		}
-		SchedulePeerTestsCleanupTimer ();	
-		ScheduleIntroducersUpdateTimer (); // wait for 30 seconds and decide if we need introducers
-	}
-
-	void SSUServer::Stop ()
-	{
-		DeleteAllSessions ();
-		m_IsRunning = false;
-		m_Service.stop ();
-		m_Socket.close ();
-		m_ServiceV6.stop ();
-		m_SocketV6.close ();
-		m_ReceiversService.stop ();
-		if (m_ReceiversThread)
-		{	
-			m_ReceiversThread->join (); 
-			delete m_ReceiversThread;
-			m_ReceiversThread = nullptr;
-		}
-		if (m_Thread)
-		{	
-			m_Thread->join (); 
-			delete m_Thread;
-			m_Thread = nullptr;
-		}
-		if (m_ThreadV6)
-		{	
-			m_ThreadV6->join (); 
-			delete m_ThreadV6;
-			m_ThreadV6 = nullptr;
-		}
-	}
-
-	void SSUServer::Run () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_Service.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU: server runtime exception: ", ex.what ());
-			}	
-		}	
-	}
-
-	void SSUServer::RunV6 () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_ServiceV6.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU: v6 server runtime exception: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void SSUServer::RunReceivers () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_ReceiversService.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU: receivers runtime exception: ", ex.what ());
-			}	
-		}	
-	}	
-	
-	void SSUServer::AddRelay (uint32_t tag, const boost::asio::ip::udp::endpoint& relay)
-	{
-		m_Relays[tag] = relay;
-	}	
-
-	std::shared_ptr<SSUSession> SSUServer::FindRelaySession (uint32_t tag)
-	{
-		auto it = m_Relays.find (tag);
-		if (it != m_Relays.end ())
-			return FindSession (it->second);
-		return nullptr;
-	}
-
-	void SSUServer::Send (const uint8_t * buf, size_t len, const boost::asio::ip::udp::endpoint& to)
-	{
-		if (to.protocol () == boost::asio::ip::udp::v4()) 
-			m_Socket.send_to (boost::asio::buffer (buf, len), to);
-		else
-			m_SocketV6.send_to (boost::asio::buffer (buf, len), to);
-	}	
-
-	void SSUServer::Receive ()
-	{
-		SSUPacket * packet = new SSUPacket ();
-		m_Socket.async_receive_from (boost::asio::buffer (packet->buf, SSU_MTU_V4), packet->from,
-			std::bind (&SSUServer::HandleReceivedFrom, this, std::placeholders::_1, std::placeholders::_2, packet)); 
-	}
-
-	void SSUServer::ReceiveV6 ()
-	{
-		SSUPacket * packet = new SSUPacket ();
-		m_SocketV6.async_receive_from (boost::asio::buffer (packet->buf, SSU_MTU_V6), packet->from,
-			std::bind (&SSUServer::HandleReceivedFromV6, this, std::placeholders::_1, std::placeholders::_2, packet)); 
-	}	
-
-	void SSUServer::HandleReceivedFrom (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet)
-	{
-		if (!ecode)
-		{
-			packet->len = bytes_transferred;
-			std::vector<SSUPacket *> packets;
-			packets.push_back (packet);
-
-			boost::system::error_code ec;
-			size_t moreBytes = m_Socket.available(ec);
-			while (moreBytes && packets.size () < 25)
-			{
-				packet = new SSUPacket ();
-				packet->len = m_Socket.receive_from (boost::asio::buffer (packet->buf, SSU_MTU_V4), packet->from);
-				packets.push_back (packet);
-				moreBytes = m_Socket.available();
-			}
-
-			m_Service.post (std::bind (&SSUServer::HandleReceivedPackets, this, packets, &m_Sessions));
-			Receive ();
-		}
-		else
-		{	
-			LogPrint (eLogError, "SSU: receive error: ", ecode.message ());
-			delete packet;
-		}	
-	}
-
-	void SSUServer::HandleReceivedFromV6 (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet)
-	{
-		if (!ecode)
-		{
-			packet->len = bytes_transferred;
-			std::vector<SSUPacket *> packets;
-			packets.push_back (packet);
-
-			size_t moreBytes = m_SocketV6.available ();
-			while (moreBytes && packets.size () < 25)
-			{
-				packet = new SSUPacket ();
-				packet->len = m_SocketV6.receive_from (boost::asio::buffer (packet->buf, SSU_MTU_V6), packet->from);
-				packets.push_back (packet);
-				moreBytes = m_SocketV6.available();
-			}
-
-			m_ServiceV6.post (std::bind (&SSUServer::HandleReceivedPackets, this, packets, &m_SessionsV6));
-			ReceiveV6 ();
-		}
-		else
-		{	
-			LogPrint (eLogError, "SSU: v6 receive error: ", ecode.message ());
-			delete packet;
-		}	
-	}
-
-	void SSUServer::HandleReceivedPackets (std::vector<SSUPacket *> packets, 
-		std::map<boost::asio::ip::udp::endpoint, std::shared_ptr<SSUSession> > * sessions)
-	{
-		std::shared_ptr<SSUSession> session;	
-		for (auto it1: packets)
-		{
-			auto packet = it1;
-			try
-			{	
-				if (!session || session->GetRemoteEndpoint () != packet->from) // we received packet for other session than previous
-				{
-					if (session) session->FlushData ();
-					auto it = sessions->find (packet->from);
-					if (it != sessions->end ())
-						session = it->second;
-					if (!session)
-					{
-						session = std::make_shared<SSUSession> (*this, packet->from);
-						session->WaitForConnect ();
-						(*sessions)[packet->from] = session;
-						LogPrint (eLogInfo, "SSU: new session from ", packet->from.address ().to_string (), ":", packet->from.port (), " created");
-					}
-				}
-				session->ProcessNextMessage (packet->buf, packet->len, packet->from);
-			}	
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU: HandleReceivedPackets ", ex.what ());
-				if (session) session->FlushData ();
-				session = nullptr;
-			}	
-			delete packet;
-		}
-		if (session) session->FlushData ();
-	}
-
-	std::shared_ptr<SSUSession> SSUServer::FindSession (std::shared_ptr<const i2p::data::RouterInfo> router) const
-	{
-		if (!router) return nullptr;
-		auto address = router->GetSSUAddress (true); // v4 only
- 		if (!address) return nullptr;
-		auto session = FindSession (boost::asio::ip::udp::endpoint (address->host, address->port));
-		if (session || !context.SupportsV6 ())
-			return session;
-		// try v6
-		address = router->GetSSUV6Address (); 
-		if (!address) return nullptr;
-		return FindSession (boost::asio::ip::udp::endpoint (address->host, address->port));
-	}	
-
-	std::shared_ptr<SSUSession> SSUServer::FindSession (const boost::asio::ip::udp::endpoint& e) const
-	{
-		auto& sessions = e.address ().is_v6 () ?  m_SessionsV6 : m_Sessions; 
-		auto it = sessions.find (e);
-		if (it != sessions.end ())
-			return it->second;
-		else
-			return nullptr;
-	}
-	
-	void SSUServer::CreateSession (std::shared_ptr<const i2p::data::RouterInfo> router, bool peerTest)
-	{
-		auto address = router->GetSSUAddress (!context.SupportsV6 ());
-		if (address)
-			CreateSession (router, address->host, address->port, peerTest);
-		else
-			LogPrint (eLogWarning, "SSU: Router ", i2p::data::GetIdentHashAbbreviation (router->GetIdentHash ()), " doesn't have SSU address");
-	}
-	
-	void SSUServer::CreateSession (std::shared_ptr<const i2p::data::RouterInfo> router,
-		const boost::asio::ip::address& addr, int port, bool peerTest)
-	{
-		if (router)
-		{
-			if (router->UsesIntroducer ())
-				m_Service.post (std::bind (&SSUServer::CreateSessionThroughIntroducer, this, router, peerTest)); // always V4 thread
-			else
-			{
-				boost::asio::ip::udp::endpoint remoteEndpoint (addr, port);
-				auto& s = addr.is_v6 () ? m_ServiceV6 : m_Service;
-				s.post (std::bind (&SSUServer::CreateDirectSession, this, router, remoteEndpoint, peerTest));
-			}
-		}
-	}
-
-	void SSUServer::CreateDirectSession (std::shared_ptr<const i2p::data::RouterInfo> router, boost::asio::ip::udp::endpoint remoteEndpoint, bool peerTest)
-	{	
-		auto& sessions = remoteEndpoint.address ().is_v6 () ? m_SessionsV6 : m_Sessions;	
-		auto it = sessions.find (remoteEndpoint);
-		if (it != sessions.end ())
-		{	
-			auto session = it->second;
-			if (peerTest && session->GetState () == eSessionStateEstablished)
-				session->SendPeerTest ();
-		}	
-		else
-		{
-			// otherwise create new session					
-			auto session = std::make_shared<SSUSession> (*this, remoteEndpoint, router, peerTest);
-			sessions[remoteEndpoint] = session;
-			// connect 					
-			LogPrint (eLogInfo, "SSU: Creating new session to [", i2p::data::GetIdentHashAbbreviation (router->GetIdentHash ()), "] ",
-				remoteEndpoint.address ().to_string (), ":", remoteEndpoint.port ());
-			session->Connect ();
-		}
-	}
-	
-	void SSUServer::CreateSessionThroughIntroducer (std::shared_ptr<const i2p::data::RouterInfo> router, bool peerTest)
-	{
-		if (router && router->UsesIntroducer ())
-		{
-			auto address = router->GetSSUAddress (true); // v4 only for now
-			if (address)
-			{
-				boost::asio::ip::udp::endpoint remoteEndpoint (address->host, address->port);
-				auto it = m_Sessions.find (remoteEndpoint);
-				// check if session if presented alredy
-				if (it != m_Sessions.end ())
-				{	
-					auto session = it->second;
-					if (peerTest && session->GetState () == eSessionStateEstablished)
-						session->SendPeerTest ();
-					return; 
-				}		
-				// create new session					
-				int numIntroducers = address->introducers.size ();
-				if (numIntroducers > 0)
-				{
-					std::shared_ptr<SSUSession> introducerSession;
-					const i2p::data::RouterInfo::Introducer * introducer = nullptr;
-					// we might have a session to introducer already
-					for (int i = 0; i < numIntroducers; i++)
-					{
-						auto intr = &(address->introducers[i]);
-						boost::asio::ip::udp::endpoint ep (intr->iHost, intr->iPort);
-						if (ep.address ().is_v4 ()) // ipv4 only
-						{	
-							if (!introducer) introducer = intr; // we pick first one for now
-							it = m_Sessions.find (ep); 
-							if (it != m_Sessions.end ())
-							{
-								introducerSession = it->second;
-								break; 
-							}	
-						}
-					}
-					if (!introducer)
-					{
-						LogPrint (eLogWarning, "SSU: Can't connect to unreachable router and no ipv4 introducers present");
-						return;
-					}				
-
-					if (introducerSession) // session found 
-						LogPrint (eLogInfo, "SSU: Session to introducer already exists");
-					else // create new
-					{
-						LogPrint (eLogInfo, "SSU: Creating new session to introducer");
-						boost::asio::ip::udp::endpoint introducerEndpoint (introducer->iHost, introducer->iPort);
-						introducerSession = std::make_shared<SSUSession> (*this, introducerEndpoint, router);
-						m_Sessions[introducerEndpoint] = introducerSession;													
-					}
-					// create session	
-					auto session = std::make_shared<SSUSession> (*this, remoteEndpoint, router, peerTest);
-					m_Sessions[remoteEndpoint] = session;
-					// introduce
-					LogPrint (eLogInfo, "SSU: Introduce new session to [", i2p::data::GetIdentHashAbbreviation (router->GetIdentHash ()),
-							"] through introducer ", introducer->iHost, ":", introducer->iPort);
-					session->WaitForIntroduction ();	
-					if (i2p::context.GetRouterInfo ().UsesIntroducer ()) // if we are unreachable
-					{
-						uint8_t buf[1];
-						Send (buf, 0, remoteEndpoint); // send HolePunch
-					}	
-					introducerSession->Introduce (*introducer, router);
-				}
-				else	
-					LogPrint (eLogWarning, "SSU: Can't connect to unreachable router and no introducers present");
-			}
-			else
-				LogPrint (eLogWarning, "SSU: Router ", i2p::data::GetIdentHashAbbreviation (router->GetIdentHash ()), " doesn't have SSU address");
-		}
-	}
-
-	void SSUServer::DeleteSession (std::shared_ptr<SSUSession> session)
-	{
-		if (session)
-		{
-			session->Close ();
-			auto& ep = session->GetRemoteEndpoint ();
-			if (ep.address ().is_v6 ())
-				m_SessionsV6.erase (ep);
-			else
-				m_Sessions.erase (ep);
-		}	
-	}	
-
-	void SSUServer::DeleteAllSessions ()
-	{
-		for (auto it: m_Sessions)
-			it.second->Close ();
-		m_Sessions.clear ();
-
-		for (auto it: m_SessionsV6)
-			it.second->Close ();
-		m_SessionsV6.clear ();
-	}
-
-	template<typename Filter>
-	std::shared_ptr<SSUSession> SSUServer::GetRandomV4Session (Filter filter) // v4 only
-	{
-		std::vector<std::shared_ptr<SSUSession> > filteredSessions;
-		for (auto s :m_Sessions)
-			if (filter (s.second)) filteredSessions.push_back (s.second);
-		if (filteredSessions.size () > 0)
-		{
-			auto ind = rand () % filteredSessions.size ();
-			return filteredSessions[ind];
-		}
-		return nullptr;	
-	}
-
-	std::shared_ptr<SSUSession> SSUServer::GetRandomEstablishedV4Session (std::shared_ptr<const SSUSession> excluded) // v4 only
-	{
-		return GetRandomV4Session (
-			[excluded](std::shared_ptr<SSUSession> session)->bool 
-			{ 
-				return session->GetState () == eSessionStateEstablished && !session->IsV6 () && 
-					session != excluded; 
-			}
-								);
-	}
-
-	std::set<SSUSession *> SSUServer::FindIntroducers (int maxNumIntroducers)
-	{
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		std::set<SSUSession *> ret;
-		for (int i = 0; i < maxNumIntroducers; i++)
-		{
-			auto session = GetRandomV4Session (
-				[&ret, ts](std::shared_ptr<SSUSession> session)->bool 
-				{ 
-					return session->GetRelayTag () && !ret.count (session.get ()) &&
-						session->GetState () == eSessionStateEstablished &&
-						ts < session->GetCreationTime () + SSU_TO_INTRODUCER_SESSION_DURATION; 
-				}
-											);	
-			if (session)
-			{
-				ret.insert (session.get ());
-				break;
-			}	
-		}
-		return ret;
-	}
-
-	void SSUServer::ScheduleIntroducersUpdateTimer ()
-	{
-		m_IntroducersUpdateTimer.expires_from_now (boost::posix_time::seconds(SSU_KEEP_ALIVE_INTERVAL));
-		m_IntroducersUpdateTimer.async_wait (std::bind (&SSUServer::HandleIntroducersUpdateTimer,
-			this, std::placeholders::_1));	
-	}
-
-	void SSUServer::HandleIntroducersUpdateTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			// timeout expired
-			if (i2p::context.GetStatus () == eRouterStatusTesting)
-			{
-				// we still don't know if we need introducers
-				ScheduleIntroducersUpdateTimer ();
-				return;
-			}	
-			if (i2p::context.GetStatus () == eRouterStatusOK) return; // we don't need introducers anymore
-			// we are firewalled
-			if (!i2p::context.IsUnreachable ()) i2p::context.SetUnreachable ();
-			std::list<boost::asio::ip::udp::endpoint> newList;
-			size_t numIntroducers = 0;
-			uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-			for (auto it :m_Introducers)
-			{	
-				auto session = FindSession (it);
-				if (session && ts < session->GetCreationTime () + SSU_TO_INTRODUCER_SESSION_DURATION)
-				{
-					session->SendKeepAlive ();
-					newList.push_back (it);
-					numIntroducers++;
-				}
-				else	
-					i2p::context.RemoveIntroducer (it);
-			}
-
-			if (numIntroducers < SSU_MAX_NUM_INTRODUCERS)
-			{
-				// create new
-				auto introducers = FindIntroducers (SSU_MAX_NUM_INTRODUCERS);
-				if (introducers.size () > 0)
-				{
-					for (auto it1: introducers)
-					{
-						auto& ep = it1->GetRemoteEndpoint ();
-						i2p::data::RouterInfo::Introducer introducer;
-						introducer.iHost = ep.address ();
-						introducer.iPort = ep.port ();
-						introducer.iTag = it1->GetRelayTag ();
-						introducer.iKey = it1->GetIntroKey ();
-						if (i2p::context.AddIntroducer (introducer))
-						{	
-							newList.push_back (ep);
-							if (newList.size () >= SSU_MAX_NUM_INTRODUCERS) break;
-						}	
-					}	
-				}	
-			}	
-			m_Introducers = newList;
-			if (m_Introducers.size () < SSU_MAX_NUM_INTRODUCERS)
-			{
-				auto introducer = i2p::data::netdb.GetRandomIntroducer ();
-				if (introducer)
-					CreateSession (introducer);
-			}	
-			ScheduleIntroducersUpdateTimer ();
-		}	
-	}
-
-	void SSUServer::NewPeerTest (uint32_t nonce, PeerTestParticipant role, std::shared_ptr<SSUSession> session)
-	{
-		m_PeerTests[nonce] = { i2p::util::GetMillisecondsSinceEpoch (), role, session };
-	}
-
-	PeerTestParticipant SSUServer::GetPeerTestParticipant (uint32_t nonce)
-	{
-		auto it = m_PeerTests.find (nonce);
-		if (it != m_PeerTests.end ())
-			return it->second.role;
-		else
-			return ePeerTestParticipantUnknown;
-	}	
-
-	std::shared_ptr<SSUSession> SSUServer::GetPeerTestSession (uint32_t nonce)
-	{
-		auto it = m_PeerTests.find (nonce);
-		if (it != m_PeerTests.end ())
-			return it->second.session;
-		else
-			return nullptr;
-	}
-
-	void SSUServer::UpdatePeerTest (uint32_t nonce, PeerTestParticipant role)
-	{
-		auto it = m_PeerTests.find (nonce);
-		if (it != m_PeerTests.end ())
-			it->second.role = role;
-	}	
-	
-	void SSUServer::RemovePeerTest (uint32_t nonce)
-	{
-		m_PeerTests.erase (nonce);
-	}	
-
-	void SSUServer::SchedulePeerTestsCleanupTimer ()
-	{
-		m_PeerTestsCleanupTimer.expires_from_now (boost::posix_time::seconds(SSU_PEER_TEST_TIMEOUT));
-		m_PeerTestsCleanupTimer.async_wait (std::bind (&SSUServer::HandlePeerTestsCleanupTimer,
-			this, std::placeholders::_1));	
-	}
-
-	void SSUServer::HandlePeerTestsCleanupTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			int numDeleted = 0;	
-			uint64_t ts = i2p::util::GetMillisecondsSinceEpoch ();	
-			for (auto it = m_PeerTests.begin (); it != m_PeerTests.end ();)
-			{
-				if (ts > it->second.creationTime + SSU_PEER_TEST_TIMEOUT*1000LL)
-				{
-					numDeleted++;
-					it = m_PeerTests.erase (it);
-				}
-				else
-					it++;	 
-			}
-			if (numDeleted > 0)
-				LogPrint (eLogDebug, "SSU: ", numDeleted, " peer tests have been expired");
-			SchedulePeerTestsCleanupTimer ();
-		}
-	}
-}
-}
-

Signature.cpp

@@ -1,486 +0,0 @@
-#include <memory>
-#include "Log.h"
-#include "Signature.h"
-
-namespace i2p
-{
-namespace crypto
-{
-	class Ed25519
-	{
-		public:
-
-			Ed25519 ()
-			{
-				BN_CTX * ctx = BN_CTX_new ();
-				BIGNUM * tmp = BN_new ();
-
-				q = BN_new ();
-				// 2^255-19				
-				BN_set_bit (q, 255); // 2^255 
-				BN_sub_word (q, 19);
-				
-				l = BN_new ();
-				// 2^252 + 27742317777372353535851937790883648493
-				BN_set_bit (l, 252);
-				two_252_2 = BN_dup (l);
-				BN_dec2bn (&tmp, "27742317777372353535851937790883648493");
-				BN_add (l, l, tmp);		
-				BN_sub_word (two_252_2, 2); // 2^252 - 2		
-
-				 // -121665*inv(121666)
-				d = BN_new ();
-				BN_set_word (tmp, 121666);
-				BN_mod_inverse (tmp, tmp, q, ctx);	
-				BN_set_word (d, 121665);
-				BN_set_negative (d, 1);							
-				BN_mul (d, d, tmp, ctx);
-
-				// 2^((q-1)/4)
-				I = BN_new ();
-				BN_free (tmp);
-				tmp = BN_dup (q);
-				BN_sub_word (tmp, 1);
-				BN_div_word (tmp, 4);	
-				BN_set_word (I, 2);
-				BN_mod_exp (I, I, tmp, q, ctx);
-				BN_free (tmp);	
-				
-				// 4*inv(5)	
-				BIGNUM * By = BN_new ();		
-				BN_set_word (By, 5);
-				BN_mod_inverse (By, By, q, ctx);	
-				BN_mul_word (By, 4);
-				BIGNUM * Bx = RecoverX (By, ctx);	
-				BN_mod (Bx, Bx, q, ctx); // % q
-				BN_mod (By, By, q, ctx); // % q										
-			
-				// precalculate Bi256 table
-				Bi256Carry = { Bx, By };  // B
-				for (int i = 0; i < 32; i++)
-				{
-					Bi256[i][0] = Bi256Carry; // first point
-					for (int j = 1; j < 128; j++)
-						Bi256[i][j] = Sum (Bi256[i][j-1], Bi256[i][0], ctx); // (256+j+1)^i*B
-					Bi256Carry = Bi256[i][127];
-					for (int j = 0; j < 128; j++) // add first point 128 more times
-						Bi256Carry = Sum (Bi256Carry, Bi256[i][0], ctx);
-				}
-
-				BN_CTX_free (ctx);
-			}
-
-			Ed25519 (const Ed25519& other): q (BN_dup (other.q)), l (BN_dup (other.l)), 
-				d (BN_dup (other.d)), I (BN_dup (other.I)), two_252_2 (BN_dup (other.two_252_2)),
-				Bi256Carry (other.Bi256Carry)
-			{
-				for (int i = 0; i < 32; i++)
-					for (int j = 0; j < 128; j++)
-						Bi256[i][j] = other.Bi256[i][j];
-			}
-
-			~Ed25519 ()
-			{
-				BN_free (q);
-				BN_free (l);
-				BN_free (d);
-				BN_free (I);
-				BN_free (two_252_2);
-			}
-
-
-			EDDSAPoint GeneratePublicKey (const uint8_t * expandedPrivateKey, BN_CTX * ctx) const
-			{
-				return MulB (expandedPrivateKey, ctx); // left half of expanded key, considered as Little Endian
-			}
-
-			EDDSAPoint DecodePublicKey (const uint8_t * buf, BN_CTX * ctx) const
-			{
-				return DecodePoint (buf, ctx);
-			}
-
-			void EncodePublicKey (const EDDSAPoint& publicKey, uint8_t * buf, BN_CTX * ctx) const
-			{
-				EncodePoint (Normalize (publicKey, ctx), buf);
-			}
-
-			bool Verify (const EDDSAPoint& publicKey, const uint8_t * digest, const uint8_t * signature) const
-			{
-				BN_CTX * ctx = BN_CTX_new ();	
-				BIGNUM * h = DecodeBN<64> (digest);
-				// signature 0..31 - R, 32..63 - S 
-				// B*S = R + PK*h => R = B*S - PK*h
-				// we don't decode R, but encode (B*S - PK*h)
-				auto Bs = MulB (signature + EDDSA25519_SIGNATURE_LENGTH/2, ctx); // B*S;
-				BN_mod (h, h, l, ctx); // public key is multiple of B, but B%l = 0
-				auto PKh = Mul (publicKey, h, ctx); // PK*h
-				uint8_t diff[32];
-				EncodePoint (Normalize (Sum (Bs, -PKh, ctx), ctx), diff); // Bs - PKh encoded
-				bool passed = !memcmp (signature, diff, 32); // R
-				BN_free (h); 
-				BN_CTX_free (ctx);
-				if (!passed)
-					LogPrint (eLogError, "25519 signature verification failed");
-				return passed; 
-			}
-
-			void Sign (const uint8_t * expandedPrivateKey, const uint8_t * publicKeyEncoded, const uint8_t * buf, size_t len, 
-				uint8_t * signature) const
-			{
-				BN_CTX * bnCtx = BN_CTX_new ();
-				// calculate r
-				SHA512_CTX ctx;
-				SHA512_Init (&ctx);
-				SHA512_Update (&ctx, expandedPrivateKey + EDDSA25519_PRIVATE_KEY_LENGTH, EDDSA25519_PRIVATE_KEY_LENGTH); // right half of expanded key
-				SHA512_Update (&ctx, buf, len); // data
-				uint8_t digest[64];
-				SHA512_Final (digest, &ctx);
-				BIGNUM * r = DecodeBN<32> (digest); // DecodeBN<64> (digest); // for test vectors
-				// calculate R
-				uint8_t R[EDDSA25519_SIGNATURE_LENGTH/2]; // we must use separate buffer because signature might be inside buf
-				EncodePoint (Normalize (MulB (digest, bnCtx), bnCtx), R); // EncodePoint (Mul (B, r, bnCtx), R); // for test vectors 
-				// calculate S
-				SHA512_Init (&ctx);
-				SHA512_Update (&ctx, R, EDDSA25519_SIGNATURE_LENGTH/2); // R
-				SHA512_Update (&ctx, publicKeyEncoded, EDDSA25519_PUBLIC_KEY_LENGTH); // public key
-				SHA512_Update (&ctx, buf, len); // data
-				SHA512_Final (digest, &ctx);
-				BIGNUM * h = DecodeBN<64> (digest);			
-				// S = (r + h*a) % l
-				BIGNUM * a = DecodeBN<EDDSA25519_PRIVATE_KEY_LENGTH> (expandedPrivateKey); // left half of expanded key
-				BN_mod_mul (h, h, a, l, bnCtx); // %l
-				BN_mod_add (h, h, r, l, bnCtx); // %l
-				memcpy (signature, R, EDDSA25519_SIGNATURE_LENGTH/2);
-				EncodeBN (h, signature + EDDSA25519_SIGNATURE_LENGTH/2, EDDSA25519_SIGNATURE_LENGTH/2); // S
-				BN_free (r); BN_free (h); BN_free (a);
-				BN_CTX_free (bnCtx);
-			}
-
-		private:		
-
-			EDDSAPoint Sum (const EDDSAPoint& p1, const EDDSAPoint& p2, BN_CTX * ctx) const
-			{
-				// x3 = (x1*y2+y1*x2)*(z1*z2-d*t1*t2)
-				// y3 = (y1*y2+x1*x2)*(z1*z2+d*t1*t2)
-				// z3 = (z1*z2-d*t1*t2)*(z1*z2+d*t1*t2)
-				// t3 = (y1*y2+x1*x2)*(x1*y2+y1*x2)
-				BIGNUM * x3 = BN_new (), * y3 = BN_new (), * z3 = BN_new (), * t3 = BN_new ();
-				
-				BN_mul (x3, p1.x, p2.x, ctx); // A = x1*x2		
-				BN_mul (y3, p1.y, p2.y, ctx); // B = y1*y2	
-				
-				BIGNUM * t1 = p1.t, * t2 = p2.t;
-				if (!t1) { t1 = BN_new (); BN_mul (t1, p1.x, p1.y, ctx); }
-				if (!t2) { t2 = BN_new (); BN_mul (t2, p2.x, p2.y, ctx); }
-				BN_mul (t3, t1, t2, ctx);
-				BN_mul (t3, t3, d, ctx);  // C = d*t1*t2
-				if (!p1.t) BN_free (t1);
-				if (!p2.t) BN_free (t2);
-
-				if (p1.z)
-				{
-					if (p2.z)
-						BN_mul (z3, p1.z, p2.z, ctx); // D = z1*z2
-					else
-						BN_copy (z3, p1.z); // D = z1
-				}
-				else
-				{
-					if (p2.z)
-						BN_copy (z3, p2.z); // D = z2
-					else
-						BN_one (z3); // D = 1
-				}	
-
-				BIGNUM * E = BN_new (), * F = BN_new (), * G = BN_new (), * H = BN_new ();
-				BN_add (E, p1.x, p1.y);				
-				BN_add (F, p2.x, p2.y);
-				BN_mul (E, E, F, ctx); // (x1 + y1)*(x2 + y2)
-				BN_sub (E, E, x3);
-				BN_sub (E, E, y3); // E = (x1 + y1)*(x2 + y2) - A - B
-				BN_sub (F, z3, t3); // F = D - C
-				BN_add (G, z3, t3); // G = D + C
-				BN_add (H, y3, x3); // H = B + A
-
-				BN_mod_mul (x3, E, F, q, ctx); // x3 = E*F
-				BN_mod_mul (y3, G, H, q, ctx); // y3 = G*H	
-				BN_mod_mul (z3, F, G, q, ctx); // z3 = F*G	
-				BN_mod_mul (t3, E, H, q, ctx); // t3 = E*H	
-
-				BN_free (E); BN_free (F); BN_free (G); BN_free (H);
-
-				return EDDSAPoint {x3, y3, z3, t3};
-			}
-
-			EDDSAPoint Double (const EDDSAPoint& p, BN_CTX * ctx) const
-			{
-				BIGNUM * x2 = BN_new (), * y2 = BN_new (), * z2 = BN_new (), * t2 = BN_new ();
-				
-				BN_sqr (x2, p.x, ctx); // x2 = A = x^2		
-				BN_sqr (y2, p.y, ctx); // y2 = B = y^2	
-				if (p.t)
-					BN_sqr (t2, p.t, ctx); // t2 = t^2
-				else
-				{
-					BN_mul (t2, p.x, p.y, ctx); // t = x*y
-					BN_sqr (t2, t2, ctx);  // t2 = t^2
-				}	
-				BN_mul (t2, t2, d, ctx);  // t2 = C = d*t^2 	
-				if (p.z)
-					BN_sqr (z2, p.z, ctx); // z2 = D = z^2 		
-				else
-					BN_one (z2); // z2 = 1
-
-				BIGNUM * E = BN_new (), * F = BN_new (), * G = BN_new (), * H = BN_new ();
-				// E = (x+y)*(x+y)-A-B = x^2+y^2+2xy-A-B = 2xy
-				BN_mul (E, p.x, p.y, ctx);
-				BN_lshift1 (E, E);	// E =2*x*y							
-				BN_sub (F, z2, t2); // F = D - C
-				BN_add (G, z2, t2); // G = D + C 
-				BN_add (H, y2, x2); // H = B + A
-
-				BN_mod_mul (x2, E, F, q, ctx); // x2 = E*F
-				BN_mod_mul (y2, G, H, q, ctx); // y2 = G*H	
-				BN_mod_mul (z2, F, G, q, ctx); // z2 = F*G	
-				BN_mod_mul (t2, E, H, q, ctx); // t2 = E*H	
-
-				BN_free (E); BN_free (F); BN_free (G); BN_free (H);
-
-				return EDDSAPoint {x2, y2, z2, t2};
-			}
-			
-			EDDSAPoint Mul (const EDDSAPoint& p, const BIGNUM * e, BN_CTX * ctx) const
-			{
-				BIGNUM * zero = BN_new (), * one = BN_new ();
-				BN_zero (zero); BN_one (one);
-				EDDSAPoint res {zero, one};
-				if (!BN_is_zero (e))
-				{
-					int bitCount = BN_num_bits (e);
-					for (int i = bitCount - 1; i >= 0; i--)
-					{
-						res = Double (res, ctx);
-						if (BN_is_bit_set (e, i)) res = Sum (res, p, ctx);
-					}
-				}	
-				return res;
-			} 
-			
-			EDDSAPoint MulB (const uint8_t * e, BN_CTX * ctx) const // B*e, e is 32 bytes Little Endian
-			{
-				BIGNUM * zero = BN_new (), * one = BN_new ();
-				BN_zero (zero); BN_one (one);
-				EDDSAPoint res {zero, one};
-				bool carry = false;
-				for (int i = 0; i < 32; i++)
-				{
-					uint8_t x = e[i];
-					if (carry) 
-					{ 
-						if (x < 255) 
-						{ 
-							x++; 
-							carry = false;
-						} 
-						else 
-							x = 0; 
-					}
-					if (x > 0)
-					{
-						if (x <= 128)
-							res = Sum (res, Bi256[i][x-1], ctx);
-						else
-						{
-							res = Sum (res, -Bi256[i][255-x], ctx); // -Bi[256-x]
-							carry = true;
-						}		
-					}
-				}
-				if (carry) res = Sum (res, Bi256Carry, ctx);
-				return res;
-			}
-
-			EDDSAPoint Normalize (const EDDSAPoint& p, BN_CTX * ctx) const
-			{
-				if (p.z)
-				{
-					BIGNUM * x = BN_new (), * y = BN_new ();
-					BN_mod_inverse (y, p.z, q, ctx);
-					BN_mod_mul (x, p.x, y, q, ctx); // x = x/z
-					BN_mod_mul (y, p.y, y, q, ctx); // y = y/z
-					return  EDDSAPoint{x, y};
-				}
-				else
-					return EDDSAPoint{BN_dup (p.x), BN_dup (p.y)};
-			}
-
-			bool IsOnCurve (const EDDSAPoint& p, BN_CTX * ctx) const
-			{
-				BIGNUM * x2 = BN_new ();
-				BN_sqr (x2, p.x, ctx); // x^2
-				BIGNUM * y2 = BN_new ();
-				BN_sqr (y2, p.y, ctx); // y^2
-				// y^2 - x^2 - 1 - d*x^2*y^2 
-				BIGNUM * tmp = BN_new ();				
-				BN_mul (tmp, d, x2, ctx);
-				BN_mul (tmp, tmp, y2, ctx);	
-				BN_sub (tmp, y2, tmp);
-				BN_sub (tmp, tmp, x2);
-				BN_sub_word (tmp, 1);
-				BN_mod (tmp, tmp, q, ctx); // % q
-				bool ret = BN_is_zero (tmp);
-				BN_free (x2);
-				BN_free (y2);
-				BN_free (tmp);
-				return ret;
-			}	
-
-			BIGNUM * RecoverX (const BIGNUM * y, BN_CTX * ctx) const
-			{
-				BIGNUM * y2 = BN_new ();
-				BN_sqr (y2, y, ctx); // y^2
-				// xx = (y^2 -1)*inv(d*y^2 +1) 
-				BIGNUM * xx = BN_new ();
-				BN_mul (xx, d, y2, ctx);
-				BN_add_word (xx, 1);
-				BN_mod_inverse (xx, xx, q, ctx);
-				BN_sub_word (y2, 1);
-				BN_mul (xx, y2, xx, ctx);
-				// x = srqt(xx) = xx^(2^252-2)		
-				BIGNUM * x = BN_new ();
-				BN_mod_exp (x, xx, two_252_2, q, ctx);
-				// check (x^2 -xx) % q	
-				BN_sqr (y2, x, ctx);
-				BN_mod_sub (y2, y2, xx, q, ctx); 
-				if (!BN_is_zero (y2))
-					BN_mod_mul (x, x, I, q, ctx);
-				if (BN_is_odd (x))
-					BN_sub (x, q, x);
-				BN_free (y2);
-				BN_free (xx);
-				return x;
-			}
-
-			EDDSAPoint DecodePoint (const uint8_t * buf, BN_CTX * ctx) const
-			{
-				// buf is 32 bytes Little Endian, convert it to Big Endian
-				uint8_t buf1[EDDSA25519_PUBLIC_KEY_LENGTH];
-				for (size_t i = 0; i < EDDSA25519_PUBLIC_KEY_LENGTH/2; i++) // invert bytes
-				{
-					buf1[i] = buf[EDDSA25519_PUBLIC_KEY_LENGTH -1 - i];
-					buf1[EDDSA25519_PUBLIC_KEY_LENGTH -1 - i] = buf[i];
-				}
-				bool isHighestBitSet = buf1[0] & 0x80;
-				if (isHighestBitSet)
-					buf1[0] &= 0x7f; // clear highest bit
-				BIGNUM * y = BN_new ();
-				BN_bin2bn (buf1, EDDSA25519_PUBLIC_KEY_LENGTH, y);
-				auto x = RecoverX (y, ctx);
-				if (BN_is_bit_set (x, 0) != isHighestBitSet)
-					BN_sub (x, q, x); // x = q - x 
-				BIGNUM * z = BN_new (), * t = BN_new (); 
-				BN_one (z); BN_mod_mul (t, x, y, q, ctx); // pre-calculate t
-				EDDSAPoint p {x, y, z, t};
-				if (!IsOnCurve (p, ctx)) 
-					LogPrint (eLogError, "Decoded point is not on 25519");
-				return p;
-			}
-			
-			void EncodePoint (const EDDSAPoint& p, uint8_t * buf) const
-			{
-				EncodeBN (p.y, buf,EDDSA25519_PUBLIC_KEY_LENGTH); 
-				if (BN_is_bit_set (p.x, 0)) // highest bit
-					buf[EDDSA25519_PUBLIC_KEY_LENGTH - 1] |= 0x80; // set highest bit
-			}
-
-			template<int len>
-			BIGNUM * DecodeBN (const uint8_t * buf) const
-			{
-				// buf is Little Endian convert it to Big Endian
-				uint8_t buf1[len];
-				for (size_t i = 0; i < len/2; i++) // invert bytes
-				{
-					buf1[i] = buf[len -1 - i];
-					buf1[len -1 - i] = buf[i];
-				}
-				BIGNUM * res = BN_new ();
-				BN_bin2bn (buf1, len, res);
-				return res;
-			}
-
-			void EncodeBN (const BIGNUM * bn, uint8_t * buf, size_t len) const
-			{
-				bn2buf (bn, buf, len);
-				// To Little Endian
-				for (size_t i = 0; i < len/2; i++) // invert bytes
-				{
-					uint8_t tmp = buf[i];
-					buf[i] = buf[len -1 - i];
-					buf[len -1 - i] = tmp;
-				}	
-			}
-
-		private:
-			
-			BIGNUM * q, * l, * d, * I; 
-			// transient values
-			BIGNUM * two_252_2; // 2^252-2
-			EDDSAPoint Bi256[32][128]; // per byte, Bi256[i][j] = (256+j+1)^i*B, we don't store zeroes
-			// if j > 128 we use 256 - j and carry 1 to next byte
-			// Bi256[0][0] = B, base point
-			EDDSAPoint Bi256Carry; // Bi256[32][0]
-	};
-
-	static std::unique_ptr<Ed25519> g_Ed25519;
-	std::unique_ptr<Ed25519>& GetEd25519 ()
-	{
-		if (!g_Ed25519)
-			g_Ed25519.reset (new Ed25519());
-			
-		return g_Ed25519; 
-	}	
-	
-
-	EDDSA25519Verifier::EDDSA25519Verifier (const uint8_t * signingKey)
-	{
-		memcpy (m_PublicKeyEncoded, signingKey, EDDSA25519_PUBLIC_KEY_LENGTH); 
-		BN_CTX * ctx = BN_CTX_new ();
-		m_PublicKey = GetEd25519 ()->DecodePublicKey (m_PublicKeyEncoded, ctx);
-		BN_CTX_free (ctx);
-	}
-
-	bool EDDSA25519Verifier::Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const
-	{
-		uint8_t digest[64];
-		SHA512_CTX ctx;
-		SHA512_Init (&ctx);
-		SHA512_Update (&ctx, signature, EDDSA25519_SIGNATURE_LENGTH/2); // R
-		SHA512_Update (&ctx, m_PublicKeyEncoded, EDDSA25519_PUBLIC_KEY_LENGTH); // public key
-		SHA512_Update (&ctx, buf, len); // data	
-		SHA512_Final (digest, &ctx);
-		
-		return GetEd25519 ()->Verify (m_PublicKey, digest, signature);
-	}
-
-	EDDSA25519Signer::EDDSA25519Signer (const uint8_t * signingPrivateKey)
-	{ 
-		// expand key
-		SHA512 (signingPrivateKey, EDDSA25519_PRIVATE_KEY_LENGTH, m_ExpandedPrivateKey);
-		m_ExpandedPrivateKey[0] &= 0xF8; // drop last 3 bits 
-		m_ExpandedPrivateKey[EDDSA25519_PRIVATE_KEY_LENGTH - 1] &= 0x1F; // drop first 3 bits
-		m_ExpandedPrivateKey[EDDSA25519_PRIVATE_KEY_LENGTH - 1] |= 0x40; // set second bit
-		// generate and encode public key
-		BN_CTX * ctx = BN_CTX_new ();	
-		auto publicKey = GetEd25519 ()->GeneratePublicKey (m_ExpandedPrivateKey, ctx);
-		GetEd25519 ()->EncodePublicKey (publicKey, m_PublicKeyEncoded, ctx);	
-		BN_CTX_free (ctx);
-	} 
-		
-	void EDDSA25519Signer::Sign (const uint8_t * buf, int len, uint8_t * signature) const
-	{
-		GetEd25519 ()->Sign (m_ExpandedPrivateKey, m_PublicKeyEncoded, buf, len, signature);
-	}	
-}
-}
-
-

Signature.h

@@ -1,444 +0,0 @@
-#ifndef SIGNATURE_H__
-#define SIGNATURE_H__
-
-#include <inttypes.h>
-#include <string.h>
-#include <openssl/sha.h>
-#include <openssl/dsa.h>
-#include <openssl/ec.h>
-#include <openssl/ecdsa.h>
-#include <openssl/rsa.h>
-#include <openssl/rand.h>
-#include <openssl/evp.h>
-#include "Crypto.h"
-
-namespace i2p
-{
-namespace crypto
-{
-	class Verifier
-	{
-		public:
-			
-			virtual ~Verifier () {};
-			virtual bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const = 0;
-			virtual size_t GetPublicKeyLen () const = 0;
-			virtual size_t GetSignatureLen () const = 0;
-			virtual size_t GetPrivateKeyLen () const { return GetSignatureLen ()/2; };
-	};
-
-	class Signer
-	{
-		public:
-
-			virtual ~Signer () {};		
-			virtual void Sign (const uint8_t * buf, int len, uint8_t * signature) const = 0; 
-	};
-
-	const size_t DSA_PUBLIC_KEY_LENGTH = 128;
-	const size_t DSA_SIGNATURE_LENGTH = 40;	
-	const size_t DSA_PRIVATE_KEY_LENGTH = DSA_SIGNATURE_LENGTH/2;
-	class DSAVerifier: public Verifier
-	{
-		public:
-
-			DSAVerifier (const uint8_t * signingKey)
-			{
-				m_PublicKey = CreateDSA ();
-				m_PublicKey->pub_key = BN_bin2bn (signingKey, DSA_PUBLIC_KEY_LENGTH, NULL);
-			}
-
-			~DSAVerifier ()
-			{
-				DSA_free (m_PublicKey);
-			}
-			
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const
-			{
-				// calculate SHA1 digest
-				uint8_t digest[20];
-				SHA1 (buf, len, digest);
-				// signature
-				DSA_SIG * sig = DSA_SIG_new();
-				sig->r = BN_bin2bn (signature, DSA_SIGNATURE_LENGTH/2, NULL);
-				sig->s = BN_bin2bn (signature + DSA_SIGNATURE_LENGTH/2, DSA_SIGNATURE_LENGTH/2, NULL);
-				// DSA verification
-				int ret = DSA_do_verify (digest, 20, sig, m_PublicKey);
-				DSA_SIG_free(sig);
-				return ret;
-			}	
-
-			size_t GetPublicKeyLen () const { return DSA_PUBLIC_KEY_LENGTH; };
-			size_t GetSignatureLen () const { return DSA_SIGNATURE_LENGTH; };
-			
-		private:
-
-			DSA * m_PublicKey;
-	};
-
-	class DSASigner: public Signer
-	{
-		public:
-
-			DSASigner (const uint8_t * signingPrivateKey)
-			{
-				m_PrivateKey = CreateDSA ();
-				m_PrivateKey->priv_key = BN_bin2bn (signingPrivateKey, DSA_PRIVATE_KEY_LENGTH, NULL);
-			}
-
-			~DSASigner ()
-			{
-				DSA_free (m_PrivateKey);
-			}
-			
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				uint8_t digest[20];
-				SHA1 (buf, len, digest);
-				DSA_SIG * sig = DSA_do_sign (digest, 20, m_PrivateKey);
-				bn2buf (sig->r, signature, DSA_SIGNATURE_LENGTH/2);
-				bn2buf (sig->s, signature + DSA_SIGNATURE_LENGTH/2, DSA_SIGNATURE_LENGTH/2);
-				DSA_SIG_free(sig);
-			}
-
-		private:
-
-			DSA * m_PrivateKey;
-	};
-
-	inline void CreateDSARandomKeys (uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		DSA * dsa = CreateDSA ();
-		DSA_generate_key (dsa);
-		bn2buf (dsa->priv_key, signingPrivateKey, DSA_PRIVATE_KEY_LENGTH);
-		bn2buf (dsa->pub_key, signingPublicKey, DSA_PUBLIC_KEY_LENGTH);
-		DSA_free (dsa);
-		
-	}	
-
-	struct SHA256Hash
-	{	
-		static void CalculateHash (const uint8_t * buf, size_t len, uint8_t * digest)
-		{
-			SHA256 (buf, len, digest);
-		}
-
-		enum { hashLen = 32 };
-	};	
-
-	struct SHA384Hash
-	{	
-		static void CalculateHash (const uint8_t * buf, size_t len, uint8_t * digest)
-		{
-			SHA384 (buf, len, digest);
-		}
-
-		enum { hashLen = 48 };
-	};
-
-	struct SHA512Hash
-	{	
-		static void CalculateHash (const uint8_t * buf, size_t len, uint8_t * digest)
-		{
-			SHA512 (buf, len, digest);
-		}
-
-		enum { hashLen = 64 };
-	};
-	
-	template<typename Hash, int curve, size_t keyLen>
-	class ECDSAVerifier: public Verifier
-	{		
-		public:
-
-			ECDSAVerifier (const uint8_t * signingKey)
-			{
-				m_PublicKey = EC_KEY_new_by_curve_name (curve);
-				EC_KEY_set_public_key_affine_coordinates (m_PublicKey, 
-					BN_bin2bn (signingKey, keyLen/2, NULL),
-					BN_bin2bn (signingKey + keyLen/2, keyLen/2, NULL));  
-			}
-
-			~ECDSAVerifier ()
-			{
-				EC_KEY_free (m_PublicKey);
-			}
-			
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const
-			{
-				uint8_t digest[Hash::hashLen];
-				Hash::CalculateHash (buf, len, digest);
-				ECDSA_SIG * sig = ECDSA_SIG_new();
-				sig->r = BN_bin2bn (signature, GetSignatureLen ()/2, NULL);
-				sig->s = BN_bin2bn (signature + GetSignatureLen ()/2, GetSignatureLen ()/2, NULL);
-				// ECDSA verification
-				int ret = ECDSA_do_verify (digest, Hash::hashLen, sig, m_PublicKey);
-				ECDSA_SIG_free(sig);
-				return ret;
-			}	
-			
-			size_t GetPublicKeyLen () const { return keyLen; };
-			size_t GetSignatureLen () const { return keyLen; }; // signature length = key length
-
-			
-		private:
-
-			EC_KEY * m_PublicKey;
-	};
-
-	template<typename Hash, int curve, size_t keyLen>
-	class ECDSASigner: public Signer
-	{
-		public:
-
-			ECDSASigner (const uint8_t * signingPrivateKey)
-			{
-				m_PrivateKey = EC_KEY_new_by_curve_name (curve);
-				EC_KEY_set_private_key (m_PrivateKey, BN_bin2bn (signingPrivateKey, keyLen/2, NULL));			
-			}
-
-			~ECDSASigner ()
-			{
-				EC_KEY_free (m_PrivateKey);
-			}
-			
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				uint8_t digest[Hash::hashLen];
-				Hash::CalculateHash (buf, len, digest);
-				ECDSA_SIG * sig = ECDSA_do_sign (digest, Hash::hashLen, m_PrivateKey);
-				// signatureLen = keyLen
-				bn2buf (sig->r, signature, keyLen/2);
-				bn2buf (sig->s, signature + keyLen/2, keyLen/2);
-				ECDSA_SIG_free(sig);
-			}
-
-		private:
-
-			EC_KEY * m_PrivateKey;
-	};
-
-	inline void CreateECDSARandomKeys (int curve, size_t keyLen, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		EC_KEY * signingKey = EC_KEY_new_by_curve_name (curve);
-		EC_KEY_generate_key (signingKey);
-		bn2buf (EC_KEY_get0_private_key (signingKey), signingPrivateKey, keyLen/2);
-		BIGNUM * x = BN_new(), * y = BN_new();
-		EC_POINT_get_affine_coordinates_GFp (EC_KEY_get0_group(signingKey),
-			EC_KEY_get0_public_key (signingKey), x, y, NULL);
-		bn2buf (x, signingPublicKey, keyLen/2);
-		bn2buf (y, signingPublicKey + keyLen/2, keyLen/2);
-		BN_free (x); BN_free (y);
-		EC_KEY_free (signingKey);		
-	}
-
-// ECDSA_SHA256_P256
-	const size_t ECDSAP256_KEY_LENGTH = 64;	
-	typedef ECDSAVerifier<SHA256Hash, NID_X9_62_prime256v1, ECDSAP256_KEY_LENGTH> ECDSAP256Verifier;
-	typedef ECDSASigner<SHA256Hash, NID_X9_62_prime256v1, ECDSAP256_KEY_LENGTH> ECDSAP256Signer;
-
-	inline void CreateECDSAP256RandomKeys (uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys (NID_X9_62_prime256v1, ECDSAP256_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}	
-
-// ECDSA_SHA384_P384
-	const size_t ECDSAP384_KEY_LENGTH = 96;
-	typedef ECDSAVerifier<SHA384Hash, NID_secp384r1, ECDSAP384_KEY_LENGTH> ECDSAP384Verifier;
-	typedef ECDSASigner<SHA384Hash, NID_secp384r1, ECDSAP384_KEY_LENGTH> ECDSAP384Signer;
-
-	inline void CreateECDSAP384RandomKeys (uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys (NID_secp384r1, ECDSAP384_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}	
-
-// ECDSA_SHA512_P521
-	const size_t ECDSAP521_KEY_LENGTH = 132;
-	typedef ECDSAVerifier<SHA512Hash, NID_secp521r1, ECDSAP521_KEY_LENGTH> ECDSAP521Verifier;
-	typedef ECDSASigner<SHA512Hash, NID_secp521r1, ECDSAP521_KEY_LENGTH> ECDSAP521Signer;
-
-	inline void CreateECDSAP521RandomKeys (uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys (NID_secp521r1, ECDSAP521_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}
-
-// RSA
-	template<typename Hash, int type, size_t keyLen>	
-	class RSAVerifier: public Verifier
-	{
-		public:
-
-			RSAVerifier (const uint8_t * signingKey)
-			{
-				m_PublicKey = RSA_new ();
-				memset (m_PublicKey, 0, sizeof (RSA));
-				m_PublicKey->e = BN_dup (GetRSAE ());
-				m_PublicKey->n = BN_bin2bn (signingKey, keyLen, NULL);
-			}
-
-			~RSAVerifier ()
-			{
-				RSA_free (m_PublicKey);
-			}
-			
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const 
-			{
-				uint8_t digest[Hash::hashLen];
-				Hash::CalculateHash (buf, len, digest);
-				return RSA_verify (type, digest, Hash::hashLen, signature, GetSignatureLen (), m_PublicKey);
-			}
-			size_t GetPublicKeyLen () const { return keyLen; }
-			size_t GetSignatureLen () const { return keyLen; }	
-			size_t GetPrivateKeyLen () const { return GetSignatureLen ()*2; };
-
-		private:
-			
-			RSA * m_PublicKey;			
-	};	
-
-	
-	template<typename Hash, int type, size_t keyLen>
-	class RSASigner: public Signer
-	{
-		public:
-
-			RSASigner (const uint8_t * signingPrivateKey)
-			{
-				m_PrivateKey = RSA_new ();
-				memset (m_PrivateKey, 0, sizeof (RSA));
-				m_PrivateKey->e = BN_dup (GetRSAE ());
-				m_PrivateKey->n = BN_bin2bn (signingPrivateKey, keyLen, NULL);
-				m_PrivateKey->d = BN_bin2bn (signingPrivateKey + keyLen, keyLen, NULL);
-			}
-
-			~RSASigner ()
-			{
-				RSA_free (m_PrivateKey);
-			}
-			
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				uint8_t digest[Hash::hashLen];
-				Hash::CalculateHash (buf, len, digest);
-				unsigned int signatureLen = keyLen;
-				RSA_sign (type, digest, Hash::hashLen, signature, &signatureLen, m_PrivateKey);
-			}
-			
-		private:
-
-			RSA * m_PrivateKey;
-	};		
-
-	inline void CreateRSARandomKeys (size_t publicKeyLen, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		RSA * rsa = RSA_new ();
-		BIGNUM * e = BN_dup (GetRSAE ()); // make it non-const
-		RSA_generate_key_ex (rsa, publicKeyLen*8, e, NULL);
-		bn2buf (rsa->n, signingPrivateKey, publicKeyLen);
-		bn2buf (rsa->d, signingPrivateKey + publicKeyLen, publicKeyLen);
-		bn2buf (rsa->n, signingPublicKey, publicKeyLen);
-		BN_free (e); // this e is not assigned to rsa->e
-		RSA_free (rsa);
-	}	
-	
-//  RSA_SHA256_2048
-	const size_t RSASHA2562048_KEY_LENGTH = 256;
-	typedef RSAVerifier<SHA256Hash, NID_sha256, RSASHA2562048_KEY_LENGTH> RSASHA2562048Verifier;
-	typedef RSASigner<SHA256Hash, NID_sha256, RSASHA2562048_KEY_LENGTH> RSASHA2562048Signer;
-
-//  RSA_SHA384_3072
-	const size_t RSASHA3843072_KEY_LENGTH = 384;
-	typedef RSAVerifier<SHA384Hash, NID_sha384, RSASHA3843072_KEY_LENGTH> RSASHA3843072Verifier;
-	typedef RSASigner<SHA384Hash, NID_sha384, RSASHA3843072_KEY_LENGTH> RSASHA3843072Signer;	
-
-//  RSA_SHA512_4096
-	const size_t RSASHA5124096_KEY_LENGTH = 512;
-	typedef RSAVerifier<SHA512Hash, NID_sha512, RSASHA5124096_KEY_LENGTH> RSASHA5124096Verifier;
-	typedef RSASigner<SHA512Hash, NID_sha512, RSASHA5124096_KEY_LENGTH> RSASHA5124096Signer;
-
-	// EdDSA
-	struct EDDSAPoint
-	{
-		BIGNUM * x, * y;
-		BIGNUM * z, * t; // projective coordinates
-		EDDSAPoint (): x(nullptr), y(nullptr), z(nullptr), t(nullptr) {};
-		EDDSAPoint (const EDDSAPoint& other): x(nullptr), y(nullptr), z(nullptr), t(nullptr) 
-		{ *this = other; };	
-		EDDSAPoint (EDDSAPoint&& other): x(nullptr), y(nullptr), z(nullptr), t(nullptr)  
-		{ *this = std::move (other); };	
-		EDDSAPoint (BIGNUM * x1, BIGNUM * y1, BIGNUM * z1 = nullptr, BIGNUM * t1 = nullptr): x(x1), y(y1), z(z1), t(t1) {};	
-		~EDDSAPoint () { BN_free (x); BN_free (y); BN_free(z); BN_free(t); };
-
-		EDDSAPoint& operator=(EDDSAPoint&& other) 
-		{
-			if (x) BN_free (x); x = other.x; other.x = nullptr;
-			if (y) BN_free (y); y = other.y; other.y = nullptr;
-			if (z) BN_free (z); z = other.z; other.z = nullptr;
-			if (t) BN_free (t); t = other.t; other.t = nullptr;
-			return *this;
-		} 	
-
-		EDDSAPoint& operator=(const EDDSAPoint& other) 
-		{
-			if (x) BN_free (x); x = other.x ? BN_dup (other.x) : nullptr;
-			if (y) BN_free (y); y = other.y ? BN_dup (other.y) : nullptr;
-			if (z) BN_free (z); z = other.z ? BN_dup (other.z) : nullptr;
-			if (t) BN_free (t); t = other.t ? BN_dup (other.t) : nullptr;
-			return *this;
-		}
-
-		EDDSAPoint operator-() const
-		{
-			BIGNUM * x1 = NULL, * y1 = NULL, * z1 = NULL, * t1 = NULL;
-			if (x) { x1 = BN_dup (x); BN_set_negative (x1, !BN_is_negative (x)); };
-			if (y) y1 = BN_dup (y);
-			if (z) z1 = BN_dup (z);
-			if (t) { t1 = BN_dup (t); BN_set_negative (t1, !BN_is_negative (t)); };
-			return EDDSAPoint {x1, y1, z1, t1};
-		}
-	};	
-
-	const size_t EDDSA25519_PUBLIC_KEY_LENGTH = 32;
-	const size_t EDDSA25519_SIGNATURE_LENGTH = 64;
-	const size_t EDDSA25519_PRIVATE_KEY_LENGTH = 32;		
-	class EDDSA25519Verifier: public Verifier
-	{
-		public:
-
-			EDDSA25519Verifier (const uint8_t * signingKey);
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const;
-
-			size_t GetPublicKeyLen () const { return EDDSA25519_PUBLIC_KEY_LENGTH; };
-			size_t GetSignatureLen () const { return EDDSA25519_SIGNATURE_LENGTH; };
-
-		private:
-
-			EDDSAPoint m_PublicKey;	
-			uint8_t m_PublicKeyEncoded[EDDSA25519_PUBLIC_KEY_LENGTH];
-	};
-
-	class EDDSA25519Signer: public Signer
-	{
-		public:
-
-			EDDSA25519Signer (const uint8_t * signingPrivateKey); 
-			void Sign (const uint8_t * buf, int len, uint8_t * signature) const; 
-			const uint8_t * GetPublicKey () const { return m_PublicKeyEncoded; };
-			
-		private:
-
-			uint8_t m_ExpandedPrivateKey[64]; 
-			uint8_t m_PublicKeyEncoded[EDDSA25519_PUBLIC_KEY_LENGTH];
-	};
-
-	inline void CreateEDDSA25519RandomKeys (uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		RAND_bytes (signingPrivateKey, EDDSA25519_PRIVATE_KEY_LENGTH);
-		EDDSA25519Signer signer (signingPrivateKey);
-		memcpy (signingPublicKey, signer.GetPublicKey (), EDDSA25519_PUBLIC_KEY_LENGTH);
-	}
-}
-}
-
-#endif
-

Timestamp.h

@@ -1,32 +0,0 @@
-#ifndef TIMESTAMP_H__
-#define TIMESTAMP_H__
-
-#include <inttypes.h>
-#include <chrono>
-
-namespace i2p
-{
-namespace util
-{
-	inline uint64_t GetMillisecondsSinceEpoch ()
-	{
-		return std::chrono::duration_cast<std::chrono::milliseconds>(
-			  	 std::chrono::system_clock::now().time_since_epoch()).count ();
-	}
-
-	inline uint32_t GetHoursSinceEpoch ()
-	{
-		return std::chrono::duration_cast<std::chrono::hours>(
-			  	 std::chrono::system_clock::now().time_since_epoch()).count ();
-	}
-
-	inline uint64_t GetSecondsSinceEpoch ()
-	{
-		return std::chrono::duration_cast<std::chrono::seconds>(
-			  	 std::chrono::system_clock::now().time_since_epoch()).count ();
-	}
-}
-}
-
-#endif
-

Transports.cpp

@@ -1,586 +0,0 @@
-#include <openssl/dh.h>
-#include "Log.h"
-#include "Crypto.h"
-#include "RouterContext.h"
-#include "I2NPProtocol.h"
-#include "NetDb.h"
-#include "Transports.h"
-
-using namespace i2p::data;
-
-namespace i2p
-{
-namespace transport
-{
-	DHKeysPairSupplier::DHKeysPairSupplier (int size):
-		m_QueueSize (size), m_IsRunning (false), m_Thread (nullptr)
-	{
-	}	
-
-	DHKeysPairSupplier::~DHKeysPairSupplier ()
-	{
-		Stop ();
-	}
-
-	void DHKeysPairSupplier::Start ()
-	{
-		m_IsRunning = true;
-		m_Thread = new std::thread (std::bind (&DHKeysPairSupplier::Run, this));
-	}
-
-	void DHKeysPairSupplier::Stop ()
-	{
-		m_IsRunning = false;
-		m_Acquired.notify_one ();	
-		if (m_Thread)
-		{	
-			m_Thread->join (); 
-			delete m_Thread;
-			m_Thread = 0;
-		}	
-	}
-
-	void DHKeysPairSupplier::Run ()
-	{
-		while (m_IsRunning)
-		{
-			int num;
-			while ((num = m_QueueSize - m_Queue.size ()) > 0)
-				CreateDHKeysPairs (num);
-			std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-			m_Acquired.wait (l); // wait for element gets aquired
-		}
-	}		
-
-	void DHKeysPairSupplier::CreateDHKeysPairs (int num)
-	{
-		if (num > 0)
-		{
-			i2p::crypto::DHKeys dh;
-			for (int i = 0; i < num; i++)
-			{
-				auto pair = std::make_shared<i2p::crypto::DHKeys> ();
-				pair->GenerateKeys ();
-				std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-				m_Queue.push (pair);
-			}
-		}
-	}
-
-	std::shared_ptr<i2p::crypto::DHKeys> DHKeysPairSupplier::Acquire ()
-	{
-		{
-			std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-			if (!m_Queue.empty ())
-			{
-				auto pair = m_Queue.front ();
-				m_Queue.pop ();
-				m_Acquired.notify_one ();
-				return pair;
-			}	
-		}	
-		// queue is empty, create new
-		auto pair = std::make_shared<i2p::crypto::DHKeys> ();
-		pair->GenerateKeys ();
-		return pair;
-	}
-
-	void DHKeysPairSupplier::Return (std::shared_ptr<i2p::crypto::DHKeys> pair)
-	{
-		std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-		m_Queue.push (pair);
-	}
-
-	Transports transports;	
-	
-	Transports::Transports (): 
-		m_IsRunning (false), m_Thread (nullptr), m_Work (m_Service), m_PeerCleanupTimer (m_Service),
-		m_NTCPServer (nullptr), m_SSUServer (nullptr), m_DHKeysPairSupplier (5), // 5 pre-generated keys
-		m_TotalSentBytes(0), m_TotalReceivedBytes(0), m_InBandwidth (0), m_OutBandwidth (0),
-		m_LastInBandwidthUpdateBytes (0), m_LastOutBandwidthUpdateBytes (0), m_LastBandwidthUpdateTime (0)	
-	{		
-	}
-		
-	Transports::~Transports () 
-	{ 
-		Stop ();
-	}	
-
-	void Transports::Start ()
-	{
-		m_DHKeysPairSupplier.Start ();
-		m_IsRunning = true;
-		m_Thread = new std::thread (std::bind (&Transports::Run, this));
-		// create acceptors
-		auto addresses = context.GetRouterInfo ().GetAddresses ();
-		for (auto& address : addresses)
-		{
-			if (!m_NTCPServer)
-			{	
-				m_NTCPServer = new NTCPServer ();
-				m_NTCPServer->Start ();
-			}	
-			
-			if (address.transportStyle == RouterInfo::eTransportSSU && address.host.is_v4 ())
-			{
-				if (!m_SSUServer)
-				{	
-					m_SSUServer = new SSUServer (address.port);
-					LogPrint (eLogInfo, "Transports: Start listening UDP port ", address.port);
-					m_SSUServer->Start ();	
-					DetectExternalIP ();
-				}
-				else
-					LogPrint (eLogError, "Transports: SSU server already exists");
-			}
-		}	
-		m_PeerCleanupTimer.expires_from_now (boost::posix_time::seconds(5*SESSION_CREATION_TIMEOUT));
-		m_PeerCleanupTimer.async_wait (std::bind (&Transports::HandlePeerCleanupTimer, this, std::placeholders::_1));
-	}
-		
-	void Transports::Stop ()
-	{	
-		m_PeerCleanupTimer.cancel ();	
-		m_Peers.clear ();
-		if (m_SSUServer)
-		{
-			m_SSUServer->Stop ();
-			delete m_SSUServer;
-			m_SSUServer = nullptr;
-		}	
-		if (m_NTCPServer)
-		{
-			m_NTCPServer->Stop ();
-			delete m_NTCPServer;
-			m_NTCPServer = nullptr;
-		}	
-
-		m_DHKeysPairSupplier.Stop ();
-		m_IsRunning = false;
-		m_Service.stop ();
-		if (m_Thread)
-		{	
-			m_Thread->join (); 
-			delete m_Thread;
-			m_Thread = nullptr;
-		}	
-	}	
-
-	void Transports::Run () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_Service.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Transports: runtime exception: ", ex.what ());
-			}	
-		}	
-	}
-		
-	void Transports::UpdateBandwidth ()
-	{
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch ();
-		if (m_LastBandwidthUpdateTime > 0)
-		{
-			auto delta = ts - m_LastBandwidthUpdateTime;
-			if (delta > 0)
-			{
-				m_InBandwidth = (m_TotalReceivedBytes - m_LastInBandwidthUpdateBytes)*1000/delta; // per second 
-				m_OutBandwidth = (m_TotalSentBytes - m_LastOutBandwidthUpdateBytes)*1000/delta; // per second 
-			} 
-		}
-		m_LastBandwidthUpdateTime = ts;
-		m_LastInBandwidthUpdateBytes = m_TotalReceivedBytes;	
-		m_LastOutBandwidthUpdateBytes = m_TotalSentBytes;		
-	}
-
-	bool Transports::IsBandwidthExceeded () const
-	{
-		if (i2p::context.GetRouterInfo ().IsExtraBandwidth ()) return false;
-		auto bw = std::max (m_InBandwidth, m_OutBandwidth);
-		return bw > (i2p::context.GetRouterInfo ().IsHighBandwidth () ? HIGH_BANDWIDTH_LIMIT : LOW_BANDWIDTH_LIMIT);
-	}
-
-	void Transports::SendMessage (const i2p::data::IdentHash& ident, std::shared_ptr<i2p::I2NPMessage> msg)
-	{
-		SendMessages (ident, std::vector<std::shared_ptr<i2p::I2NPMessage> > {msg });                             
-	}	
-
-	void Transports::SendMessages (const i2p::data::IdentHash& ident, const std::vector<std::shared_ptr<i2p::I2NPMessage> >& msgs)
-	{
-		m_Service.post (std::bind (&Transports::PostMessages, this, ident, msgs));
-	}	
-
-	void Transports::PostMessages (i2p::data::IdentHash ident, std::vector<std::shared_ptr<i2p::I2NPMessage> > msgs)
-	{
-		if (ident == i2p::context.GetRouterInfo ().GetIdentHash ())
-		{	
-			// we send it to ourself
-			for (auto it: msgs)
-				i2p::HandleI2NPMessage (it);
-			return;
-		}	
-		auto it = m_Peers.find (ident);
-		if (it == m_Peers.end ())
-		{
-			bool connected = false; 
-			try
-			{
-				auto r = netdb.FindRouter (ident);
-				{
-					std::unique_lock<std::mutex>  l(m_PeersMutex);	
-					it = m_Peers.insert (std::pair<i2p::data::IdentHash, Peer>(ident, { 0, r, {},
-						i2p::util::GetSecondsSinceEpoch (), {} })).first;
-				}
-				connected = ConnectToPeer (ident, it->second);
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Transports: PostMessages exception:", ex.what ());
-			}
-			if (!connected) return;
-		}	
-		if (!it->second.sessions.empty ())
-			it->second.sessions.front ()->SendI2NPMessages (msgs);
-		else
-		{	
-			for (auto it1: msgs)
-				it->second.delayedMessages.push_back (it1);
-		}	
-	}	
-		
-	bool Transports::ConnectToPeer (const i2p::data::IdentHash& ident, Peer& peer)
-	{
-		if (peer.router) // we have RI already
-		{	
-			if (!peer.numAttempts) // NTCP
-			{
-				peer.numAttempts++;
-				auto address = peer.router->GetNTCPAddress (!context.SupportsV6 ());
-				if (address)
-				{
-#if BOOST_VERSION >= 104900
-					if (!address->host.is_unspecified ()) // we have address now
-#else
-					boost::system::error_code ecode;
-					address->host.to_string (ecode);
-					if (!ecode)
-#endif
-					{
-						if (!peer.router->UsesIntroducer () && !peer.router->IsUnreachable ())
-						{	
-							auto s = std::make_shared<NTCPSession> (*m_NTCPServer, peer.router);
-							m_NTCPServer->Connect (address->host, address->port, s);
-							return true;
-						}
-					}
-					else // we don't have address
-					{
-						if (address->addressString.length () > 0) // trying to resolve
-						{
-							LogPrint (eLogDebug, "Transports: Resolving NTCP ", address->addressString);
-							NTCPResolve (address->addressString, ident);
-							return true;
-						}
-					}
-				}	
-				else
-					LogPrint (eLogWarning, "Transports: NTCP address is not present for ", i2p::data::GetIdentHashAbbreviation (ident), ", trying SSU");
-			}
-			if (peer.numAttempts == 1)// SSU
-			{
-				peer.numAttempts++;
-				if (m_SSUServer && peer.router->IsSSU (!context.SupportsV6 ()))
-				{
-					auto address = peer.router->GetSSUAddress (!context.SupportsV6 ());
-#if BOOST_VERSION >= 104900
-					if (!address->host.is_unspecified ()) // we have address now
-#else
-					boost::system::error_code ecode;
-					address->host.to_string (ecode);
-					if (!ecode)
-#endif
-					{
-						m_SSUServer->CreateSession (peer.router, address->host, address->port);
-						return true;
-					}
-					else // we don't have address
-					{
-						if (address->addressString.length () > 0) // trying to resolve
-						{
-							LogPrint (eLogDebug, "Transports: Resolving SSU ", address->addressString);
-							SSUResolve (address->addressString, ident);
-							return true;
-						}
-					}
-				}
-			}	
-			LogPrint (eLogError, "Transports: No NTCP or SSU addresses available");
-			peer.Done ();
-			std::unique_lock<std::mutex>  l(m_PeersMutex);	
-			m_Peers.erase (ident);
-			return false;
-		}	
-		else // otherwise request RI
-		{
-			LogPrint (eLogInfo, "Transports: RouterInfo for ", ident.ToBase64 (), " not found, requested");
-			i2p::data::netdb.RequestDestination (ident, std::bind (
-				&Transports::RequestComplete, this, std::placeholders::_1, ident));
-		}	
-		return true;
-	}	
-	
-	void Transports::RequestComplete (std::shared_ptr<const i2p::data::RouterInfo> r, const i2p::data::IdentHash& ident)
-	{
-		m_Service.post (std::bind (&Transports::HandleRequestComplete, this, r, ident));
-	}		
-	
-	void Transports::HandleRequestComplete (std::shared_ptr<const i2p::data::RouterInfo> r, i2p::data::IdentHash ident)
-	{
-		auto it = m_Peers.find (ident);
-		if (it != m_Peers.end ())
-		{	
-			if (r)
-			{
-				LogPrint (eLogDebug, "Transports: RouterInfo for ", ident.ToBase64 (), " found, Trying to connect");
-				it->second.router = r;
-				ConnectToPeer (ident, it->second);
-			}	
-			else
-			{
-				LogPrint (eLogError, "Transports: RouterInfo not found, Failed to send messages");
-				std::unique_lock<std::mutex>  l(m_PeersMutex);	
-				m_Peers.erase (it);
-			}	
-		}	
-	}	
-
-	void Transports::NTCPResolve (const std::string& addr, const i2p::data::IdentHash& ident)
-	{
-		auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(m_Service);
-		resolver->async_resolve (boost::asio::ip::tcp::resolver::query (addr, ""), 
-			std::bind (&Transports::HandleNTCPResolve, this, 
-				std::placeholders::_1, std::placeholders::_2, ident, resolver));
-	}
-
-	void Transports::HandleNTCPResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it, 
-		i2p::data::IdentHash ident, std::shared_ptr<boost::asio::ip::tcp::resolver> resolver)
-	{
-		auto it1 = m_Peers.find (ident);
-		if (it1 != m_Peers.end ())
-		{
-			auto& peer = it1->second;
-			if (!ecode && peer.router)
-			{
-				auto address = (*it).endpoint ().address ();
-				LogPrint (eLogDebug, "Transports: ", (*it).host_name (), " has been resolved to ", address);
-				auto addr = peer.router->GetNTCPAddress ();
-				if (addr)
-				{
-					auto s = std::make_shared<NTCPSession> (*m_NTCPServer, peer.router);
-					m_NTCPServer->Connect (address, addr->port, s);
-					return;
-				}	
-			}
-			LogPrint (eLogError, "Transports: Unable to resolve NTCP address: ", ecode.message ());
-			std::unique_lock<std::mutex>  l(m_PeersMutex);		
-			m_Peers.erase (it1);
-		}
-	}
-
-	void Transports::SSUResolve (const std::string& addr, const i2p::data::IdentHash& ident)
-	{
-		auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(m_Service);
-		resolver->async_resolve (boost::asio::ip::tcp::resolver::query (addr, ""), 
-			std::bind (&Transports::HandleSSUResolve, this, 
-				std::placeholders::_1, std::placeholders::_2, ident, resolver));
-	}
-
-	void Transports::HandleSSUResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it, 
-		i2p::data::IdentHash ident, std::shared_ptr<boost::asio::ip::tcp::resolver> resolver)
-	{
-		auto it1 = m_Peers.find (ident);
-		if (it1 != m_Peers.end ())
-		{
-			auto& peer = it1->second;
-			if (!ecode && peer.router)
-			{
-				auto address = (*it).endpoint ().address ();
-				LogPrint (eLogDebug, "Transports: ", (*it).host_name (), " has been resolved to ", address);
-				auto addr = peer.router->GetSSUAddress (!context.SupportsV6 ());;
-				if (addr)
-				{
-					m_SSUServer->CreateSession (peer.router, address, addr->port);
-					return;
-				}	
-			}
-			LogPrint (eLogError, "Transports: Unable to resolve SSU address: ", ecode.message ());
-			std::unique_lock<std::mutex>  l(m_PeersMutex);	
-			m_Peers.erase (it1);
-		}
-	}
-
-	void Transports::CloseSession (std::shared_ptr<const i2p::data::RouterInfo> router)
-	{
-		if (!router) return;
-		m_Service.post (std::bind (&Transports::PostCloseSession, this, router));    
-	}	
-
-	void Transports::PostCloseSession (std::shared_ptr<const i2p::data::RouterInfo> router)
-	{
-		auto ssuSession = m_SSUServer ? m_SSUServer->FindSession (router) : nullptr;
-		if (ssuSession) // try SSU first
-		{	
-			m_SSUServer->DeleteSession (ssuSession);
-			LogPrint (eLogDebug, "Transports: SSU session closed");
-		}	
-		// TODO: delete NTCP
-	}	
-		
-	void Transports::DetectExternalIP ()
-	{
-		if (m_SSUServer)
-		{
-			i2p::context.SetStatus (eRouterStatusTesting);
-			for (int i = 0; i < 5; i++)
-			{
-				auto router = i2p::data::netdb.GetRandomPeerTestRouter ();
-				if (router  && router->IsSSU (!context.SupportsV6 ()))
-					m_SSUServer->CreateSession (router, true);  // peer test	
-				else
-				{
-					// if not peer test capable routers found pick any
-					router = i2p::data::netdb.GetRandomRouter ();
-					if (router && router->IsSSU ())
-						m_SSUServer->CreateSession (router);  	// no peer test
-				}
-			}	
-		}
-		else
-			LogPrint (eLogError, "Transports: Can't detect external IP. SSU is not available");
-	}
-
-	void Transports::PeerTest ()
-	{
-		if (m_SSUServer)
-		{
-			bool statusChanged = false;
-			for (int i = 0; i < 5; i++)
-			{
-				auto router = i2p::data::netdb.GetRandomPeerTestRouter ();
-				if (router && router->IsSSU (!context.SupportsV6 ()))
-				{	
-					if (!statusChanged)
-					{	
-						statusChanged = true;
-						i2p::context.SetStatus (eRouterStatusTesting); // first time only
-					}	
-					m_SSUServer->CreateSession (router, true);  // peer test	
-				}	
-			}	
-		}
-	}	
-		
-	std::shared_ptr<i2p::crypto::DHKeys> Transports::GetNextDHKeysPair ()
-	{
-		return m_DHKeysPairSupplier.Acquire ();
-	}
-
-	void Transports::ReuseDHKeysPair (std::shared_ptr<i2p::crypto::DHKeys> pair)
-	{
-		m_DHKeysPairSupplier.Return (pair);
-	}
-
-	void Transports::PeerConnected (std::shared_ptr<TransportSession> session)
-	{
-		m_Service.post([session, this]()
-		{   
-			auto remoteIdentity = session->GetRemoteIdentity (); 
-			if (!remoteIdentity) return;
-			auto ident = remoteIdentity->GetIdentHash ();
-			auto it = m_Peers.find (ident);
-			if (it != m_Peers.end ())
-			{
-				it->second.sessions.push_back (session);
-				session->SendI2NPMessages (it->second.delayedMessages);
-				it->second.delayedMessages.clear ();
-			}
-			else // incoming connection
-			{
-				std::unique_lock<std::mutex>  l(m_PeersMutex);	
-				m_Peers.insert (std::make_pair (ident, Peer{ 0, nullptr, { session }, i2p::util::GetSecondsSinceEpoch (), {} }));
-			}
-		});			
-	}
-		
-	void Transports::PeerDisconnected (std::shared_ptr<TransportSession> session)
-	{
-		m_Service.post([session, this]()
-		{  
-			auto remoteIdentity = session->GetRemoteIdentity (); 
-			if (!remoteIdentity) return;
-			auto ident = remoteIdentity->GetIdentHash ();
-			auto it = m_Peers.find (ident);
-			if (it != m_Peers.end ())
-			{
-				it->second.sessions.remove (session);
-				if (it->second.sessions.empty ()) // TODO: why?
-				{	
-					if (it->second.delayedMessages.size () > 0)
-						ConnectToPeer (ident, it->second);
-					else
-					{
-						std::unique_lock<std::mutex>  l(m_PeersMutex);	
-						m_Peers.erase (it);
-					}
-				}
-			}
-		});	
-	}	
-
-	bool Transports::IsConnected (const i2p::data::IdentHash& ident) const
-	{	
-		std::unique_lock<std::mutex> l(m_PeersMutex);		
-		auto it = m_Peers.find (ident);
-		return it != m_Peers.end ();
-	}	
-		
-	void Transports::HandlePeerCleanupTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			auto ts = i2p::util::GetSecondsSinceEpoch ();
-			for (auto it = m_Peers.begin (); it != m_Peers.end (); )
-			{
-				if (it->second.sessions.empty () && ts > it->second.creationTime + SESSION_CREATION_TIMEOUT)
-				{
-					LogPrint (eLogWarning, "Transports: Session to peer ", it->first.ToBase64 (), " has not been created in ", SESSION_CREATION_TIMEOUT, " seconds");
-					std::unique_lock<std::mutex>  l(m_PeersMutex);	
-					it = m_Peers.erase (it);
-				}
-				else
-					it++;
-			}
-			UpdateBandwidth (); // TODO: use separate timer(s) for it
-			if (i2p::context.GetStatus () == eRouterStatusTesting) // if still testing,  repeat peer test
-				DetectExternalIP ();
-			m_PeerCleanupTimer.expires_from_now (boost::posix_time::seconds(5*SESSION_CREATION_TIMEOUT));
-			m_PeerCleanupTimer.async_wait (std::bind (&Transports::HandlePeerCleanupTimer, this, std::placeholders::_1));
-		}	
-	}
-
-	std::shared_ptr<const i2p::data::RouterInfo> Transports::GetRandomPeer () const
-	{
-		if (!m_Peers.size ()) return nullptr;
-		std::unique_lock<std::mutex> l(m_PeersMutex);	
-		auto it = m_Peers.begin ();
-		std::advance (it, rand () % m_Peers.size ());	
-		return it != m_Peers.end () ? it->second.router : nullptr;
-	}
-}
-}
-

Transports.h

@@ -1,157 +0,0 @@
-#ifndef TRANSPORTS_H__
-#define TRANSPORTS_H__
-
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <functional>
-#include <map>
-#include <vector>
-#include <queue>
-#include <string>
-#include <memory>
-#include <atomic>
-#include <boost/asio.hpp>
-#include "TransportSession.h"
-#include "NTCPSession.h"
-#include "SSU.h"
-#include "RouterInfo.h"
-#include "I2NPProtocol.h"
-#include "Identity.h"
-
-namespace i2p
-{
-namespace transport
-{
-	class DHKeysPairSupplier
-	{
-		public:
-
-			DHKeysPairSupplier (int size);
-			~DHKeysPairSupplier ();
-			void Start ();
-			void Stop ();
-			std::shared_ptr<i2p::crypto::DHKeys> Acquire ();
-			void Return (std::shared_ptr<i2p::crypto::DHKeys> pair);
-
-		private:
-
-			void Run ();
-			void CreateDHKeysPairs (int num);
-
-		private:
-
-			const int m_QueueSize;
-			std::queue<std::shared_ptr<i2p::crypto::DHKeys> > m_Queue;
-
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			std::condition_variable m_Acquired;
-			std::mutex m_AcquiredMutex;
-	};
-
-	struct Peer
-	{
-		int numAttempts;
-		std::shared_ptr<const i2p::data::RouterInfo> router;
-		std::list<std::shared_ptr<TransportSession> > sessions;
-		uint64_t creationTime;
-		std::vector<std::shared_ptr<i2p::I2NPMessage> > delayedMessages;
-
-		void Done ()
-		{
-			for (auto it: sessions)
-				it->Done ();
-		}	
-	};	
-	
-	const size_t SESSION_CREATION_TIMEOUT = 10; // in seconds
-	const uint32_t LOW_BANDWIDTH_LIMIT = 32*1024; // 32KBs
-	const uint32_t HIGH_BANDWIDTH_LIMIT = 256*1024; // 256KBs
-	class Transports
-	{
-		public:
-
-			Transports ();
-			~Transports ();
-
-			void Start ();
-			void Stop ();
-			
-			boost::asio::io_service& GetService () { return m_Service; };
-			std::shared_ptr<i2p::crypto::DHKeys> GetNextDHKeysPair ();	
-			void ReuseDHKeysPair (std::shared_ptr<i2p::crypto::DHKeys> pair);
-
-			void SendMessage (const i2p::data::IdentHash& ident, std::shared_ptr<i2p::I2NPMessage> msg);
-			void SendMessages (const i2p::data::IdentHash& ident, const std::vector<std::shared_ptr<i2p::I2NPMessage> >& msgs);
-			void CloseSession (std::shared_ptr<const i2p::data::RouterInfo> router);
-
-			void PeerConnected (std::shared_ptr<TransportSession> session);
-			void PeerDisconnected (std::shared_ptr<TransportSession> session);
-			bool IsConnected (const i2p::data::IdentHash& ident) const;
-			
-			void UpdateSentBytes (uint64_t numBytes) { m_TotalSentBytes += numBytes; };
-			void UpdateReceivedBytes (uint64_t numBytes) { m_TotalReceivedBytes += numBytes; };
-			uint64_t GetTotalSentBytes () const { return m_TotalSentBytes; };
-			uint64_t GetTotalReceivedBytes () const { return m_TotalReceivedBytes; };		
-			uint32_t GetInBandwidth () const { return m_InBandwidth; }; // bytes per second
-			uint32_t GetOutBandwidth () const { return m_OutBandwidth; }; // bytes per second
-			bool IsBandwidthExceeded () const;
-			size_t GetNumPeers () const { return m_Peers.size (); };
-			std::shared_ptr<const i2p::data::RouterInfo> GetRandomPeer () const;
-
-			void PeerTest ();
-			
-		private:
-
-			void Run ();
-			void RequestComplete (std::shared_ptr<const i2p::data::RouterInfo> r, const i2p::data::IdentHash& ident);
-			void HandleRequestComplete (std::shared_ptr<const i2p::data::RouterInfo> r, i2p::data::IdentHash ident);
-			void PostMessages (i2p::data::IdentHash ident, std::vector<std::shared_ptr<i2p::I2NPMessage> > msgs);
-			void PostCloseSession (std::shared_ptr<const i2p::data::RouterInfo> router);
-			bool ConnectToPeer (const i2p::data::IdentHash& ident, Peer& peer);
-			void HandlePeerCleanupTimer (const boost::system::error_code& ecode);			
-
-			void NTCPResolve (const std::string& addr, const i2p::data::IdentHash& ident);
-			void HandleNTCPResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it,
- 				i2p::data::IdentHash ident, std::shared_ptr<boost::asio::ip::tcp::resolver> resolver);
-			void SSUResolve (const std::string& addr, const i2p::data::IdentHash& ident);
-			void HandleSSUResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it,
- 				i2p::data::IdentHash ident, std::shared_ptr<boost::asio::ip::tcp::resolver> resolver);
-
-			void UpdateBandwidth ();
-			void DetectExternalIP ();
-			
-		private:
-
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			boost::asio::io_service m_Service;
-			boost::asio::io_service::work m_Work;
-			boost::asio::deadline_timer m_PeerCleanupTimer;
-
-			NTCPServer * m_NTCPServer;
-			SSUServer * m_SSUServer;
-			mutable std::mutex m_PeersMutex;
-			std::map<i2p::data::IdentHash, Peer> m_Peers;
-			
-			DHKeysPairSupplier m_DHKeysPairSupplier;
-
-			std::atomic<uint64_t> m_TotalSentBytes, m_TotalReceivedBytes;
-			uint32_t m_InBandwidth, m_OutBandwidth;
-			uint64_t m_LastInBandwidthUpdateBytes, m_LastOutBandwidthUpdateBytes;	
-			uint64_t m_LastBandwidthUpdateTime;		
-
-		public:
-
-			// for HTTP only
-			const NTCPServer * GetNTCPServer () const { return m_NTCPServer; };
-			const SSUServer * GetSSUServer () const { return m_SSUServer; };
-			const decltype(m_Peers)& GetPeers () const { return m_Peers; };
-	};	
-
-	extern Transports transports;
-}	
-}
-
-#endif

TunnelConfig.h

@@ -1,249 +0,0 @@
-#ifndef TUNNEL_CONFIG_H__
-#define TUNNEL_CONFIG_H__
-
-#include <inttypes.h>
-#include <sstream>
-#include <vector>
-#include <memory>
-#include <openssl/rand.h>
-#include "Crypto.h"
-#include "Identity.h"
-#include "RouterContext.h"
-#include "Timestamp.h"
-
-namespace i2p
-{
-namespace tunnel
-{
-	struct TunnelHopConfig
-	{
-		std::shared_ptr<const i2p::data::IdentityEx> ident;
-		i2p::data::IdentHash nextIdent;
-		uint32_t tunnelID, nextTunnelID;
-		uint8_t layerKey[32];
-		uint8_t ivKey[32];
-		uint8_t replyKey[32];
-		uint8_t replyIV[16];
-		bool isGateway, isEndpoint;	
-		
-		TunnelHopConfig * next, * prev;
-		int recordIndex; // record # in tunnel build message
-		
-		TunnelHopConfig (std::shared_ptr<const i2p::data::IdentityEx> r)
-		{
-			RAND_bytes (layerKey, 32);
-			RAND_bytes (ivKey, 32);
-			RAND_bytes (replyKey, 32);
-			RAND_bytes (replyIV, 16);
-			RAND_bytes ((uint8_t *)&tunnelID, 4);
-			isGateway = true;
-			isEndpoint = true;
-			ident = r; 
-			//nextRouter = nullptr; 
-			nextTunnelID = 0;
-
-			next = nullptr;
-			prev = nullptr;
-		}	
-
-		void SetNextIdent (const i2p::data::IdentHash& ident)
-		{
-			nextIdent = ident;
-			isEndpoint = false;
-			RAND_bytes ((uint8_t *)&nextTunnelID, 4);
-		}	
-
-		void SetReplyHop (uint32_t replyTunnelID, const i2p::data::IdentHash& replyIdent)
-		{
-			nextIdent = replyIdent;
-			nextTunnelID = replyTunnelID;
-			isEndpoint = true;
-		}
-		
-		void SetNext (TunnelHopConfig * n)
-		{
-			next = n;
-			if (next)
-			{	
-				next->prev = this;
-				next->isGateway = false;
-				isEndpoint = false;
-				nextIdent = next->ident->GetIdentHash ();
-				nextTunnelID = next->tunnelID;
-			}	
-		}
-
-		void SetPrev (TunnelHopConfig * p)
-		{
-			prev = p;
-			if (prev) 
-			{	
-				prev->next = this;
-				prev->isEndpoint = false;
-				isGateway = false;
-			}	
-		}
-
-		void CreateBuildRequestRecord (uint8_t * record, uint32_t replyMsgID) const
-		{
-			uint8_t clearText[BUILD_REQUEST_RECORD_CLEAR_TEXT_SIZE];
-			htobe32buf (clearText + BUILD_REQUEST_RECORD_RECEIVE_TUNNEL_OFFSET, tunnelID); 
-			memcpy (clearText + BUILD_REQUEST_RECORD_OUR_IDENT_OFFSET, ident->GetIdentHash (), 32);
-			htobe32buf (clearText + BUILD_REQUEST_RECORD_NEXT_TUNNEL_OFFSET, nextTunnelID);
-			memcpy (clearText + BUILD_REQUEST_RECORD_NEXT_IDENT_OFFSET, nextIdent, 32);
-			memcpy (clearText + BUILD_REQUEST_RECORD_LAYER_KEY_OFFSET, layerKey, 32);
-			memcpy (clearText + BUILD_REQUEST_RECORD_IV_KEY_OFFSET, ivKey, 32);
-			memcpy (clearText + BUILD_REQUEST_RECORD_REPLY_KEY_OFFSET, replyKey, 32);
-			memcpy (clearText + BUILD_REQUEST_RECORD_REPLY_IV_OFFSET, replyIV, 16);
-			uint8_t flag = 0;
-			if (isGateway) flag |= 0x80;
-			if (isEndpoint) flag |= 0x40;
-			clearText[BUILD_REQUEST_RECORD_FLAG_OFFSET] = flag;
-			htobe32buf (clearText + BUILD_REQUEST_RECORD_REQUEST_TIME_OFFSET, i2p::util::GetHoursSinceEpoch ()); 
-			htobe32buf (clearText + BUILD_REQUEST_RECORD_SEND_MSG_ID_OFFSET, replyMsgID); 
-			RAND_bytes (clearText + BUILD_REQUEST_RECORD_PADDING_OFFSET, BUILD_REQUEST_RECORD_CLEAR_TEXT_SIZE - BUILD_REQUEST_RECORD_PADDING_OFFSET);
-			i2p::crypto::ElGamalEncryption elGamalEncryption (ident->GetEncryptionPublicKey ());
-			elGamalEncryption.Encrypt (clearText, BUILD_REQUEST_RECORD_CLEAR_TEXT_SIZE, record + BUILD_REQUEST_RECORD_ENCRYPTED_OFFSET);
-			memcpy (record + BUILD_REQUEST_RECORD_TO_PEER_OFFSET, (const uint8_t *)ident->GetIdentHash (), 16);
-		}	
-	};	
-
-	class TunnelConfig
-	{
-		public:			
-			
-			TunnelConfig (std::vector<std::shared_ptr<const i2p::data::IdentityEx> > peers) // inbound
-			{
-				CreatePeers (peers);
-				m_LastHop->SetNextIdent (i2p::context.GetIdentHash ());
-			}
-
-			TunnelConfig (std::vector<std::shared_ptr<const i2p::data::IdentityEx> > peers, 
-				uint32_t replyTunnelID, const i2p::data::IdentHash& replyIdent) // outbound
-			{
-				CreatePeers (peers);
-				m_FirstHop->isGateway = false;
-				m_LastHop->SetReplyHop (replyTunnelID, replyIdent);
-			}
-			
-			~TunnelConfig ()
-			{
-				TunnelHopConfig * hop = m_FirstHop;
-				
-				while (hop)
-				{
-					auto tmp = hop;
-					hop = hop->next;
-					delete tmp;
-				}	
-			}
-			
-			TunnelHopConfig * GetFirstHop () const
-			{
-				return m_FirstHop;
-			}
-
-			TunnelHopConfig * GetLastHop () const
-			{
-				return m_LastHop;
-			}
-
-			int GetNumHops () const
-			{
-				int num = 0;
-				TunnelHopConfig * hop = m_FirstHop;		
-				while (hop)
-				{
-					num++;
-					hop = hop->next;
-				}	
-				return num;
-			}
-
-			virtual bool IsInbound () const { return m_FirstHop->isGateway; }
-
-			virtual uint32_t GetTunnelID () const 
-			{	
-				if (!m_FirstHop) return 0;
-				return IsInbound () ? m_LastHop->nextTunnelID : m_FirstHop->tunnelID; 
-			}
-
-			virtual uint32_t GetNextTunnelID () const 
-			{	
-				if (!m_FirstHop) return 0;
-				return m_FirstHop->tunnelID; 
-			}
-
-			virtual const i2p::data::IdentHash& GetNextIdentHash () const 
-			{ 
-				return m_FirstHop->ident->GetIdentHash (); 
-			}	
-
-			virtual const i2p::data::IdentHash& GetLastIdentHash () const 
-			{ 
-				return m_LastHop->ident->GetIdentHash (); 
-			}	
-			
-			std::vector<std::shared_ptr<const i2p::data::IdentityEx> > GetPeers () const
-			{
-				std::vector<std::shared_ptr<const i2p::data::IdentityEx> > peers;
-				TunnelHopConfig * hop = m_FirstHop;		
-				while (hop)
-				{
-					peers.push_back (hop->ident);
-					hop = hop->next;
-				}	
-				return peers;
-			}
-			
-		protected:
-
-			// this constructor can't be called from outside
-			TunnelConfig (): m_FirstHop (nullptr), m_LastHop (nullptr)
-			{
-			}
-	
-		private:
-
-			template<class Peers>
-			void CreatePeers (const Peers& peers)
-			{
-				TunnelHopConfig * prev = nullptr;
-				for (auto it: peers)
-				{
-					auto hop = new TunnelHopConfig (it);
-					if (prev)
-						prev->SetNext (hop);
-					else	
-						m_FirstHop = hop;
-					prev = hop;
-				}	
-				m_LastHop = prev;
-			}
-			
-		private:
-
-			TunnelHopConfig * m_FirstHop, * m_LastHop;
-	};
-
-	class ZeroHopsTunnelConfig: public TunnelConfig
-	{
-		public:
-
-			ZeroHopsTunnelConfig () { RAND_bytes ((uint8_t *)&m_TunnelID, 4);};
-
-			bool IsInbound () const { return true; }; // TODO:		
-			uint32_t GetTunnelID () const { return m_TunnelID; };
-			uint32_t GetNextTunnelID () const { return m_TunnelID; };
-			const i2p::data::IdentHash& GetNextIdentHash () const { return i2p::context.GetIdentHash (); };
-			const i2p::data::IdentHash& GetLastIdentHash () const { return i2p::context.GetIdentHash (); };
-
-
-		private:
-		
-			uint32_t m_TunnelID;	
-	};	
-}		
-}	
-
-#endif

UPnP.cpp

@@ -1,247 +0,0 @@
-#ifdef USE_UPNP
-#include <string>
-#include <thread>
-
-#include <boost/thread/thread.hpp>
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-
-#ifdef _WIN32
-#include <windows.h>
-#define dlsym GetProcAddress
-#else
-#include <dlfcn.h>
-#endif
-
-#include "Log.h"
-
-#include "RouterContext.h"
-#include "UPnP.h"
-#include "NetDb.h"
-#include "util.h"
-
-#include <miniupnpc/miniupnpc.h>
-#include <miniupnpc/upnpcommands.h>
-
-// These are per-process and are safe to reuse for all threads
-#ifndef UPNPDISCOVER_SUCCESS
-/* miniupnpc 1.5 */
-UPNPDev* (*upnpDiscoverFunc) (int, const char *, const char *, int);
-int (*UPNP_AddPortMappingFunc) (const char *, const char *, const char *, const char *,
-                                             const char *, const char *, const char *, const char *);
-#else
-/* miniupnpc 1.6 */
-UPNPDev* (*upnpDiscoverFunc) (int, const char *, const char *, int, int, int *);
-int (*UPNP_AddPortMappingFunc) (const char *, const char *, const char *, const char *,
-                                             const char *, const char *, const char *, const char *, const char *);
-#endif
-int (*UPNP_GetValidIGDFunc) (struct UPNPDev *, struct UPNPUrls *, struct IGDdatas *, char *, int);
-int (*UPNP_GetExternalIPAddressFunc) (const char *, const char *, char *);
-int (*UPNP_DeletePortMappingFunc) (const char *, const char *, const char *, const char *, const char *);
-void (*freeUPNPDevlistFunc) (struct UPNPDev *);
-void (*FreeUPNPUrlsFunc) (struct UPNPUrls *);
-
-// Nice approach http://stackoverflow.com/a/21517513/673826
-template<class M, typename F>
-F GetKnownProcAddressImpl(M hmod, const char *name, F) {
-    auto proc = reinterpret_cast<F>(dlsym(hmod, name));
-    if (!proc) {
-        LogPrint(eLogError, "UPnP: Error resolving ", name, " from library, version mismatch?");
-    }
-    return proc;
-}
-#define GetKnownProcAddress(hmod, func) GetKnownProcAddressImpl(hmod, #func, func##Func);
-
-
-namespace i2p
-{
-namespace transport
-{
-    UPnP::UPnP () : m_Thread (nullptr) , m_IsModuleLoaded (false)
-    {
-    }
-
-    void UPnP::Stop ()
-    {
-        if (m_Thread)
-        {   
-            m_Thread->join (); 
-            delete m_Thread;
-            m_Thread = nullptr;
-        }
-    }
-
-    void UPnP::Start()
-    {
-        if (!m_IsModuleLoaded) {
-#ifdef MAC_OSX
-            m_Module = dlopen ("libminiupnpc.dylib", RTLD_LAZY);
-#elif _WIN32
-            m_Module = LoadLibrary ("miniupnpc.dll"); // official prebuilt binary, e.g., in upnpc-exe-win32-20140422.zip
-#else
-            m_Module = dlopen ("libminiupnpc.so", RTLD_LAZY);
-#endif
-            if (m_Module == NULL)
-            {
-                LogPrint (eLogError, "UPnP: Error loading UPNP library, version mismatch?");
-                return;
-            }
-            else
-            {
-                upnpDiscoverFunc = GetKnownProcAddress (m_Module, upnpDiscover);
-                UPNP_GetValidIGDFunc = GetKnownProcAddress (m_Module, UPNP_GetValidIGD);
-                UPNP_GetExternalIPAddressFunc = GetKnownProcAddress (m_Module, UPNP_GetExternalIPAddress);
-                UPNP_AddPortMappingFunc = GetKnownProcAddress (m_Module, UPNP_AddPortMapping);
-                UPNP_DeletePortMappingFunc = GetKnownProcAddress (m_Module, UPNP_DeletePortMapping);
-                freeUPNPDevlistFunc = GetKnownProcAddress (m_Module, freeUPNPDevlist);
-                FreeUPNPUrlsFunc = GetKnownProcAddress (m_Module, FreeUPNPUrls);
-                if (upnpDiscoverFunc && UPNP_GetValidIGDFunc && UPNP_GetExternalIPAddressFunc && UPNP_AddPortMappingFunc &&
-                    UPNP_DeletePortMappingFunc && freeUPNPDevlistFunc && FreeUPNPUrlsFunc)
-                    m_IsModuleLoaded = true;
-            }
-        }
-        m_Thread = new std::thread (std::bind (&UPnP::Run, this));
-    }
-    
-    UPnP::~UPnP ()
-    {
-    } 
-
-    void UPnP::Run ()
-    {
-        for (auto& address : context.GetRouterInfo ().GetAddresses ())
-        {
-            if (!address.host.is_v6 ())
-            {
-                Discover ();
-                if (address.transportStyle == data::RouterInfo::eTransportSSU )
-                {
-                    TryPortMapping (I2P_UPNP_UDP, address.port);
-                }
-                else if (address.transportStyle == data::RouterInfo::eTransportNTCP )
-                {
-                    TryPortMapping (I2P_UPNP_TCP, address.port);
-                }
-            }
-        }
-    } 
-        
-    void UPnP::Discover ()
-    {
-#ifndef UPNPDISCOVER_SUCCESS
-        /* miniupnpc 1.5 */
-        m_Devlist = upnpDiscoverFunc (2000, m_MulticastIf, m_Minissdpdpath, 0);
-#else
-        /* miniupnpc 1.6 */
-        int nerror = 0;
-        m_Devlist = upnpDiscoverFunc (2000, m_MulticastIf, m_Minissdpdpath, 0, 0, &nerror);
-#endif
-
-        int r;
-        r = UPNP_GetValidIGDFunc (m_Devlist, &m_upnpUrls, &m_upnpData, m_NetworkAddr, sizeof (m_NetworkAddr));
-        if (r == 1)
-        {
-            r = UPNP_GetExternalIPAddressFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, m_externalIPAddress);
-            if(r != UPNPCOMMAND_SUCCESS)
-            {
-                LogPrint (eLogError, "UPnP: UPNP_GetExternalIPAddress () returned ", r);
-                return;
-            }
-            else
-            {
-                if (m_externalIPAddress[0])
-                {
-                    LogPrint (eLogInfo, "UPnP: ExternalIPAddress = ", m_externalIPAddress);
-                    i2p::context.UpdateAddress (boost::asio::ip::address::from_string (m_externalIPAddress));
-                    return;
-                }
-                else
-                {
-                    LogPrint (eLogError, "UPnP: GetExternalIPAddress failed.");
-                    return;
-                }
-            }
-        }
-    }
-
-    void UPnP::TryPortMapping (int type, int port)
-    {
-        std::string strType, strPort (std::to_string (port));
-        switch (type)
-        {
-            case I2P_UPNP_TCP:
-                strType = "TCP";
-                break;
-            case I2P_UPNP_UDP:
-            default:
-                strType = "UDP";
-        }
-        int r;
-        std::string strDesc = "I2Pd";
-        try {
-            for (;;) {
-#ifndef UPNPDISCOVER_SUCCESS
-                /* miniupnpc 1.5 */
-                r = UPNP_AddPortMappingFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, strPort.c_str (), strPort.c_str (), m_NetworkAddr, strDesc.c_str (), strType.c_str (), 0);
-#else
-                /* miniupnpc 1.6 */
-                r = UPNP_AddPortMappingFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, strPort.c_str (), strPort.c_str (), m_NetworkAddr, strDesc.c_str (), strType.c_str (), 0, "0");
-#endif
-                if (r!=UPNPCOMMAND_SUCCESS)
-                {
-                    LogPrint (eLogError, "UPnP: AddPortMapping (", strPort.c_str () ,", ", strPort.c_str () ,", ", m_NetworkAddr, ") failed with code ", r);
-                    return;
-                }
-                else
-                {
-                    LogPrint (eLogDebug, "UPnP: Port Mapping successful. (", m_NetworkAddr ,":", strPort.c_str(), " type ", strType.c_str () ," -> ", m_externalIPAddress ,":", strPort.c_str() ,")");
-                    return;
-                }
-                std::this_thread::sleep_for(std::chrono::minutes(20)); // c++11
-                //boost::this_thread::sleep_for(); // pre c++11
-                //sleep(20*60); // non-portable
-            }
-        }
-        catch (boost::thread_interrupted)
-        {
-            CloseMapping(type, port);
-            Close();
-            throw;
-        }
-    }
-
-    void UPnP::CloseMapping (int type, int port)
-    {
-        std::string strType, strPort (std::to_string (port));
-        switch (type)
-        {
-            case I2P_UPNP_TCP:
-                strType = "TCP";
-                break;
-            case I2P_UPNP_UDP:
-            default:
-                strType = "UDP";
-        }
-        int r = 0;
-        r = UPNP_DeletePortMappingFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, strPort.c_str (), strType.c_str (), 0);
-        LogPrint (eLogError, "UPnP: DeletePortMapping() returned : ", r, "\n");
-    }
-
-    void UPnP::Close ()
-    {
-        freeUPNPDevlistFunc (m_Devlist);
-        m_Devlist = 0;
-        FreeUPNPUrlsFunc (&m_upnpUrls);
-#ifndef _WIN32
-        dlclose (m_Module);
-#else
-        FreeLibrary (m_Module);
-#endif
-    }
-
-}
-}
-
-
-#endif
-

UPnP.h

@@ -1,63 +0,0 @@
-#ifndef __UPNP_H__
-#define __UPNP_H__
-
-#ifdef USE_UPNP
-#include <string>
-#include <thread>
-
-#include <miniupnpc/miniwget.h>
-#include <miniupnpc/miniupnpc.h>
-#include <miniupnpc/upnpcommands.h>
-#include <miniupnpc/upnperrors.h>
-
-#include <boost/asio.hpp>
-
-#include "util.h"
-
-#define I2P_UPNP_TCP 1
-#define I2P_UPNP_UDP 2
-
-namespace i2p
-{
-namespace transport
-{
-	class UPnP
-	{
-	public:
-
-		UPnP ();
-		~UPnP ();
-        void Close ();
-
-        void Start ();
-        void Stop ();
-
-		void Discover ();
-		void TryPortMapping (int type, int port);
-		void CloseMapping (int type, int port);
-	private:
-		void Run ();
-
-        std::thread * m_Thread;
-        struct UPNPUrls m_upnpUrls;
-        struct IGDdatas m_upnpData;
-
-        // For miniupnpc
-        char * m_MulticastIf = 0;
-        char * m_Minissdpdpath = 0;
-        struct UPNPDev * m_Devlist = 0;
-        char m_NetworkAddr[64];
-        char m_externalIPAddress[40];
-        bool m_IsModuleLoaded;
-#ifndef _WIN32
-        void *m_Module;
-#else
-        HINSTANCE m_Module;
-#endif
-	};
-}
-}
-
-#endif
-
-#endif

Win32/.gitignore

@@ -1,14 +0,0 @@
-*
-!*/
-
-!*.h
-!*.cpp
-
-!*.bat
-
-!*.sln
-!*.vcproj
-!*.vcxproj
-!*.vcxproj.filters
-!*.iss
-!.gitignore

Win32/DaemonWin32.cpp

@@ -0,0 +1,89 @@
+/*
+* Copyright (c) 2013-2020, The PurpleI2P Project
+*
+* This file is part of Purple i2pd project and licensed under BSD3
+*
+* See full license text in LICENSE file at top of project tree
+*/
+
+#include <thread>
+#include <clocale>
+#include "Config.h"
+#include "Daemon.h"
+#include "util.h"
+#include "Log.h"
+
+#ifdef _WIN32
+#ifdef WIN32_APP
+#include <windows.h>
+#include "Win32App.h"
+#endif
+
+namespace i2p
+{
+namespace util
+{
+	bool DaemonWin32::init(int argc, char* argv[])
+	{
+		setlocale(LC_CTYPE, "");
+		SetConsoleCP(1251);
+		SetConsoleOutputCP(1251);
+		setlocale(LC_ALL, "Russian");
+		setlocale(LC_TIME, "C");
+
+		i2p::log::SetThrowFunction ([](const std::string& s)
+			{
+				MessageBox(0, TEXT(s.c_str ()), TEXT("i2pd"), MB_ICONERROR | MB_TASKMODAL | MB_OK );
+			}
+		);
+
+		if (!Daemon_Singleton::init(argc, argv))
+			return false;
+		return true;
+	}
+
+	bool DaemonWin32::start()
+	{
+		setlocale(LC_CTYPE, "");
+		SetConsoleCP(1251);
+		SetConsoleOutputCP(1251);
+		setlocale(LC_ALL, "Russian");
+		setlocale(LC_TIME, "C");
+#ifdef WIN32_APP
+		if (!i2p::win32::StartWin32App ()) return false;
+#endif
+		bool ret = Daemon_Singleton::start();
+		if (ret && i2p::log::Logger().GetLogType() == eLogFile)
+		{
+			// TODO: find out where this garbage to console comes from
+			SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);
+			SetStdHandle(STD_ERROR_HANDLE, INVALID_HANDLE_VALUE);
+		}
+		bool insomnia; i2p::config::GetOption("insomnia", insomnia);
+		if (insomnia)
+			SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
+		return ret;
+	}
+
+	bool DaemonWin32::stop()
+	{
+#ifdef WIN32_APP
+		i2p::win32::StopWin32App ();
+#endif
+		return Daemon_Singleton::stop();
+	}
+
+	void DaemonWin32::run ()
+	{
+#ifdef WIN32_APP
+		i2p::win32::RunWin32App ();
+#else
+		while (running)
+		{
+			std::this_thread::sleep_for (std::chrono::seconds(1));
+		}
+#endif
+	}
+}
+}
+#endif //_WIN32

Win32/Itoopie.cmd

@@ -1,14 +0,0 @@
-@echo off
-convert Itoopie.svg ^
-  -fuzz 90%% -fill transparent -floodfill 2x2 white -fuzz 20%% -fill #AE0E99 -opaque red ^
-  -fill #FBBC11 -opaque yellow ^
-  ( -clone 0 -resize 256x256  ) ^
-  ( -clone 0 -resize 128x128  ) ^
-  ( -clone 0 -resize  64x64   ) ^
-  ( -clone 0 -resize  48x48   ) ^
-  ( -clone 0 -resize  32x32   ) ^
-  ( -clone 0 -resize  24x24   ) ^
-  ( -clone 0 -resize  16x16   ) ^
-  ( -size 150x57 xc:white -clone 0 -geometry 57x57+46+0 -composite -gravity center -write BMP3:ictoopie.bmp +delete ) ^
-  ( -clone 0 -write Itoopie_purple.png +delete ) ^
-  -delete 0 ictoopie.ico

Win32/PurpleI2P.nsi

@@ -1,282 +0,0 @@
-# NSIS Installer script. (Tested with NSIS 2.64 on Windows 7)
-# Author: Mikal Villa (Meeh)
-# Version: 1.1
-Name PurpleI2P
-
-RequestExecutionLevel highest
-SetCompressor /SOLID lzma
-ShowInstDetails show
-
-# General Symbol Definitions
-!define REGKEY "SOFTWARE\$(^Name)"
-!define VERSION 0.3.0.0
-!define COMPANY "The Privacy Solutions Project"
-!define URL "https://i2p.io"
-
-# MUI Symbol Definitions
-!define MUI_ICON "ictoopie.ico"
-#!define MUI_WELCOMEFINISHPAGE_BITMAP "../share/pixmaps/nsis-wizard.bmp"
-!define MUI_HEADERIMAGE
-!define MUI_HEADERIMAGE_RIGHT
-#!define MUI_HEADERIMAGE_BITMAP "../share/pixmaps/nsis-header.bmp"
-!define MUI_FINISHPAGE_NOAUTOCLOSE
-!define MUI_STARTMENUPAGE_REGISTRY_ROOT HKLM
-!define MUI_STARTMENUPAGE_REGISTRY_KEY ${REGKEY}
-!define MUI_STARTMENUPAGE_REGISTRY_VALUENAME StartMenuGroup
-!define MUI_STARTMENUPAGE_DEFAULTFOLDER PurpleI2P
-!define MUI_FINISHPAGE_RUN $INSTDIR\i2pd.exe
-!define MUI_FINISHPAGE_SHOWREADME $INSTDIR\Readme.txt
-
-
-!define MUI_UNICON "${NSISDIR}\Contrib\Graphics\Icons\modern-uninstall.ico"
-!define MUI_UNWELCOMEFINISHPAGE_BITMAP "../share/pixmaps/nsis-wizard.bmp"
-!define MUI_UNFINISHPAGE_NOAUTOCLOSE
-
-# Included files
-!include Sections.nsh
-!include MUI2.nsh
-!include nsDialogs.nsh
-!include winmessages.nsh
-!include logiclib.nsh
-# Local included files
-!include nsi\helper_readme.nsh
-;!include nsi\servicelib.nsh
-
-# Variables
-Var StartMenuGroup
-
-# Installer pages
-# Execution flow of installer windows
-!insertmacro MUI_PAGE_WELCOME
-!insertmacro MUI_PAGE_README "../Readme.md"
-!insertmacro MUI_PAGE_DIRECTORY
-# Disabled for now. Use the bat
-;Page custom mode_selection # Meeh's hack for installing and starting service.
-!insertmacro MUI_PAGE_STARTMENU Application $StartMenuGroup
-!insertmacro MUI_PAGE_INSTFILES
-!insertmacro MUI_PAGE_FINISH
-
-# Uninstall pages
-!insertmacro MUI_UNPAGE_CONFIRM
-!insertmacro MUI_UNPAGE_INSTFILES
-
-# Installer languages
-!insertmacro MUI_LANGUAGE English
-
-# Installer attributes
-OutFile PurpleI2P-0.3.0.0-win32-setup.exe
-InstallDir $PROGRAMFILES\PurpleI2P
-CRCCheck on
-XPStyle on
-BrandingText " "
-ShowInstDetails show
-VIProductVersion 0.3.0.0
-VIAddVersionKey ProductName PurpleI2P
-VIAddVersionKey ProductVersion "${VERSION}"
-VIAddVersionKey CompanyName "${COMPANY}"
-VIAddVersionKey CompanyWebsite "${URL}"
-VIAddVersionKey FileVersion "${VERSION}"
-VIAddVersionKey FileDescription ""
-VIAddVersionKey LegalCopyright ""
-InstallDirRegKey HKCU "${REGKEY}" Path
-ShowUninstDetails show
-
-# Readme definitions
-
-;--------------------------------
-;Languages
-  ;Set up install lang strings for 1st lang
-  ${ReadmeLanguage} "${LANG_ENGLISH}" \
-          "Read Me" \
-          "Please review the following important information." \
-          "About $(^name):" \
-          "$\n  Click on scrollbar arrows or press Page Down to review the entire text."
- 
-  ;Add 2nd language
-  !insertmacro MUI_LANGUAGE "Norwegian"
- 
-  ;set up install lang strings for second lang
-  ${ReadmeLanguage} "${LANG_NORWEGIAN}" \
-          "Les meg!" \
-          "Vennligst les informasjonen om hvordan du skal bruke PurpleI2P." \
-          "Om $(^name):" \
-          "$\n  Klikk på scrollbaren til høyre for å se hele innholdet."
- 
-;--------------------------------
-
-# Installer sections
-Section -Main SEC0000
-    SetOutPath $INSTDIR
-    SetOverwrite on
-    File /oname=i2pd.exe Release\i2pd.exe
-    File /oname=install_service.bat install_service.bat
-    File /oname=uninstall_service.bat uninstall_service.bat
-    File /oname=LICENSE.txt ..\LICENSE
-    File /oname=Readme.txt ..\README.md
-    SetOutPath $INSTDIR\src
-    File /r /x *.nsi /x *.rc /x *.exe /x *.obj /x *.nsh /x *.sln /x *.vcxproj /x *.tlog /x *.log /x *.res /x *.pdb /x *.suo /x *.opensdf /x *.filters /x *.sdf /x *.iss /x *.aps /x .gitignore /x *.o ../\*.*
-    SetOutPath $INSTDIR
-    RMDir /r /REBOOTOK $INSTDIR\src\.git # Remove git directory
-    RMDir /r /REBOOTOK $INSTDIR\src\Win32\Release # Removing release directory
-    RMDir /r /REBOOTOK $INSTDIR\src\Win32\nsi
-    WriteRegStr HKCU "${REGKEY}\Components" Main 1
-SectionEnd
-
-Section -post SEC0001
-    WriteRegStr HKCU "${REGKEY}" Path $INSTDIR
-    SetOutPath $INSTDIR
-    WriteUninstaller $INSTDIR\uninstall.exe
-    !insertmacro MUI_STARTMENU_WRITE_BEGIN Application
-    CreateDirectory $SMPROGRAMS\$StartMenuGroup
-    CreateShortcut "$SMPROGRAMS\$StartMenuGroup\PurpleI2P.lnk" $INSTDIR\i2pd.exe
-    CreateShortcut "$SMPROGRAMS\$StartMenuGroup\Install PurpleI2P Service.lnk" $INSTDIR\install_service.bat
-    CreateShortcut "$SMPROGRAMS\$StartMenuGroup\Uninstall PurpleI2P Service.lnk" $INSTDIR\uninstall_service.bat
-    CreateShortcut "$SMPROGRAMS\$StartMenuGroup\Uninstall PurpleI2P.lnk" $INSTDIR\uninstall.exe
-    !insertmacro MUI_STARTMENU_WRITE_END
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" DisplayName "$(^Name)"
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" DisplayVersion "${VERSION}"
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" Publisher "${COMPANY}"
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" URLInfoAbout "${URL}"
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" DisplayIcon $INSTDIR\uninstall.exe
-    WriteRegStr HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" UninstallString $INSTDIR\uninstall.exe
-    WriteRegDWORD HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" NoModify 1
-    WriteRegDWORD HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)" NoRepair 1
-    WriteRegStr HKCR "i2pd" "URL Protocol" ""
-    WriteRegStr HKCR "i2pd" "" "URL:i2pd" # TODO: if a instance of own is found, relaunch with a proxyfied browser to open webage. (e.g i2pd://meeh.i2p)
-    WriteRegStr HKCR "i2pd\DefaultIcon" "" $INSTDIR\i2pd.exe
-    WriteRegStr HKCR "i2pd\shell\open\command" "" '"$INSTDIR\i2pd.exe" "%1"'
-SectionEnd
-
-# Macro for selecting uninstaller sections
-!macro SELECT_UNSECTION SECTION_NAME UNSECTION_ID
-    Push $R0
-    ReadRegStr $R0 HKCU "${REGKEY}\Components" "${SECTION_NAME}"
-    StrCmp $R0 1 0 next${UNSECTION_ID}
-    !insertmacro SelectSection "${UNSECTION_ID}"
-    GoTo done${UNSECTION_ID}
-next${UNSECTION_ID}:
-    !insertmacro UnselectSection "${UNSECTION_ID}"
-done${UNSECTION_ID}:
-    Pop $R0
-!macroend
-
-
-# Uninstaller sections
-Section /o -un.Main UNSEC0000
-    Delete /REBOOTOK $INSTDIR\i2pd.exe
-    Delete /REBOOTOK $INSTDIR\LICENSE.txt
-    Delete /REBOOTOK $INSTDIR\Readme.txt
-    Delete /REBOOTOK $INSTDIR\install_service.bat
-    Delete /REBOOTOK $INSTDIR\uninstall_service.bat
-    RMDir /r /REBOOTOK $INSTDIR\src
-    DeleteRegValue HKCU "${REGKEY}\Components" Main
-SectionEnd
-
-Section -un.post UNSEC0001
-    DeleteRegKey HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$(^Name)"
-    Delete /REBOOTOK "$SMPROGRAMS\$StartMenuGroup\Uninstall PurpleI2P.lnk"
-    Delete /REBOOTOK "$SMPROGRAMS\$StartMenuGroup\PurpleI2P.lnk"
-    Delete /REBOOTOK "$SMPROGRAMS\$StartMenuGroup\Install PurpleI2P Service.lnk"
-    Delete /REBOOTOK "$SMPROGRAMS\$StartMenuGroup\UnInstall PurpleI2P Service.lnk"
-    Delete /REBOOTOK "$SMSTARTUP\PurpleI2P.lnk"
-    Delete /REBOOTOK $INSTDIR\uninstall.exe
-    Delete /REBOOTOK $INSTDIR\debug.log
-    DeleteRegValue HKCU "${REGKEY}" StartMenuGroup
-    DeleteRegValue HKCU "${REGKEY}" Path
-    DeleteRegKey /IfEmpty HKCU "${REGKEY}\Components"
-    DeleteRegKey /IfEmpty HKCU "${REGKEY}"
-    DeleteRegKey HKCR "i2pd"
-    RmDir /REBOOTOK $SMPROGRAMS\$StartMenuGroup
-    RmDir /REBOOTOK $INSTDIR
-    Push $R0
-    StrCpy $R0 $StartMenuGroup 1
-    StrCmp $R0 ">" no_smgroup
-no_smgroup:
-    Pop $R0
-SectionEnd
-
-; var hwndExecModeRadio
-; var hwndRunServiceNowRadio
-
-; Function mode_selection
-;     nsDialogs::Create 1018 
-;     Pop $0
-;     ${NSD_CreateLabel} 0 10 75% 20u "How would you like PurpleI2P (i2pd) to run?"
-;     Pop $0 
-
-;     ${NSD_CreateRadioButton} 20 60 80% 25u "Service Mode"
-;     Pop $hwndExecModeRadio
-;     ${NSD_AddStyle} $hwndExecModeRadio ${WS_GROUP}
-
-;     ${NSD_CreateRadioButton} 20 90 80% 25u "Command line Mode"
-;     Pop $0
-
-;     ${NSD_CreateButton} 20 150 -40 14u "Do it!"
-;     Pop $0
-;     ${NSD_OnClick} $0 perform_mode
-
-;     nsDialogs::Show
-; FunctionEnd
-
-; Function start_now_selection
-;     nsDialogs::Create 1018 
-;     Pop $0
-;     ${NSD_CreateLabel} 0 10 75% 20u "Enable the service now?"
-;     Pop $0 
-
-;     ${NSD_CreateRadioButton} 20 60 80% 25u "Yes"
-;     Pop $hwndRunServiceNowRadio
-;     ${NSD_AddStyle} $hwndRunServiceNowRadio ${WS_GROUP}
-
-;     ${NSD_CreateRadioButton} 20 90 80% 25u "No"
-;     Pop $0
-
-;     ${NSD_CreateButton} 20 150 -40 14u "Do it!"
-;     Pop $0
-;     ${NSD_OnClick} $0 perform_mode
-
-;     nsDialogs::Show
-; FunctionEnd
-
-; Function perform_mode
-;     ${NSD_GetState} $hwndExecModeRadio $0
-;     ${If} $0 = ${BST_CHECKED}
-;         Call service_mode
-;     ${EndIF}
-; FunctionEnd
-
-; Function start_now
-;     ${NSD_GetState} $hwndRunServiceNowRadio $0
-;     ${If} $0 = ${BST_CHECKED}
-;         Call start_now_selection
-;     ${EndIF}
-; FunctionEnd
-
-; Function service_mode
-;     Push "create"
-;     Push "PurpleI2P Service"
-;     Push "$INSTDIR\i2pd.exe;autostart=1;display=PurpleI2P"
-;     Call Service
-;     Pop $0 ; Actually more to write than !insertmacro, but much more fun :D
-;     Push "start"
-;     Push "PurpleI2P Service"
-;     Call Service
-;     Pop $0
-;     Call start_now
-;     !define MUI_FINISHPAGE_RUN_NOTCHECKED
-;     !define MUI_FINISHPAGE_RUN_TEXT "No need to run now since we already installed and launched it as a Windows service!"
-; FunctionEnd
-
-# Installer functions
-Function .onInit
-    InitPluginsDir
-    !insertmacro MUI_LANGDLL_DISPLAY
-FunctionEnd
-
-# Uninstaller functions
-Function un.onInit
-    ReadRegStr $INSTDIR HKCU "${REGKEY}" Path
-    !insertmacro MUI_STARTMENU_GETFOLDER Application $StartMenuGroup
-    !insertmacro SELECT_UNSECTION Main ${UNSEC0000}
-    !insertmacro MUI_UNGETLANGUAGE
-FunctionEnd

Win32/Resource.rc

@@ -1,72 +1,36 @@
-// Microsoft Visual C++ generated resource script.
-//
 #include "resource.h"
 
 #define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
 #include "winres.h"
-
-/////////////////////////////////////////////////////////////////////////////
 #undef APSTUDIO_READONLY_SYMBOLS
 
-/////////////////////////////////////////////////////////////////////////////
-// English (United States) resources
-
 #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 #pragma code_page(1252)
 
 #ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
 1 TEXTINCLUDE 
 BEGIN
     "resource.h\0"
 END
 
-2 TEXTINCLUDE 
+2 TEXTINCLUDE
 BEGIN
     "#include ""winres.h""\r\n"
     "\0"
 END
 
-3 TEXTINCLUDE 
+3 TEXTINCLUDE
 BEGIN
     "\r\n"
     "\0"
 END
+#endif		// APSTUDIO_INVOKED
 
-#endif    // APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Icon
-//
-
-// Icon with lowest ID value placed first to ensure application icon
-// remains consistent on all systems.
-MAINICON                ICON                    "ictoopie.ico"
-
-#endif    // English (United States) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
+MAINICON ICON "mask.ico"
+#endif		// English (United States) resources
 
 #ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
 #include "Resource.rc2"
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
+#endif		// not APSTUDIO_INVOKED
 

Win32/Resource.rc2

@@ -1,17 +1,8 @@
-//
-// Resource.RC2 - resources Microsoft Visual C++ does not edit directly
-//
-
 #ifdef APSTUDIO_INVOKED
 #error this file is not editable by Microsoft Visual C++
 #endif //APSTUDIO_INVOKED
 
-#include "../version.h"
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Version
-//
+#include "../libi2pd/version.h"
 
 VS_VERSION_INFO VERSIONINFO
  FILEVERSION I2PD_VERSION_MAJOR,I2PD_VERSION_MINOR,I2PD_VERSION_MICRO,I2PD_VERSION_PATCH
@@ -34,7 +25,7 @@ BEGIN
             VALUE "FileDescription", "C++ I2P daemon"
             VALUE "FileVersion", I2PD_VERSION
             VALUE "InternalName", CODENAME
-            VALUE "LegalCopyright", "Copyright (C) 2013-2015, The PurpleI2P Project"
+            VALUE "LegalCopyright", "Copyright (C) 2013-2020, The PurpleI2P Project"
             VALUE "OriginalFilename", "i2pd"
             VALUE "ProductName", "Purple I2P"
             VALUE "ProductVersion", I2P_VERSION

Win32/Win32App.cpp

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

Win32/Win32App.h

@@ -0,0 +1,27 @@
+/*
+* Copyright (c) 2013-2020, The PurpleI2P Project
+*
+* This file is part of Purple i2pd project and licensed under BSD3
+*
+* See full license text in LICENSE file at top of project tree
+*/
+
+#ifndef WIN32APP_H__
+#define WIN32APP_H__
+
+#define I2PD_WIN32_CLASSNAME "i2pd main window"
+
+namespace i2p
+{
+namespace win32
+{
+	extern DWORD g_GracefulShutdownEndtime;
+
+	bool StartWin32App ();
+	void StopWin32App ();
+	int RunWin32App ();
+	bool GracefulShutdown ();
+	bool StopGracefulShutdown ();
+}
+}
+#endif // WIN32APP_H__

Win32/Win32NetState.cpp

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

Win32/Win32NetState.h

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

Win32/Win32Service.cpp

@@ -1,462 +0,0 @@
-#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 "../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) ? (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(eLogError, "Win32Service Start", dwError);
-
-		SetServiceStatus(SERVICE_STOPPED, dwError);
-	}
-	catch (...)
-	{
-		LogPrint(eLogError, "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();
-
-	//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(eLogInfo, "Win32Service Stop", dwError);
-
-		SetServiceStatus(dwOriginalState);
-	}
-	catch (...)
-	{
-		LogPrint(eLogError, "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(eLogError, "Win32Service Pause", dwError);
-
-		SetServiceStatus(SERVICE_RUNNING);
-	}
-	catch (...)
-	{
-		LogPrint(eLogError, "Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
-
-		SetServiceStatus(SERVICE_RUNNING);
-	}
-}
-
-
-void I2PService::OnPause()
-{
-}
-
-
-void I2PService::Continue()
-{
-	try
-	{
-		SetServiceStatus(SERVICE_CONTINUE_PENDING);
-
-		OnContinue();
-
-		SetServiceStatus(SERVICE_RUNNING);
-	}
-	catch (DWORD dwError)
-	{
-		LogPrint(eLogError, "Win32Service Continue", dwError);
-
-		SetServiceStatus(SERVICE_PAUSED);
-	}
-	catch (...)
-	{
-		LogPrint(eLogError, "Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
-
-		SetServiceStatus(SERVICE_PAUSED);
-	}
-}
-
-
-void I2PService::OnContinue()
-{
-}
-
-
-void I2PService::Shutdown()
-{
-	try
-	{
-		OnShutdown();
-
-		SetServiceStatus(SERVICE_STOPPED);
-	}
-	catch (DWORD dwError)
-	{
-		LogPrint(eLogError, "Win32Service Shutdown", dwError);
-	}
-	catch (...)
-	{
-		LogPrint(eLogError, "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);
-}

Win32/Win32Service.h

@@ -1,84 +0,0 @@
-#ifndef WIN_32_SERVICE_H__
-#define WIN_32_SERVICE_H__
-
-#include <thread>
-#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__

Win32/i2pd.sln

@@ -1,30 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.30723.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "i2pd", "i2pd.vcxproj", "{930568EC-31C9-406A-AD1C-9636DF5D8FAA}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Debug|x64 = Debug|x64
-		Release|Win32 = Release|Win32
-		Release|x64 = Release|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Debug|Win32.ActiveCfg = Debug|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Debug|Win32.Build.0 = Debug|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Debug|Win32.Deploy.0 = Debug|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Debug|x64.ActiveCfg = Debug|x64
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Debug|x64.Build.0 = Debug|x64
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Release|Win32.ActiveCfg = Release|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Release|Win32.Build.0 = Release|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Release|Win32.Deploy.0 = Release|Win32
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Release|x64.ActiveCfg = Release|x64
-		{930568EC-31C9-406A-AD1C-9636DF5D8FAA}.Release|x64.Build.0 = Release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

Win32/i2pd.vcxproj

@@ -1,292 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\AddressBook.cpp" />
-    <ClCompile Include="..\aes.cpp" />
-    <ClCompile Include="..\base64.cpp" />
-    <ClCompile Include="..\BOB.cpp" />
-    <ClCompile Include="..\CryptoConst.cpp" />
-    <ClCompile Include="..\Daemon.cpp" />
-    <ClCompile Include="..\DaemonWin32.cpp" />
-    <ClCompile Include="..\Garlic.cpp" />
-    <ClCompile Include="..\HTTPProxy.cpp" />
-    <ClCompile Include="..\HTTPServer.cpp" />
-    <ClCompile Include="..\I2NPProtocol.cpp" />
-    <ClCompile Include="..\i2p.cpp" />
-    <ClCompile Include="..\I2PEndian.cpp" />
-    <ClCompile Include="..\I2PService.cpp" />
-    <ClCompile Include="..\Identity.cpp" />
-    <ClCompile Include="..\LeaseSet.cpp" />
-    <ClCompile Include="..\Log.cpp" />
-    <ClCompile Include="..\NetDb.cpp" />
-	<ClCompile Include="..\NetDbRequests.cpp" />
-    <ClCompile Include="..\NTCPSession.cpp" />
-	<ClCompile Include="..\Profiling.cpp" />
-    <ClCompile Include="..\Reseed.cpp" />
-    <ClCompile Include="..\RouterContext.cpp" />
-    <ClCompile Include="..\RouterInfo.cpp" />
-	<ClCompile Include="..\Signature.cpp" />	
-    <ClCompile Include="..\SAM.cpp" />
-    <ClCompile Include="..\SSU.cpp" />
-    <ClCompile Include="..\SSUData.cpp" />
-    <ClCompile Include="..\SSUSession.cpp" />
-    <ClCompile Include="..\Streaming.cpp" />
-    <ClCompile Include="..\Datagram.cpp" />
-    <ClCompile Include="..\Destination.cpp" />
-    <ClCompile Include="..\TransitTunnel.cpp" />
-    <ClCompile Include="..\Transports.cpp" />
-    <ClCompile Include="..\Tunnel.cpp" />
-    <ClCompile Include="..\TunnelEndpoint.cpp" />
-    <ClCompile Include="..\TunnelGateway.cpp" />
-    <ClCompile Include="..\TunnelPool.cpp" />
-    <ClCompile Include="..\UPnP.cpp" />
-    <ClCompile Include="..\util.cpp" />
-    <ClCompile Include="..\SOCKS.cpp" />
-    <ClCompile Include="..\I2PTunnel.cpp" />
-    <ClCompile Include="..\I2PControl.cpp" />
-    <ClCompile Include="..\ClientContext.cpp" />
-    <ClCompile Include="Win32Service.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\AddressBook.h" />
-    <ClInclude Include="..\base64.h" />
-    <ClInclude Include="..\BOB.h" />
-    <ClInclude Include="..\CryptoConst.h" />
-    <ClInclude Include="..\Daemon.h" />
-    <ClInclude Include="..\ElGamal.h" />
-    <ClInclude Include="..\Garlic.h" />
-    <ClInclude Include="..\HTTPProxy.h" />
-    <ClInclude Include="..\HTTPServer.h" />
-    <ClInclude Include="..\I2NPProtocol.h" />
-    <ClInclude Include="..\I2PEndian.h" />
-    <ClInclude Include="..\I2PService.h" />
-    <ClInclude Include="..\Identity.h" />
-    <ClInclude Include="..\LeaseSet.h" />
-    <ClInclude Include="..\LittleBigEndian.h" />
-    <ClInclude Include="..\Log.h" />
-	<ClInclude Include="..\NetDbRequests.h" />
-    <ClInclude Include="..\NetDb.h" />
-    <ClInclude Include="..\NTCPSession.h" />
-    <ClInclude Include="..\Queue.h" />
-	<ClInclude Include="..\Profiling.h" />
-    <ClInclude Include="..\Reseed.h" />
-    <ClInclude Include="..\RouterContext.h" />
-    <ClInclude Include="..\RouterInfo.h" />
-    <ClInclude Include="..\SAM.h" />
-    <ClInclude Include="..\SSU.h" />
-    <ClInclude Include="..\SSUData.h" />
-    <ClInclude Include="..\SSUSession.h" />
-    <ClInclude Include="..\Streaming.h" />
-    <ClInclude Include="..\Datagram.h" />
-    <ClInclude Include="..\Destination.h" />
-    <ClInclude Include="..\Timestamp.h" />
-    <ClInclude Include="..\TransitTunnel.h" />
-    <ClInclude Include="..\Transports.h" />
-    <ClInclude Include="..\Tunnel.h" />
-    <ClInclude Include="..\TunnelBase.h" />
-    <ClInclude Include="..\TunnelConfig.h" />
-    <ClInclude Include="..\TunnelEndpoint.h" />
-    <ClInclude Include="..\TunnelGateway.h" />
-    <ClInclude Include="..\TunnelPool.h" />
-    <ClInclude Include="..\UPnP.h" />
-    <ClInclude Include="..\util.h" />
-    <ClInclude Include="..\SOCKS.h" />
-    <ClInclude Include="..\I2PTunnel.h" />
-    <ClInclude Include="..\I2PControl.h" />
-    <ClInclude Include="..\version.h" />
-    <ClInclude Include="..\Signature.h" />
-    <ClInclude Include="..\ClientContext.h" />
-    <ClInclude Include="..\TransportSession.h" />
-    <ClInclude Include="resource.h" />
-    <ClInclude Include="Win32Service.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="Resource.rc" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{930568EC-31C9-406A-AD1C-9636DF5D8FAA}</ProjectGuid>
-    <RootNamespace>i2pd</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120_xp</PlatformToolset>
-    <CharacterSet>NotSet</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120_xp</PlatformToolset>
-    <CharacterSet>NotSet</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120_xp</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>NotSet</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120_xp</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>NotSet</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <IncludePath>./..;$(IncludePath);$(BOOST);$(CRYPTOPP);C:\build-lib\cryptopp;C:\build-lib\boost_1_57_0\</IncludePath>
-    <LibraryPath>$(BOOST)\stage\lib;C:\build-lib\cryptopp;C:\build-lib\boost_1_57_0\stage\lib;$(CRYPTOPP)\cryptopp\$(Platform)\Output\$(Configuration);$(LibraryPath)</LibraryPath>
-    <SourcePath>./..;$(VC_SourcePath);</SourcePath>
-    <TargetName>$(ProjectName)_d</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <IncludePath>./..;$(IncludePath);$(BOOST);$(CRYPTOPP)</IncludePath>
-    <LibraryPath>$(BOOST)\stage\lib;$(CRYPTOPP)\cryptopp\$(Platform)\Output\$(Configuration);$(LibraryPath)</LibraryPath>
-    <SourcePath>./..;$(VC_SourcePath);</SourcePath>
-    <TargetName>$(ProjectName)_d</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <IncludePath>./..;$(IncludePath);$(BOOST);C:\build-lib\boost_1_57_0\;C:\build-lib</IncludePath>
-    <LibraryPath>C:\build-lib\boost_1_57_0\stage\lib;C:\build-lib\cryptopp\$(Platform)\Output\$(Configuration);$(LibraryPath)</LibraryPath>
-    <SourcePath>./..;$(VC_SourcePath);</SourcePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <IncludePath>./..;$(IncludePath);$(BOOST);$(CRYPTOPP)</IncludePath>
-    <LibraryPath>$(BOOST)\stage\lib;$(CRYPTOPP)\cryptopp\$(Platform)\Output\$(Configuration);$(LibraryPath)</LibraryPath>
-    <SourcePath>./..;$(VC_SourcePath);</SourcePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PreprocessorDefinitions>_MBCS;_WIN32_WINNT=0x0501;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>cryptlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
-      <UACExecutionLevel>AsInvoker</UACExecutionLevel>
-      <Version>0.2</Version>
-      <SubSystem>Console</SubSystem>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PreprocessorDefinitions>_MBCS;_WIN32_WINNT=0x0502;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>cryptlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
-      <UACExecutionLevel>AsInvoker</UACExecutionLevel>
-      <Version>0.2</Version>
-      <SubSystem>Console</SubSystem>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level2</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>_WIN32_WINNT=0x0501;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <SDLCheck>true</SDLCheck>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>false</OptimizeReferences>
-      <AdditionalDependencies>cryptlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
-      <UACExecutionLevel>AsInvoker</UACExecutionLevel>
-      <Version>
-      </Version>
-      <SubSystem>Console</SubSystem>
-      <MinimumRequiredVersion>5.01</MinimumRequiredVersion>
-      <LinkErrorReporting>NoErrorReport</LinkErrorReporting>
-    </Link>
-    <Manifest>
-      <AssemblyIdentity>
-      </AssemblyIdentity>
-      <ComponentFileName>
-      </ComponentFileName>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>_WIN32_WINNT=0x0502;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <SDLCheck>true</SDLCheck>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>false</OptimizeReferences>
-      <AdditionalDependencies>cryptlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
-      <UACExecutionLevel>AsInvoker</UACExecutionLevel>
-      <Version>
-      </Version>
-      <SubSystem>Console</SubSystem>
-      <MinimumRequiredVersion>5.02</MinimumRequiredVersion>
-      <LinkErrorReporting>NoErrorReport</LinkErrorReporting>
-    </Link>
-    <Manifest>
-      <AssemblyIdentity>
-      </AssemblyIdentity>
-      <ComponentFileName>
-      </ComponentFileName>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

Win32/i2pd.vcxproj.filters

@@ -1,302 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-    <Filter Include="Win32">
-      <UniqueIdentifier>{a880a08c-16b8-4243-82ea-6bfc63bb7dab}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\Identity.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\LeaseSet.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Log.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\NetDb.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\NTCPSession.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\RouterContext.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\RouterInfo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Streaming.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\TransitTunnel.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Transports.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Tunnel.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\TunnelEndpoint.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\TunnelGateway.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\base64.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Garlic.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\HTTPServer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\I2NPProtocol.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\i2p.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\I2PEndian.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\SOCKS.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\SSU.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\util.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Reseed.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\UPnP.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\HTTPProxy.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\TunnelPool.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\AddressBook.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Win32Service.cpp">
-      <Filter>Win32</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Daemon.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\DaemonWin32.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\SSUData.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\CryptoConst.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\aes.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\I2PTunnel.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\SAM.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\SSUSession.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Datagram.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\Destination.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\ClientContext.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\BOB.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\I2PControl.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\I2PService.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\Identity.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\LeaseSet.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\LittleBigEndian.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Log.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\NetDb.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\NTCPSession.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Queue.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\RouterContext.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\RouterInfo.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Streaming.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Timestamp.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TransitTunnel.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Transports.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Tunnel.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TunnelBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TunnelConfig.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TunnelEndpoint.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TunnelGateway.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\base64.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\CryptoConst.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\ElGamal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Garlic.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\HTTPServer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\I2NPProtocol.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\I2PEndian.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\SOCKS.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\SSU.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\util.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Reseed.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\UPnP.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\HTTPProxy.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TunnelPool.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\AddressBook.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Win32Service.h">
-      <Filter>Win32</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Daemon.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\SSUData.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\I2PTunnel.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\version.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Signature.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\SAM.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\SSUSession.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Datagram.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Destination.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\ClientContext.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\TransportSession.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="resource.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\BOB.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\I2PControl.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\I2PService.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="Resource.rc">
-      <Filter>Resource Files</Filter>
-    </ResourceCompile>
-  </ItemGroup>
-</Project>

Win32/inno_installer.iss

@@ -1,149 +0,0 @@
-
-#define I2Pd_AppName "i2pd"
-#define I2Pd_ver "0.2"
-
-[Setup]
-AppName={#I2Pd_AppName}
-AppVersion={#I2Pd_ver}
-DefaultDirName={pf}\I2Pd
-DefaultGroupName=I2Pd
-UninstallDisplayIcon={app}\I2Pd.exe
-Compression=lzma2
-SolidCompression=yes
-OutputDir=.
-LicenseFile=.\..\LICENSE
-OutputBaseFilename=setup_{#I2Pd_AppName}_v{#I2Pd_ver}
-ArchitecturesInstallIn64BitMode=x64
-
-
-[Files]
-Source: "x64\Release\i2pd.exe"; DestDir: "{app}"; DestName: "i2pd.exe"; Check: Is64BitInstallMode
-Source: "Release\i2pd.exe"; DestDir: "{app}"; Check: not Is64BitInstallMode
-Source: "..\README.md"; DestDir: "{app}"; DestName: "Readme.txt"; AfterInstall: ConvertLineEndings
-
-[Icons]
-Name: "{group}\I2Pd"; Filename: "{app}\i2pd.exe"
-Name: "{group}\Readme"; Filename: "{app}\Readme.txt"
-
-
-[Registry]
-Root: HKCU; Subkey: "Environment"; ValueName: "Path"; ValueType: "string"; ValueData: "{app};{olddata}"; Check: NotOnPathAlready(); Flags: preservestringtype;
-
-[Code]
-
-var
-  DefaultTop,
-  DefaultLeft,
-  DefaultHeight,
-  DefaultBackTop,
-  DefaultNextTop,
-  DefaultCancelTop,
-  DefaultBevelTop,
-  DefaultOuterHeight: Integer;
-
-const
-  LicenseHeight = 400;
-   LF = #10;
-   CR = #13;
-   CRLF = CR + LF;
-
-procedure ConvertLineEndings();
-  var
-     FilePath : String;
-     FileContents : String;
-begin
-   FilePath := ExpandConstant(CurrentFileName)
-   LoadStringFromFile(FilePath, FileContents);
-   StringChangeEx(FileContents, LF, CRLF, False);
-   SaveStringToFile(FilePath, FileContents, False);
-end;
-
-procedure InitializeWizard();
-begin
-  DefaultTop := WizardForm.Top;
-  DefaultLeft := WizardForm.Left;
-  DefaultHeight := WizardForm.Height;
-  DefaultBackTop := WizardForm.BackButton.Top;
-  DefaultNextTop := WizardForm.NextButton.Top;
-  DefaultCancelTop := WizardForm.CancelButton.Top;
-  DefaultBevelTop := WizardForm.Bevel.Top;
-  DefaultOuterHeight := WizardForm.OuterNotebook.Height;
-
-  WizardForm.InnerPage.Height := WizardForm.InnerPage.Height + (LicenseHeight - DefaultHeight);
-  WizardForm.InnerNotebook.Height :=  WizardForm.InnerNotebook.Height + (LicenseHeight - DefaultHeight);
-  WizardForm.LicensePage.Height := WizardForm.LicensePage.Height + (LicenseHeight - DefaultHeight);
-  WizardForm.LicenseMemo.Height := WizardForm.LicenseMemo.Height + (LicenseHeight - DefaultHeight);
-  WizardForm.LicenseNotAcceptedRadio.Top := WizardForm.LicenseNotAcceptedRadio.Top + (LicenseHeight - DefaultHeight);
-  WizardForm.LicenseAcceptedRadio.Top := WizardForm.LicenseAcceptedRadio.Top + (LicenseHeight - DefaultHeight);
-
-end;
-
-procedure CurPageChanged(CurPageID: Integer);
-begin
-  if CurPageID = wpLicense then
-  begin
-    WizardForm.Top := DefaultTop - (LicenseHeight - DefaultHeight) div 2;
-    WizardForm.Height := LicenseHeight;
-    WizardForm.OuterNotebook.Height := WizardForm.OuterNotebook.Height + (LicenseHeight - DefaultHeight);
-    WizardForm.CancelButton.Top := DefaultCancelTop + (LicenseHeight - DefaultHeight);
-    WizardForm.NextButton.Top := DefaultNextTop + (LicenseHeight - DefaultHeight);
-    WizardForm.BackButton.Top := DefaultBackTop + (LicenseHeight - DefaultHeight);
-    WizardForm.Bevel.Top := DefaultBevelTop + (LicenseHeight - DefaultHeight);
-  end
-  else
-  begin
-    WizardForm.Top := DefaultTop;
-    WizardForm.Left := DefaultLeft;
-    WizardForm.Height := DefaultHeight;
-    WizardForm.OuterNotebook.Height := DefaultOuterHeight;
-    WizardForm.CancelButton.Top := DefaultCancelTop;
-    WizardForm.NextButton.Top := DefaultNextTop;
-    WizardForm.BackButton.Top := DefaultBackTop;
-    WizardForm.Bevel.Top := DefaultBevelTop;
-  end;
-end;
-
-function NotOnPathAlready(): Boolean;
-var
-  BinDir, Path: String;
-begin
-  Log('Checking if i2pd dir is already in the %PATH%');
-  if RegQueryStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', Path) then
-  begin // Successfully read the value
-    Log('HKCUEnvironmentPATH = ' + Path);
-    BinDir := ExpandConstant('{app}');
-    Log('Looking for i2pd dir in %PATH%: ' + BinDir + ' in ' + Path);
-    if Pos(LowerCase(BinDir), Lowercase(Path)) = 0 then
-    begin
-      Log('Did not find i2pd dir in %PATH% so I will add it');
-      Result := True;
-    end
-    else
-    begin
-      Log('Found i2pd dir in %PATH% so will not add it again');
-      Result := False;
-    end
-  end
-  else // The key probably doesn't exist
-  begin
-    Log('Could not access HKCUEnvironmentPATH so I assume that it is OK to add it');
-    Result := True;
-  end;
-end;
-
-
-procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
-var
-  BinDir, Path: String;
-begin
-  if (CurUninstallStep = usPostUninstall)
-     and (RegQueryStringValue(HKEY_CURRENT_USER, 'Environment', 'PATH', Path)) then
-  begin
-    BinDir := ExpandConstant('{app}');
-    if Pos(LowerCase(BinDir) + ';', Lowercase(Path)) <> 0 then
-    begin
-      StringChange(Path, BinDir + ';', '');
-      RegWriteStringValue(HKEY_CURRENT_USER, 'Environment', 'PATH', Path);
-    end;
-  end;
-end;

Win32/install_service.bat

@@ -1 +0,0 @@
-i2pd --service=install

Win32/nsi/helper_readme.nsh

@@ -1,57 +0,0 @@
-!verbose push
-!verbose 3
- 
-!ifndef _MUI_EXTRAPAGES_NSH
-!define _MUI_EXTRAPAGES_NSH
- 
-!ifmacrondef MUI_EXTRAPAGE_README & MUI_PAGE_README & MUI_UNPAGE_README & ReadmeLangStrings
- 
-!macro MUI_EXTRAPAGE_README UN ReadmeFile
-!verbose push
-!verbose 3
-   !define MUI_PAGE_HEADER_TEXT "$(${UN}ReadmeHeader)"
-   !define MUI_PAGE_HEADER_SUBTEXT "$(${UN}ReadmeSubHeader)"
-   !define MUI_LICENSEPAGE_TEXT_TOP "$(${UN}ReadmeTextTop)"
-   !define MUI_LICENSEPAGE_TEXT_BOTTOM "$(${UN}ReadmeTextBottom)"
-   !define MUI_LICENSEPAGE_BUTTON "$(^NextBtn)"
-   !insertmacro MUI_${UN}PAGE_LICENSE "${ReadmeFile}"
-!verbose pop
-!macroend
- 
-!define ReadmeRun "!insertmacro MUI_EXTRAPAGE_README"
- 
- 
-!macro MUI_PAGE_README ReadmeFile
-!verbose push
-!verbose 3
-    ${ReadmeRun} "" "${ReadmeFile}"
-!verbose pop
-!macroend
- 
- 
-!macro MUI_UNPAGE_README ReadmeFile
-!verbose push
-!verbose 3
-    ${ReadmeRun} "UN" "${ReadmeFile}"
-!verbose pop
-!macroend
- 
- 
-!macro ReadmeLangStrings UN MUI_LANG ReadmeHeader ReadmeSubHeader ReadmeTextTop ReadmeTextBottom
-!verbose push
-!verbose 3
-    LangString ${UN}ReadmeHeader     ${MUI_LANG} "${ReadmeHeader}"
-    LangString ${UN}ReadmeSubHeader  ${MUI_LANG} "${ReadmeSubHeader}"
-    LangString ${UN}ReadmeTextTop    ${MUI_LANG} "${ReadmeTextTop}"
-    LangString ${UN}ReadmeTextBottom ${MUI_LANG} "${ReadmeTextBottom}"
-!verbose pop
-!macroend
- 
-!define ReadmeLanguage `!insertmacro ReadmeLangStrings ""`
- 
-!define Un.ReadmeLanguage `!insertmacro ReadmeLangStrings "UN"`
- 
-!endif
-!endif
- 
-!verbose pop

Win32/nsi/servicelib.nsh

@@ -1,419 +0,0 @@
-; NSIS SERVICE LIBRARY - servicelib.nsh
-; Version 1.8.1 - Jun 21th, 2013
-; Questions/Comments - dselkirk@hotmail.com
-;
-; Description:
-;   Provides an interface to window services
-;
-; Inputs:
-;   action     - systemlib action ie. create, delete, start, stop, pause,
-;              continue, installed, running, status
-;   name       - name of service to manipulate
-;   param      - action parameters; usage: var1=value1;var2=value2;...etc.
-;                 (don't forget to add a ';' after the last value!)
-;
-; Actions:
-;   create     - creates a new windows service
-;              Parameters:
-;                path        - path to service executable
-;                autostart   - automatically start with system ie. 1|0
-;                interact    - interact with the desktop ie. 1|0
-;                depend      - service dependencies
-;                user        - user that runs the service
-;                password    - password of the above user
-;                display     - display name in service's console
-;                description - Description of service
-;                starttype   - start type (supersedes autostart)
-;                servicetype - service type (supersedes interact)
-;
-;   delete     - deletes a windows service
-;   start      - start a stopped windows service
-;   stop       - stops a running windows service
-;   pause      - pauses a running windows service
-;   continue   - continues a paused windows service
-;   installed  - is the provided service installed
-;              Parameters:
-;                action      - if true then invokes the specified action
-;   running    - is the provided service running
-;              Parameters:
-;                action      - if true then invokes the specified action
-;   status     - check the status of the provided service
-;
-; Usage:
-;   Method 1:
-;     Push "action"
-;     Push "name"
-;     Push "param"
-;     Call Service
-;     Pop $0 ;response
-;
-;   Method 2:
-;     !insertmacro SERVICE "action" "name" "param"
-;
-; History:
-;   1.0 - 09/15/2003 - Initial release
-;   1.1 - 09/16/2003 - Changed &l to i, thx brainsucker
-;   1.2 - 02/29/2004 - Fixed documentation.
-;   1.3 - 01/05/2006 - Fixed interactive flag and pop order (Kichik)
-;   1.4 - 12/07/2006 - Added display and depend, fixed datatypes (Vitoco)
-;   1.5 - 06/25/2008 - Added description of service.(DeSafe.com/liuqixing#gmail.com)
-;   1.5.1 - 06/12/2009 - Added use of __UNINSTALL__
-;   1.6 - 08/02/2010 - Fixed description implementation (Anders)
-;   1.7 - 04/11/2010 - Added get running service process id (Nico)
-;   1.8 - 24/03/2011 - Added starttype and servicetype (Sergius)
-;   1.8.1 - 21/06/2013 - Added dynamic ASCII & Unicode support (Zinthose)
- 
-!ifndef SERVICELIB
-  !define SERVICELIB
- 
-  !define SC_MANAGER_ALL_ACCESS         0x3F
-  !define SC_STATUS_PROCESS_INFO        0x0
-  !define SERVICE_ALL_ACCESS            0xF01FF
- 
-  !define SERVICE_CONTROL_STOP          1
-  !define SERVICE_CONTROL_PAUSE         2
-  !define SERVICE_CONTROL_CONTINUE      3
- 
-  !define SERVICE_STOPPED               0x1
-  !define SERVICE_START_PENDING         0x2
-  !define SERVICE_STOP_PENDING          0x3
-  !define SERVICE_RUNNING               0x4
-  !define SERVICE_CONTINUE_PENDING      0x5
-  !define SERVICE_PAUSE_PENDING         0x6
-  !define SERVICE_PAUSED                0x7
- 
-  !define SERVICE_KERNEL_DRIVER         0x00000001
-  !define SERVICE_FILE_SYSTEM_DRIVER    0x00000002 
-  !define SERVICE_WIN32_OWN_PROCESS     0x00000010 
-  !define SERVICE_WIN32_SHARE_PROCESS   0x00000020
-  !define SERVICE_INTERACTIVE_PROCESS   0x00000100
- 
- 
-  !define SERVICE_BOOT_START            0x00000000
-  !define SERVICE_SYSTEM_START          0x00000001
-  !define SERVICE_AUTO_START            0x00000002 
-  !define SERVICE_DEMAND_START          0x00000003
-  !define SERVICE_DISABLED              0x00000004
- 
-  ## Added by Zinthose for Native Unicode Support
-  !ifdef NSIS_UNICODE
-	!define APITAG "W"
-  !else
-    !define APITAG "A"
-  !endif
- 
-  !macro SERVICE ACTION NAME PARAM
-    Push '${ACTION}'
-    Push '${NAME}'
-    Push '${PARAM}'
-    !ifdef __UNINSTALL__
-        Call un.Service
-    !else
-        Call Service
-    !endif
-  !macroend
- 
-  !macro FUNC_GETPARAM
-    Push $0
-    Push $1
-    Push $2
-    Push $3
-    Push $4
-    Push $5
-    Push $6
-    Push $7
-    Exch 8
-    Pop $1 ;name
-    Exch 8
-    Pop $2 ;source
-    StrCpy $0 ""
-    StrLen $7 $2
-    StrCpy $3 0
-    lbl_loop:
-      IntCmp $3 $7 0 0 lbl_done
-      StrLen $4 "$1="
-      StrCpy $5 $2 $4 $3
-      StrCmp $5 "$1=" 0 lbl_next
-      IntOp $5 $3 + $4
-      StrCpy $3 $5
-      lbl_loop2:
-        IntCmp $3 $7 0 0 lbl_done
-        StrCpy $6 $2 1 $3
-        StrCmp $6 ";" 0 lbl_next2
-        IntOp $6 $3 - $5
-        StrCpy $0 $2 $6 $5
-        Goto lbl_done
-        lbl_next2:
-        IntOp $3 $3 + 1
-        Goto lbl_loop2
-      lbl_next:
-      IntOp $3 $3 + 1
-      Goto lbl_loop
-    lbl_done:
-    Pop $5
-    Pop $4
-    Pop $3
-    Pop $2
-    Pop $1
-    Exch 2
-    Pop $6
-    Pop $7
-    Exch $0
-  !macroend
- 
-  !macro CALL_GETPARAM VAR NAME DEFAULT LABEL
-    Push $1
-    Push ${NAME}
-    Call ${UN}GETPARAM
-    Pop $6
-    StrCpy ${VAR} "${DEFAULT}"
-    StrCmp $6 "" "${LABEL}" 0
-    StrCpy ${VAR} $6
-  !macroend
- 
-  !macro FUNC_SERVICE UN
-    Push $0
-    Push $1
-    Push $2
-    Push $3
-    Push $4
-    Push $5
-    Push $6
-    Push $7
-    Exch 8
-    Pop $1 ;param
-    Exch 8
-    Pop $2 ;name
-    Exch 8
-    Pop $3 ;action
-    ;$0 return
-    ;$4 OpenSCManager
-    ;$5 OpenService
- 
-    StrCpy $0 "false"
-    System::Call 'advapi32::OpenSCManager${APITAG}(n, n, i ${SC_MANAGER_ALL_ACCESS}) i.r4'
-    IntCmp $4 0 lbl_done
-    StrCmp $3 "create" lbl_create
-    System::Call 'advapi32::OpenService${APITAG}(i r4, t r2, i ${SERVICE_ALL_ACCESS}) i.r5'
-    IntCmp $5 0 lbl_done
- 
-    lbl_select:
-    StrCmp $3 "delete" lbl_delete
-    StrCmp $3 "start" lbl_start
-    StrCmp $3 "stop" lbl_stop
-    StrCmp $3 "pause" lbl_pause
-    StrCmp $3 "continue" lbl_continue
-    StrCmp $3 "installed" lbl_installed
-    StrCmp $3 "running" lbl_running
-    StrCmp $3 "status" lbl_status
-    StrCmp $3 "processid" lbl_processid
-    Goto lbl_done
- 
-    ; create service
-    lbl_create:
-      Push $R1 ;depend
-      Push $R2 ;user
-      Push $R3 ;password
-      Push $R4 ;servicetype/interact
-      Push $R5 ;starttype/autostart
-      Push $R6 ;path
-      Push $R7 ;display
-      Push $R8 ;description
- 
-      !insertmacro CALL_GETPARAM $R1 "depend" "n" "lbl_depend"
-        StrCpy $R1 't "$R1"'
-      lbl_depend:
-      StrCmp $R1 "n" 0 lbl_machine ;old name of depend param
-      !insertmacro CALL_GETPARAM $R1 "machine" "n" "lbl_machine"
-        StrCpy $R1 't "$R1"'
-      lbl_machine:
- 
-      !insertmacro CALL_GETPARAM $R2 "user" "n" "lbl_user"
-        StrCpy $R2 't "$R2"'
-      lbl_user:
- 
-      !insertmacro CALL_GETPARAM $R3 "password" "n" "lbl_password"
-        StrCpy $R3 't "$R3"'
-      lbl_password:
- 
-      !insertmacro CALL_GETPARAM $R4 "interact" "${SERVICE_WIN32_OWN_PROCESS}" "lbl_interact"
-        StrCpy $6 ${SERVICE_WIN32_OWN_PROCESS}
-        IntCmp $R4 0 +2
-        IntOp $6 $6 | ${SERVICE_INTERACTIVE_PROCESS}
-        StrCpy $R4 $6
-      lbl_interact:
- 
-      !insertmacro CALL_GETPARAM $R4 "servicetype" "$R4" "lbl_servicetype"
-      lbl_servicetype:
- 
-      !insertmacro CALL_GETPARAM $R5 "autostart" "${SERVICE_DEMAND_START}" "lbl_autostart"
-        StrCpy $6 ${SERVICE_DEMAND_START}
-        IntCmp $R5 0 +2
-        StrCpy $6 ${SERVICE_AUTO_START}
-        StrCpy $R5 $6
-      lbl_autostart:
- 
-      !insertmacro CALL_GETPARAM $R5 "starttype" "$R5" "lbl_starttype"
-      lbl_starttype:
- 
-      !insertmacro CALL_GETPARAM $R6 "path" "n" "lbl_path"
-      lbl_path:
- 
-      !insertmacro CALL_GETPARAM $R7 "display" "$2" "lbl_display"
-      lbl_display:
- 
-      !insertmacro CALL_GETPARAM $R8 "description" "$2" "lbl_description"
-      lbl_description:
- 
-      System::Call 'advapi32::CreateService${APITAG}(i r4, t r2, t R7, i ${SERVICE_ALL_ACCESS}, \
-                                             i R4, i R5, i 0, t R6, n, n, $R1, $R2, $R3) i.r6' 
- 
-      ; write description of service (SERVICE_CONFIG_DESCRIPTION)
-      System::Call 'advapi32::ChangeServiceConfig2${APITAG}(ir6,i1,*t "$R8")i.R7'
-      strcmp $R7 "error" 0 lbl_descriptioncomplete
-      WriteRegStr HKLM "SYSTEM\CurrentControlSet\Services\$2" "Description" $R8
-      lbl_descriptioncomplete:
- 
-      Pop $R8
-      Pop $R7
-      Pop $R6
-      Pop $R5
-      Pop $R4
-      Pop $R3
-      Pop $R2
-      Pop $R1
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; delete service
-    lbl_delete:
-      System::Call 'advapi32::DeleteService(i r5) i.r6'
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; start service
-    lbl_start:
-      System::Call 'advapi32::StartService${APITAG}(i r5, i 0, i 0) i.r6'
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; stop service
-    lbl_stop:
-      Push $R1
-      System::Call '*(i,i,i,i,i,i,i) i.R1'
-      System::Call 'advapi32::ControlService(i r5, i ${SERVICE_CONTROL_STOP}, i $R1) i'
-      System::Free $R1
-      Pop $R1
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; pause service
-    lbl_pause:
-      Push $R1
-      System::Call '*(i,i,i,i,i,i,i) i.R1'
-      System::Call 'advapi32::ControlService(i r5, i ${SERVICE_CONTROL_PAUSE}, i $R1) i'
-      System::Free $R1
-      Pop $R1
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; continue service
-    lbl_continue:
-      Push $R1
-      System::Call '*(i,i,i,i,i,i,i) i.R1'
-      System::Call 'advapi32::ControlService(i r5, i ${SERVICE_CONTROL_CONTINUE}, i $R1) i'
-      System::Free $R1
-      Pop $R1
-      StrCmp $6 0 lbl_done lbl_good
- 
-    ; is installed
-    lbl_installed:
-      !insertmacro CALL_GETPARAM $7 "action" "" "lbl_good"
-        StrCpy $3 $7
-        Goto lbl_select
- 
-    ; is service running
-    lbl_running:
-      Push $R1
-      System::Call '*(i,i,i,i,i,i,i) i.R1'
-      System::Call 'advapi32::QueryServiceStatus(i r5, i $R1) i'
-      System::Call '*$R1(i, i.r6)'
-      System::Free $R1
-      Pop $R1
-      IntFmt $6 "0x%X" $6
-      StrCmp $6 ${SERVICE_RUNNING} 0 lbl_done
-      !insertmacro CALL_GETPARAM $7 "action" "" "lbl_good"
-        StrCpy $3 $7
-        Goto lbl_select
- 
-    lbl_status:
-      Push $R1
-      System::Call '*(i,i,i,i,i,i,i) i.R1'
-      System::Call 'advapi32::QueryServiceStatus(i r5, i $R1) i'
-      System::Call '*$R1(i, i .r6)'
-      System::Free $R1
-      Pop $R1
-      IntFmt $6 "0x%X" $6
-      StrCpy $0 "running"
-      IntCmp $6 ${SERVICE_RUNNING} lbl_done
-      StrCpy $0 "stopped"
-      IntCmp $6 ${SERVICE_STOPPED} lbl_done
-      StrCpy $0 "start_pending"
-      IntCmp $6 ${SERVICE_START_PENDING} lbl_done
-      StrCpy $0 "stop_pending"
-      IntCmp $6 ${SERVICE_STOP_PENDING} lbl_done
-      StrCpy $0 "running"
-      IntCmp $6 ${SERVICE_RUNNING} lbl_done
-      StrCpy $0 "continue_pending"
-      IntCmp $6 ${SERVICE_CONTINUE_PENDING} lbl_done
-      StrCpy $0 "pause_pending"
-      IntCmp $6 ${SERVICE_PAUSE_PENDING} lbl_done
-      StrCpy $0 "paused"
-      IntCmp $6 ${SERVICE_PAUSED} lbl_done
-      StrCpy $0 "unknown"
-      Goto lbl_done
- 
-    lbl_processid:
-      Push $R1
-      Push $R2
-      System::Call '*(i,i,i,i,i,i,i,i,i) i.R1'
-      System::Call '*(i 0) i.R2'
-      System::Call "advapi32::QueryServiceStatusEx(i r5, i ${SC_STATUS_PROCESS_INFO}, i $R1, i 36, i $R2) i"
-      System::Call "*$R1(i,i,i,i,i,i,i, i .r0)"
-      System::Free $R2
-      System::Free $R1
-      Pop $R2
-      Pop $R1
-      Goto lbl_done
- 
-    lbl_good:
-    StrCpy $0 "true"
-    lbl_done:
-    IntCmp $5 0 +2
-    System::Call 'advapi32::CloseServiceHandle(i r5) n'
-    IntCmp $4 0 +2
-    System::Call 'advapi32::CloseServiceHandle(i r4) n'
-    Pop $4
-    Pop $3
-    Pop $2
-    Pop $1
-    Exch 3
-    Pop $5
-    Pop $7
-    Pop $6
-    Exch $0
-  !macroend
- 
-  Function Service
-    !insertmacro FUNC_SERVICE ""
-  FunctionEnd
- 
-  Function un.Service
-    !insertmacro FUNC_SERVICE "un."
-  FunctionEnd
- 
-  Function GetParam
-    !insertmacro FUNC_GETPARAM
-  FunctionEnd
- 
-  Function un.GetParam
-    !insertmacro FUNC_GETPARAM
-  FunctionEnd
- 
-  !undef APITAG
-!endif

Win32/resource.h

@@ -1,16 +1,11 @@
-//{{NO_DEPENDENCIES}}
-// Microsoft Visual C++ generated include file.
-// Used by Resource.rc
-//
-#define IDI_ICON1                       101
-
-// Next default values for new objects
-// 
-#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
+//{{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