2.14.0

NTCP SOCKS/HTTP Proxy support

.dir-locals.el

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

.gitignore

@@ -1,16 +1,21 @@
 # i2pd
-obj/*.o
+*.o
 router.info
 router.keys
 i2p
 libi2pd.so
 netDb
+/i2pd
+/libi2pd.a
+/libi2pdclient.a
+i2pd.exe
+
 
 # Autotools
 autom4te.cache
 .deps
 stamp-h1
-Makefile
+#Makefile
 config.h
 config.h.in~
 config.log
@@ -230,3 +235,23 @@ pip-log.txt
 
 #Mr Developer
 .mr.developer.cfg
+
+# Sphinx
+docs/_build
+/androidIdea/
+
+# Doxygen
+docs/generated
+
+# emacs files
+*~
+*\#*
+
+# gdb files
+.gdb_history
+
+# cmake makefile
+build/Makefile
+
+# debian stuff
+.pc/

.travis.yml

@@ -0,0 +1,35 @@
+language: cpp
+cache:
+  apt: true
+os:
+  - linux
+sudo: required
+dist: trusty
+addons:
+  apt:
+    packages:
+      - build-essential
+      - cmake
+      - g++
+      - clang
+      - libboost-chrono-dev
+      - libboost-date-time-dev
+      - libboost-filesystem-dev
+      - libboost-program-options-dev
+      - libboost-system-dev
+      - libboost-thread-dev
+      - libminiupnpc-dev
+      - libssl-dev
+compiler:
+  - gcc
+  - clang
+before_install:
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install openssl miniupnpc ; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew unlink boost openssl && brew link boost openssl -f ; fi
+env:
+  matrix:
+    - BUILD_TYPE=Release UPNP=ON
+    - BUILD_TYPE=Release UPNP=OFF
+script:
+  - cd build && cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DWITH_UPNP=${UPNP} && make

AddressBook.cpp

@@ -1,572 +0,0 @@
-#include <string.h>
-#include <inttypes.h>
-#include <string>
-#include <map>
-#include <fstream>
-#include <chrono>
-#include <condition_variable>
-#include <boost/filesystem.hpp>
-#include <boost/lexical_cast.hpp>
-#include <cryptopp/osrng.h>
-#include "base64.h"
-#include "util.h"
-#include "Identity.h"
-#include "Log.h"
-#include "NetDb.h"
-#include "ClientContext.h"
-#include "AddressBook.h"
-
-namespace i2p
-{
-namespace client
-{
-
-	class AddressBookFilesystemStorage: public AddressBookStorage
-	{
-		public:
-
-			AddressBookFilesystemStorage ();
-			bool GetAddress (const i2p::data::IdentHash& ident, i2p::data::IdentityEx& address) const;
-			void AddAddress (const i2p::data::IdentityEx& address);
-			void RemoveAddress (const i2p::data::IdentHash& ident);
-
-			int Load (std::map<std::string, i2p::data::IdentHash>& addresses);
-			int Save (const std::map<std::string, i2p::data::IdentHash>& addresses);
-
-		private:	
-			
-			boost::filesystem::path GetPath () const { return i2p::util::filesystem::GetDefaultDataDir() / "addressbook"; };
-
-	};
-
-	AddressBookFilesystemStorage::AddressBookFilesystemStorage ()
-	{
-		auto path = GetPath ();
-		if (!boost::filesystem::exists (path))
-		{
-			// Create directory is necessary
-			if (!boost::filesystem::create_directory (path))
-				LogPrint (eLogError, "Failed to create addressbook directory");
-		}
-	}
-
-	bool AddressBookFilesystemStorage::GetAddress (const i2p::data::IdentHash& ident, i2p::data::IdentityEx& address) const
-	{
-		auto filename = GetPath () / (ident.ToBase32() + ".b32");
-		std::ifstream f(filename.c_str (), std::ifstream::binary);
-		if (f.is_open ())	
-		{
-			f.seekg (0,std::ios::end);
-			size_t len = f.tellg ();
-			if (len < i2p::data::DEFAULT_IDENTITY_SIZE)
-			{
-				LogPrint (eLogError, "File ", filename, " is too short. ", len);
-				return false;
-			}
-			f.seekg(0, std::ios::beg);
-			uint8_t * buf = new uint8_t[len];
-			f.read((char *)buf, len);
-			address.FromBuffer (buf, len);
-			delete[] buf;
-			return true;
-		}
-		else
-			return false;
-	}
-
-	void AddressBookFilesystemStorage::AddAddress (const i2p::data::IdentityEx& address)
-	{
-		auto filename = GetPath () / (address.GetIdentHash ().ToBase32() + ".b32");
-		std::ofstream f (filename.c_str (), std::ofstream::binary | std::ofstream::out);
-		if (f.is_open ())	
-		{
-			size_t len = address.GetFullLen ();
-			uint8_t * buf = new uint8_t[len];
-			address.ToBuffer (buf, len);
-			f.write ((char *)buf, len);
-			delete[] buf;
-		}
-		else
-			LogPrint (eLogError, "Can't open file ", filename);	
-	}	
-
-	void AddressBookFilesystemStorage::RemoveAddress (const i2p::data::IdentHash& ident)
-	{
-		auto filename = GetPath () / (ident.ToBase32() + ".b32");
-		if (boost::filesystem::exists (filename))  
-			boost::filesystem::remove (filename);
-	}
-
-	int AddressBookFilesystemStorage::Load (std::map<std::string, i2p::data::IdentHash>& addresses)
-	{
-		int num = 0;	
-		auto filename = GetPath () / "addresses.csv";
-		std::ifstream f (filename.c_str (), std::ofstream::in); // in text mode
-		if (f.is_open ())	
-		{
-			addresses.clear ();
-			while (!f.eof ())
-			{
-				std::string s;
-				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);
-
-					i2p::data::IdentHash ident;
-					ident.FromBase32 (addr);
-					addresses[name] = ident;
-					num++;
-				}		
-			}
-			LogPrint (eLogInfo, num, " addresses loaded");
-		}
-		else
-			LogPrint (eLogWarning, filename, " not found");
-		return num;
-	}
-
-	int AddressBookFilesystemStorage::Save (const std::map<std::string, i2p::data::IdentHash>& addresses)
-	{
-		int num = 0;
-		auto filename = GetPath () / "addresses.csv";
-		std::ofstream f (filename.c_str (), std::ofstream::out); // in text mode
-		if (f.is_open ())	
-		{
-			for (auto it: addresses)
-			{
-				f << it.first << "," << it.second.ToBase32 () << std::endl;
-				num++;
-			}
-			LogPrint (eLogInfo, num, " addresses saved");
-		}
-		else	
-			LogPrint (eLogError, "Can't open file ", filename);	
-		return num;	
-	}	
-
-//---------------------------------------------------------------------
-	AddressBook::AddressBook (): m_Storage (nullptr), m_IsLoaded (false), m_IsDownloading (false), 
-		m_DefaultSubscription (nullptr), m_SubscriptionsUpdateTimer (nullptr)
-	{
-	}
-
-	AddressBook::~AddressBook ()
-	{	
-		Stop ();
-	}
-
-	void AddressBook::Start ()
-	{
-		StartSubscriptions ();
-	}
-	
-	void AddressBook::Stop ()
-	{
-		StopSubscriptions ();
-		if (m_SubscriptionsUpdateTimer)
-		{	
-			delete m_SubscriptionsUpdateTimer;	
-			m_SubscriptionsUpdateTimer = nullptr;
-		}	
-		if (m_IsDownloading)
-		{
-			LogPrint (eLogInfo, "Subscription is downloading. Waiting for temination...");
-			for (int i = 0; i < 30; i++)
-			{
-				if (!m_IsDownloading)
-				{
-					LogPrint (eLogInfo, "Subscription download complete");
-					break;
-				}	
-				std::this_thread::sleep_for (std::chrono::seconds (1)); // wait for 1 seconds
-			}	
-			LogPrint (eLogError, "Subscription download hangs");
-			m_IsDownloading = false;
-		}	
-		if (m_Storage)
-		{
-			m_Storage->Save (m_Addresses);
-			delete m_Storage;
-			m_Storage = nullptr;
-		}
-		if (m_DefaultSubscription)
-		{	
-			delete m_DefaultSubscription;
-			m_DefaultSubscription = nullptr;
-		}	
-		for (auto it: m_Subscriptions)
-			delete it;
-		m_Subscriptions.clear ();	
-	}	
-	
-	AddressBookStorage * AddressBook::CreateStorage ()
-	{
-		return new AddressBookFilesystemStorage ();
-	}	
-
-	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)
-	{
-		if (!m_IsLoaded)
-			LoadHosts ();
-		if (m_IsLoaded)
-		{
-			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)
-	{
-		i2p::data::IdentityEx ident;
-		ident.FromBase64 (base64);
-		if (!m_Storage)
-			 m_Storage = CreateStorage ();
-		m_Storage->AddAddress (ident);
-		m_Addresses[address] = ident.GetIdentHash ();
-		LogPrint (address,"->", ToAddress(ident.GetIdentHash ()), " added");
-	}
-
-	void AddressBook::InsertAddress (const i2p::data::IdentityEx& address)
-	{
-		if (!m_Storage) 
-			m_Storage = CreateStorage ();
-		m_Storage->AddAddress (address);
-	}
-
-	bool AddressBook::GetAddress (const std::string& address, i2p::data::IdentityEx& identity)
-	{
-		if (!m_Storage) 
-			m_Storage = CreateStorage ();
-		i2p::data::IdentHash ident;
-		if (!GetIdentHash (address, ident)) return false;
-		return m_Storage->GetAddress (ident, identity);
-	}	
-
-	void AddressBook::LoadHosts ()
-	{
-		if (!m_Storage)
-			 m_Storage = CreateStorage ();
-		if (m_Storage->Load (m_Addresses) > 0)
-		{
-			m_IsLoaded = true;
-			return;
-		}
-	
-		// try hosts.txt first
-		std::ifstream f (i2p::util::filesystem::GetFullPath ("hosts.txt").c_str (), std::ofstream::in); // in text mode
-		if (f.is_open ())	
-		{
-			LoadHostsFromStream (f);
-			m_IsLoaded = true;
-		}
-		else
-		{
-			// if not found download it from http://i2p-projekt.i2p/hosts.txt 
-			LogPrint (eLogInfo, "hosts.txt not found. Try to download it from default subscription...");
-			if (!m_IsDownloading)
-			{
-				m_IsDownloading = true;
-				if (!m_DefaultSubscription)
-					m_DefaultSubscription = new AddressBookSubscription (*this, DEFAULT_SUBSCRIPTION_ADDRESS);
-				m_DefaultSubscription->CheckSubscription ();
-			}
-		}	
-		
-	}
-
-	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);
-
-				i2p::data::IdentityEx ident;
-				if (ident.FromBase64(addr))
-				{	
-					m_Addresses[name] = ident.GetIdentHash ();
-					m_Storage->AddAddress (ident);
-					numAddresses++;
-				}	
-				else
-					LogPrint (eLogError, "Malformed address ", addr, " for ", name);
-			}		
-		}
-		LogPrint (eLogInfo, 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::util::filesystem::GetFullPath ("subscriptions.txt").c_str (), std::ofstream::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, m_Subscriptions.size (), " subscriptions loaded");
-			}
-			else
-				LogPrint (eLogWarning, "subscriptions.txt not found");
-		}
-		else
-			LogPrint (eLogError, "Subscriptions already loaded");
-	}
-
-	void AddressBook::DownloadComplete (bool success)
-	{
-		m_IsDownloading = false;
-		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_Subscriptions.size ()) 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, "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) return;
-			if (m_IsLoaded && !m_IsDownloading && dest->IsReady ())
-			{
-				// pick random subscription
-				CryptoPP::AutoSeededRandomPool rnd;
-				auto ind = rnd.GenerateWord32 (0, m_Subscriptions.size() - 1);	
-				m_IsDownloading = true;	
-				m_Subscriptions[ind]->CheckSubscription ();		
-			}
-			else
-			{
-				if (!m_IsLoaded)
-					LoadHosts ();
-				// 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, "Downloading hosts 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)
-			{
-				bool found = false;
-				std::unique_lock<std::mutex> l(newDataReceivedMutex);
-				i2p::client::context.GetSharedLocalDestination ()->RequestDestination (ident,
-					[&newDataReceived, &found](bool success)
-				    {
-						found = success;
-						newDataReceived.notify_all ();
-					});
-				if (newDataReceived.wait_for (l, std::chrono::seconds (SUBSCRIPTION_REQUEST_TIMEOUT)) == std::cv_status::timeout)
-					LogPrint (eLogError, "Subscription LeseseSet request timeout expired");
-				if (found)
-					leaseSet = i2p::client::context.GetSharedLocalDestination ()->FindLeaseSet (ident);	
-			}
-			if (leaseSet)
-			{
-				std::stringstream request, response;
-				// standard header
-				request << "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";
-				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, "Subscription 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;
-					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);
-							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");
-						}	
-					}
-					LogPrint (eLogInfo, m_Link, " ETag: ", m_Etag, " Last-Modified: ", m_LastModified);
-					if (!response.eof ())	
-					{
-						success = true;
-						if (!isChunked)
-							m_Book.LoadHostsFromStream (response);
-						else
-						{
-							// merge chunks
-							std::stringstream merged;
-							i2p::util::http::MergeChunkedResponse (response, merged);
-							m_Book.LoadHostsFromStream (merged);
-						}	
-					}	
-				}
-				else if (status == 304)
-				{	
-					success = true;
-					LogPrint (eLogInfo, "No updates from ", m_Link);
-				}	
-				else
-					LogPrint (eLogWarning, "Adressbook HTTP response ", status);
-			}
-			else
-				LogPrint (eLogError, "Address ", u.host_, " not found");
-		}
-		else
-			LogPrint (eLogError, "Can't resolve ", u.host_);
-		LogPrint (eLogInfo, "Download complete ", success ? "Success" : "Failed");
-		m_Book.DownloadComplete (success);
-	}
-}
-}
-

AddressBook.h

@@ -1,105 +0,0 @@
-#ifndef ADDRESS_BOOK_H__
-#define ADDRESS_BOOK_H__
-
-#include <string.h>
-#include <string>
-#include <map>
-#include <vector>
-#include <iostream>
-#include <mutex>
-#include <boost/asio.hpp>
-#include "base64.h"
-#include "util.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 bool GetAddress (const i2p::data::IdentHash& ident, i2p::data::IdentityEx& address) const = 0;	
-			virtual void AddAddress (const i2p::data::IdentityEx& address) = 0;
-			virtual void RemoveAddress (const i2p::data::IdentHash& ident) = 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);
-			bool GetAddress (const std::string& address, i2p::data::IdentityEx& identity);
-			const i2p::data::IdentHash * FindAddress (const std::string& address);
-			void InsertAddress (const std::string& address, const std::string& base64); // for jump service
-			void InsertAddress (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(const i2p::data::IdentityEx& ident) { return ToAddress(ident.GetIdentHash ()); }
-		private:
-
-			void StartSubscriptions ();
-			void StopSubscriptions ();
-			
-			AddressBookStorage * CreateStorage ();	
-			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;
-			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 ();
-		
-		private:
-
-			AddressBook& m_Book;
-			std::string m_Link, m_Etag, m_LastModified;
-	};
-}
-}
-
-#endif
-
-

ChangeLog

@@ -0,0 +1,184 @@
+# for this file format description,
+# see https://github.com/olivierlacan/keep-a-changelog
+
+## [2.14.0] - 2017-06-01
+### Added
+- Transit traffic bandwidth limitation
+- NTCP connections through HTTP and SOCKS proxies
+- Ability to disable address helper for HTTP proxy
+### Changed
+- Reseed servers list
+- Minimal required version is 4.0 for Android
+### Fixed
+- Ignore comments in addressbook feed
+
+## [2.13.0] - 2017-04-06
+### Added
+- Persist local destination's tags
+- GOST signature types 9 and 10
+- Exploratory tunnels configuration
+### Changed
+- Reseed servers list
+- Inactive NTCP sockets get closed faster
+- Some EdDSA speed up
+### Fixed
+- Multiple acceptors for SAM
+- Follow on data after STREAM CREATE for SAM
+- Memory leaks
+
+## [2.12.0] - 2017-02-14
+### Added
+- Additional HTTP and SOCKS proxy tunnels
+- Reseed from ZIP archive
+- Some stats in a main window for Windows version
+### Changed
+- Reseed servers list
+- MTU of 1488 for ipv6 
+- Android and Mac OS X versions use OpenSSL 1.1
+- New logo for Android
+### Fixed
+- Multiple memory leaks
+- Incomptibility of some EdDSA private keys with Java
+- Clock skew for Windows XP
+- Occasional crashes with I2PSnark
+
+## [2.11.0] - 2016-12-18
+### Added
+- Websockets support
+- Reseed through a floodfill
+- Tunnel configuration for HTTP and SOCKS proxy
+- Zero-hops tunnels for destinations
+- Multiple acceptors for SAM
+### Changed
+- Reseed servers list
+- DHT uses AVX if applicable
+- New logo
+- LeaseSet lookups
+### Fixed
+- HTTP Proxy connection reset for Windows
+- Crash upon SAM session termination
+- Can't connect to a destination for a longer time after restart
+- Mass packet loss for UDP tunnels
+
+## [2.10.2] - 2016-12-04
+### Fixed
+- Fixes UPnP discovery bug, producing excessive CPU usage
+- Fixes sudden SSU thread stop for Windows. 
+
+## [2.10.1] - 2016-11-07
+### Fixed
+- Fixed some performance issues for Windows and Android
+
+## [2.10.0] - 2016-10-17
+### Added
+- Datagram i2p tunnels
+- Unique local addresses for server tunnels
+- Configurable list of reseed servers  and initial addressbook
+- Configurable netid
+- Initial iOS support
+
+### Changed
+- Reduced file descriptiors usage
+- Strict reseed checks enabled by default
+
+## Fixed
+- Multiple fixes in I2CP and BOB implementations
+
+## [2.9.0] - 2016-08-12
+### Changed
+- Proxy refactoring & speedup
+- Transmission-I2P support
+- Graceful shutdown for Windows
+- Android without QT
+- Reduced number of timers in SSU
+- ipv6 peer test support
+- Reseed from SU3 file
+
+## [2.8.0] - 2016-06-20
+### Added
+- Basic Android support
+- I2CP implementation
+- 'doxygen' target
+
+### Changed
+- I2PControl refactoring & fixes (proper jsonrpc responses on errors)
+- boost::regex no more needed
+
+### Fixed
+- initscripts: added openrc one, in sysv-ish make I2PD_PORT optional
+- properly close NTCP sessions (memleak)
+
+## [2.7.0] - 2016-05-18
+### Added
+- Precomputed El-Gamal/DH tables
+- Configurable limit of transit tunnels
+
+### Changed
+- Speed-up of assymetric crypto for non-x64 platforms
+- Refactoring of web-console
+
+## [2.6.0] - 2016-03-31
+### Added
+- Gracefull 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,344 +0,0 @@
-#include <fstream>
-#include <iostream>
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/ini_parser.hpp>
-#include "util.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), m_I2PControlService (nullptr)
-	{
-	}
-	
-	ClientContext::~ClientContext () 
-	{
-		delete m_HttpProxy;
-		delete m_SocksProxy;
-		delete m_SamBridge;
-		delete m_BOBCommandChannel;
-		delete m_I2PControlService;
-	}
-	
-	void ClientContext::Start ()
-	{
-		if (!m_SharedLocalDestination)
-		{	
-			m_SharedLocalDestination = CreateNewLocalDestination (); // non-public, DSA
-			m_Destinations[m_SharedLocalDestination->GetIdentity ().GetIdentHash ()] = m_SharedLocalDestination;
-			m_SharedLocalDestination->Start ();
-		}
-
-		std::shared_ptr<ClientDestination> localDestination;	
-		// proxies	
-		std::string proxyKeys = i2p::util::config::GetArg("-proxykeys", "");
-		if (proxyKeys.length () > 0)
-			localDestination = LoadLocalDestination (proxyKeys, false);
-		m_HttpProxy = new i2p::proxy::HTTPProxy(i2p::util::config::GetArg("-httpproxyport", 4446), localDestination);
-		m_HttpProxy->Start();
-		LogPrint("HTTP Proxy started");
-		m_SocksProxy = new i2p::proxy::SOCKSProxy(i2p::util::config::GetArg("-socksproxyport", 4447), localDestination);
-		m_SocksProxy->Start();
-		LogPrint("SOCKS Proxy Started");
-	
-		// I2P tunnels
-		std::string ircDestination = i2p::util::config::GetArg("-ircdest", "");
-		if (ircDestination.length () > 0) // ircdest is presented
-		{
-			localDestination = nullptr;
-			std::string ircKeys = i2p::util::config::GetArg("-irckeys", "");	
-			if (ircKeys.length () > 0)
-				localDestination = LoadLocalDestination (ircKeys, false);
-			auto ircPort = i2p::util::config::GetArg("-ircport", 6668);
-			auto ircTunnel = new I2PClientTunnel (ircDestination, ircPort, localDestination);
-			ircTunnel->Start ();
-			m_ClientTunnels.insert (std::make_pair(ircPort, std::unique_ptr<I2PClientTunnel>(ircTunnel)));
-			LogPrint("IRC tunnel started");
-		}	
-		std::string eepKeys = i2p::util::config::GetArg("-eepkeys", "");
-		if (eepKeys.length () > 0) // eepkeys file is presented
-		{
-			localDestination = LoadLocalDestination (eepKeys, true);
-			auto serverTunnel = new I2PServerTunnel (i2p::util::config::GetArg("-eephost", "127.0.0.1"),
- 				i2p::util::config::GetArg("-eepport", 80), localDestination);
-			serverTunnel->Start ();
-			m_ServerTunnels.insert (std::make_pair(localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel)));
-			LogPrint("Server tunnel started");
-		}
-		ReadTunnels ();
-
-		// SAM
-		int samPort = i2p::util::config::GetArg("-samport", 0);
-		if (samPort)
-		{
-			m_SamBridge = new SAMBridge (samPort);
-			m_SamBridge->Start ();
-			LogPrint("SAM bridge started");
-		} 
-
-		// BOB
-		int bobPort = i2p::util::config::GetArg("-bobport", 0);
-		if (bobPort)
-		{
-			m_BOBCommandChannel = new BOBCommandChannel (bobPort);
-			m_BOBCommandChannel->Start ();
-			LogPrint("BOB command channel started");
-		} 
-
-		// I2P Control
-		int i2pcontrolPort = i2p::util::config::GetArg("-i2pcontrolport", 0);
-		if (i2pcontrolPort)
-		{
-			m_I2PControlService = new I2PControlService (i2pcontrolPort);
-			m_I2PControlService->Start ();
-			LogPrint("I2PControl started");
-		}
-		m_AddressBook.Start ();
-	}
-		
-	void ClientContext::Stop ()
-	{
-		m_HttpProxy->Stop();
-		delete m_HttpProxy;
-		m_HttpProxy = nullptr;
-		LogPrint("HTTP Proxy stopped");
-		m_SocksProxy->Stop();
-		delete m_SocksProxy;
-		m_SocksProxy = nullptr;
-		LogPrint("SOCKS Proxy stopped");
-		for (auto& it: m_ClientTunnels)
-		{
-			it.second->Stop ();
-			LogPrint("I2P client tunnel on port ", it.first, " stopped");	
-		}
-		m_ClientTunnels.clear ();	
-		for (auto& it: m_ServerTunnels)
-		{
-			it.second->Stop ();
-			LogPrint("I2P server tunnel stopped");	
-		}
-		m_ServerTunnels.clear ();	
-		if (m_SamBridge)
-		{
-			m_SamBridge->Stop ();
-			delete m_SamBridge; 
-			m_SamBridge = nullptr;
-			LogPrint("SAM brdige stopped");	
-		}		
-		if (m_BOBCommandChannel)
-		{
-			m_BOBCommandChannel->Stop ();
-			delete m_BOBCommandChannel; 
-			m_BOBCommandChannel = nullptr;
-			LogPrint("BOB command channel stopped");	
-		}			
-		if (m_I2PControlService)
-		{
-			m_I2PControlService->Stop ();
-			delete m_I2PControlService; 
-			m_I2PControlService = nullptr;
-			LogPrint("I2PControl stopped");	
-		}	
-		m_AddressBook.Stop ();		
-		for (auto it: m_Destinations)
-			it.second->Stop ();
-		m_Destinations.clear ();
-		m_SharedLocalDestination = nullptr; 
-	}	
-	
-	std::shared_ptr<ClientDestination> ClientContext::LoadLocalDestination (const std::string& filename, bool isPublic)
-	{
-		i2p::data::PrivateKeys keys;
-		std::string fullPath = i2p::util::filesystem::GetFullPath (filename);
-		std::ifstream s(fullPath.c_str (), std::ifstream::binary);
-		if (s.is_open ())	
-		{	
-			s.seekg (0, std::ios::end);
-			size_t len = s.tellg();
-			s.seekg (0, std::ios::beg);
-			uint8_t * buf = new uint8_t[len];
-			s.read ((char *)buf, len);
-			keys.FromBuffer (buf, len);
-			delete[] buf;
-			LogPrint ("Local address ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " loaded");
-		}	
-		else
-		{
-			LogPrint ("Can't open file ", fullPath, " Creating new one");
-			keys = i2p::data::PrivateKeys::CreateRandomKeys (i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256); 
-			std::ofstream f (fullPath, std::ofstream::binary | std::ofstream::out);
-			size_t len = keys.GetFullLen ();
-			uint8_t * buf = new uint8_t[len];
-			len = keys.ToBuffer (buf, len);
-			f.write ((char *)buf, len);
-			delete[] buf;
-			
-			LogPrint ("New private keys file ", fullPath, " for ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " created");
-		}	
-
-		std::shared_ptr<ClientDestination> localDestination = nullptr;	
-		std::unique_lock<std::mutex> l(m_DestinationsMutex);	
-		auto it = m_Destinations.find (keys.GetPublic ().GetIdentHash ()); 
-		if (it != m_Destinations.end ())
-		{
-			LogPrint (eLogWarning, "Local destination ",  m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " alreday exists");
-			localDestination = it->second;
-		}
-		else
-		{
-			localDestination = std::make_shared<ClientDestination> (keys, isPublic);
-			m_Destinations[localDestination->GetIdentHash ()] = localDestination;
-			localDestination->Start ();
-		}
-		return localDestination;
-	}
-
-	std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (bool isPublic, i2p::data::SigningKeyType sigType,
-		const std::map<std::string, std::string> * params)
-	{
-		i2p::data::PrivateKeys keys = i2p::data::PrivateKeys::CreateRandomKeys (sigType);
-		auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
-		std::unique_lock<std::mutex> l(m_DestinationsMutex);
-		m_Destinations[localDestination->GetIdentHash ()] = localDestination;
-		localDestination->Start ();
-		return localDestination;
-	}
-
-	void ClientContext::DeleteLocalDestination (std::shared_ptr<ClientDestination> destination)
-	{
-		if (!destination) return;
-		auto it = m_Destinations.find (destination->GetIdentHash ());
-		if (it != m_Destinations.end ())
-		{
-			auto d = it->second;
-			{
-				std::unique_lock<std::mutex> l(m_DestinationsMutex);
-				m_Destinations.erase (it);
-			}	
-			d->Stop ();
-		}
-	}
-
-	std::shared_ptr<ClientDestination> ClientContext::CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic,
-		const std::map<std::string, std::string> * params)
-	{
-		auto it = m_Destinations.find (keys.GetPublic ().GetIdentHash ());
-		if (it != m_Destinations.end ())
-		{
-			LogPrint ("Local destination ", m_AddressBook.ToAddress(keys.GetPublic ().GetIdentHash ()), " exists");
-			if (!it->second->IsRunning ())
-			{	
-				it->second->Start ();
-				return it->second;
-			}	
-			return nullptr;
-		}	
-		auto localDestination = std::make_shared<ClientDestination> (keys, isPublic, params);
-		std::unique_lock<std::mutex> l(m_DestinationsMutex);
-		m_Destinations[keys.GetPublic ().GetIdentHash ()] = localDestination;
-		localDestination->Start ();
-		return localDestination;
-	}
-	
-	std::shared_ptr<ClientDestination> ClientContext::FindLocalDestination (const i2p::data::IdentHash& destination) const
-	{
-		auto it = m_Destinations.find (destination);
-		if (it != m_Destinations.end ())
-			return it->second;
-		return nullptr;
-	}	
-
-	void ClientContext::ReadTunnels ()
-	{
-		boost::property_tree::ptree pt;
-		try
-		{
-			boost::property_tree::read_ini (i2p::util::filesystem::GetFullPath (TUNNELS_CONFIG_FILENAME), pt);
-		}
-		catch (std::exception& ex)
-		{
-			LogPrint (eLogWarning, "Can't read ", TUNNELS_CONFIG_FILENAME, ": ", 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, "");
-					int destinationPort = section.second.get (I2P_CLIENT_TUNNEL_DESTINATION_PORT, 0);
-
-					std::shared_ptr<ClientDestination> localDestination = nullptr;
-					if (keys.length () > 0)
-						localDestination = LoadLocalDestination (keys, false);
-					auto clientTunnel = new I2PClientTunnel (dest, port, localDestination, destinationPort);
-					if (m_ClientTunnels.insert (std::make_pair (port, std::unique_ptr<I2PClientTunnel>(clientTunnel))).second)
-						clientTunnel->Start ();
-					else
-						LogPrint (eLogError, "I2P client tunnel with port ", port, " already exists");
-					numClientTunnels++;
-				}
-				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER)
-				{	
-					// mandatory params
-					std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);
-					int port = section.second.get<int> (I2P_SERVER_TUNNEL_PORT);
-					std::string keys = section.second.get<std::string> (I2P_SERVER_TUNNEL_KEYS);
-					// optional params
-					int inPort = section.second.get (I2P_SERVER_TUNNEL_INPORT, 0);
-					std::string accessList = section.second.get (I2P_SERVER_TUNNEL_ACCESS_LIST, "");					
-
-					auto localDestination = LoadLocalDestination (keys, true);
-					auto serverTunnel = new I2PServerTunnel (host, port, localDestination, inPort);
-					if (accessList.length () > 0)
-					{
-						std::set<i2p::data::IdentHash> idents;
-						size_t pos = 0, comma;
-						do
-						{
-							comma = accessList.find (',', pos);
-							i2p::data::IdentHash ident;
-							ident.FromBase32 (accessList.substr (pos, comma != std::string::npos ? comma - pos : std::string::npos));	
-							idents.insert (ident);
-							pos = comma + 1;
-						}
-						while (comma != std::string::npos);
-						serverTunnel->SetAccessList (idents);
-					}
-					if (m_ServerTunnels.insert (std::make_pair (localDestination->GetIdentHash (), std::unique_ptr<I2PServerTunnel>(serverTunnel))).second)
-						serverTunnel->Start ();
-					else
-						LogPrint (eLogError, "I2P server tunnel for destination ",   m_AddressBook.ToAddress(localDestination->GetIdentHash ()), " already exists");	
-					numServerTunnels++;
-				}
-				else
-					LogPrint (eLogWarning, "Unknown section type=", type, " of ", name, " in ", TUNNELS_CONFIG_FILENAME);
-				
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Can't read tunnel ", name, " params: ", ex.what ());
-			}
-		}	
-		LogPrint (eLogInfo, numClientTunnels, " I2P client tunnels created");
-		LogPrint (eLogInfo, numServerTunnels, " I2P server tunnels created");
-	}	
-}		
-}	

ClientContext.h

@@ -1,85 +0,0 @@
-#ifndef CLIENT_CONTEXT_H__
-#define CLIENT_CONTEXT_H__
-
-#include <map>
-#include <mutex>
-#include <memory>
-#include "Destination.h"
-#include "HTTPProxy.h"
-#include "SOCKS.h"
-#include "I2PTunnel.h"
-#include "SAM.h"
-#include "BOB.h"
-#include "AddressBook.h"
-#include "I2PControl.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_CLIENT_TUNNEL_PORT[] = "port";
-	const char I2P_CLIENT_TUNNEL_DESTINATION[] = "destination";
-	const char I2P_CLIENT_TUNNEL_KEYS[] = "keys";
-	const char I2P_CLIENT_TUNNEL_DESTINATION_PORT[] = "destinationport";	
-	const char I2P_SERVER_TUNNEL_HOST[] = "host";	
-	const char I2P_SERVER_TUNNEL_PORT[] = "port";
-	const char I2P_SERVER_TUNNEL_KEYS[] = "keys";
-	const char I2P_SERVER_TUNNEL_INPORT[] = "inport";
-	const char I2P_SERVER_TUNNEL_ACCESS_LIST[] = "accesslist";		
-	const char TUNNELS_CONFIG_FILENAME[] = "tunnels.cfg";
-
-	class ClientContext
-	{
-		public:
-
-			ClientContext ();
-			~ClientContext ();
-
-			void Start ();
-			void Stop ();
-
-			std::shared_ptr<ClientDestination> GetSharedLocalDestination () const { return m_SharedLocalDestination; };
-			std::shared_ptr<ClientDestination> CreateNewLocalDestination (bool isPublic = false, i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1,
-			    const std::map<std::string, std::string> * params = nullptr); // transient
-			std::shared_ptr<ClientDestination> CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic = true, 
-				const std::map<std::string, std::string> * params = nullptr);
-			void DeleteLocalDestination (std::shared_ptr<ClientDestination> destination);
-			std::shared_ptr<ClientDestination> FindLocalDestination (const i2p::data::IdentHash& destination) const;		
-			std::shared_ptr<ClientDestination> LoadLocalDestination (const std::string& filename, bool isPublic);
-
-			AddressBook& GetAddressBook () { return m_AddressBook; };
-			const SAMBridge * GetSAMBridge () const { return m_SamBridge; };
-		
-		private:
-
-			void ReadTunnels ();
-	
-		private:
-
-			std::mutex m_DestinationsMutex;
-			std::map<i2p::data::IdentHash, std::shared_ptr<ClientDestination> > m_Destinations;
-			std::shared_ptr<ClientDestination>  m_SharedLocalDestination;	
-
-			AddressBook m_AddressBook;
-
-			i2p::proxy::HTTPProxy * m_HttpProxy;
-			i2p::proxy::SOCKSProxy * m_SocksProxy;
-			std::map<int, std::unique_ptr<I2PClientTunnel> > m_ClientTunnels; // port->tunnel
-			std::map<i2p::data::IdentHash, std::unique_ptr<I2PServerTunnel> > m_ServerTunnels; // destination->tunnel
-			SAMBridge * m_SamBridge;
-			BOBCommandChannel * m_BOBCommandChannel;
-			I2PControlService * m_I2PControlService;
-
-		public:
-			// for HTTP
-			const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
-	};
-	
-	extern ClientContext context;	
-}		
-}	
-
-#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,155 +0,0 @@
-#include <thread>
-
-#include "Daemon.h"
-
-#include "Log.h"
-#include "base64.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 "util.h"
-#include "Streaming.h"
-#include "Destination.h"
-#include "HTTPServer.h"
-#include "ClientContext.h"
-
-#ifdef USE_UPNP
-#include "UPnP.h"
-#endif
-
-
-namespace i2p
-{
-	namespace util
-	{
-		class Daemon_Singleton::Daemon_Singleton_Private
-		{
-		public:
-			Daemon_Singleton_Private() : httpServer(nullptr)
-			{};
-			~Daemon_Singleton_Private() 
-			{
-				delete httpServer;
-			};
-
-			i2p::util::HTTPServer *httpServer;
-		};
-
-		Daemon_Singleton::Daemon_Singleton() : running(1), d(*new Daemon_Singleton_Private()) {};
-		Daemon_Singleton::~Daemon_Singleton() {
-			delete &d;
-		};
-
-		bool Daemon_Singleton::IsService () const
-		{
-#ifndef _WIN32
-			return i2p::util::config::GetArg("-service", 0);
-#else
-			return false;
-#endif
-		}
-
-		bool Daemon_Singleton::init(int argc, char* argv[])
-		{
-			i2p::util::config::OptionParser(argc, argv);
-			i2p::context.Init ();
-
-			LogPrint("\n\n\n\ni2pd starting\n");
-			LogPrint("Version ", VERSION);
-			LogPrint("data directory: ", i2p::util::filesystem::GetDataDir().string());
-			i2p::util::filesystem::ReadConfigFile(i2p::util::config::mapArgs, i2p::util::config::mapMultiArgs);
-
-			isDaemon = i2p::util::config::GetArg("-daemon", 0);
-			isLogging = i2p::util::config::GetArg("-log", 1);
-
-			int port = i2p::util::config::GetArg("-port", 0);
-			if (port)
-				i2p::context.UpdatePort (port);					
-			const char * host = i2p::util::config::GetCharArg("-host", "");
-			if (host && host[0])
-				i2p::context.UpdateAddress (boost::asio::ip::address::from_string (host));	
-
-			i2p::context.SetSupportsV6 (i2p::util::config::GetArg("-v6", 0));
-			i2p::context.SetFloodfill (i2p::util::config::GetArg("-floodfill", 0));
-			auto bandwidth = i2p::util::config::GetArg("-bandwidth", "");
-			if (bandwidth.length () > 0)
-			{
-				if (bandwidth[0] > 'L')
-					i2p::context.SetHighBandwidth ();
-				else
-					i2p::context.SetLowBandwidth ();
-			}	
-
-			LogPrint("CMD parameters:");
-			for (int i = 0; i < argc; ++i)
-				LogPrint(i, "  ", argv[i]);
-
-			return true;
-		}
-			
-		bool Daemon_Singleton::start()
-		{
-			// initialize log			
-			if (isLogging)
-			{
-				if (isDaemon)
-				{
-					std::string logfile_path = IsService () ? "/var/log" : i2p::util::filesystem::GetDataDir().string();
-#ifndef _WIN32
-					logfile_path.append("/i2pd.log");
-#else
-					logfile_path.append("\\i2pd.log");
-#endif
-					StartLog (logfile_path);
-				}
-				else
-					StartLog (""); // write to stdout
-			}
-
-			d.httpServer = new i2p::util::HTTPServer(i2p::util::config::GetArg("-httpport", 7070));
-			d.httpServer->Start();
-			LogPrint("HTTP Server started");
-			i2p::data::netdb.Start();
-			LogPrint("NetDB started");
-			i2p::transport::transports.Start();
-			LogPrint("Transports started");
-			i2p::tunnel::tunnels.Start();
-			LogPrint("Tunnels started");
-			i2p::client::context.Start ();
-			LogPrint("Client started");
-#ifdef USE_UPNP
-            i2p::UPnP::upnpc.Start();
-            LogPrint("UPnP module loaded");
-#endif
-			return true;
-		}
-
-		bool Daemon_Singleton::stop()
-		{
-			LogPrint("Shutdown started.");
-			i2p::client::context.Stop();
-			LogPrint("Client stopped");
-			i2p::tunnel::tunnels.Stop();
-			LogPrint("Tunnels stopped");
-			i2p::transport::transports.Stop();
-			LogPrint("Transports stopped");
-			i2p::data::netdb.Stop();
-			LogPrint("NetDB stopped");
-			d.httpServer->Stop();
-			LogPrint("HTTP Server stopped");
-#ifdef USE_UPNP
-			i2p::UPnP::upnpc.Stop();
-#endif
-			StopLog ();
-
-			delete d.httpServer; d.httpServer = nullptr;
-
-			return true;
-		}
-	}
-}

Daemon.h

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

DaemonLinux.cpp

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

DaemonWin32.cpp

@@ -1,83 +0,0 @@
-#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::util::config::GetArg("-service", "none");
-			if (serviceControl == "install")
-			{
-				InstallService(
-					SERVICE_NAME,               // Name of service
-					SERVICE_DISPLAY_NAME,       // Name to display
-					SERVICE_START_TYPE,         // Service start type
-					SERVICE_DEPENDENCIES,       // Dependencies
-					SERVICE_ACCOUNT,            // Service running account
-					SERVICE_PASSWORD            // Password of the account
-					);
-				exit(0);
-			}
-			else if (serviceControl == "remove")
-			{
-				UninstallService(SERVICE_NAME);
-				exit(0);
-			}
-			else if (serviceControl != "none")
-			{
-				printf(" --service=install  to install the service.\n");
-				printf(" --service=remove   to remove the service.\n");
-			}
-			
-			if (isDaemon == 1)
-			{
-				LogPrint("Service session");
-				I2PService service(SERVICE_NAME);
-				if (!I2PService::Run(service))
-				{
-					LogPrint("Service failed to run w/err 0x%08lx\n", GetLastError());
-					exit(EXIT_FAILURE);
-				}
-				exit(EXIT_SUCCESS);
-			}
-			else
-				LogPrint("User session");
-
-			return true;
-		}
-		bool DaemonWin32::start()
-		{
-			setlocale(LC_CTYPE, "");
-			SetConsoleCP(1251);
-			SetConsoleOutputCP(1251);
-			setlocale(LC_ALL, "Russian");
-
-			return Daemon_Singleton::start();
-		}
-
-		bool DaemonWin32::stop()
-		{
-			return Daemon_Singleton::stop();
-		}
-	}
-}
-
-#endif

Datagram.cpp

@@ -1,155 +0,0 @@
-#include <string.h>
-#include <vector>
-#include <cryptopp/sha.h>
-#include <cryptopp/gzip.h>
-#include "Log.h"
-#include "TunnelBase.h"
-#include "RouterContext.h"
-#include "Destination.h"
-#include "Datagram.h"
-
-namespace i2p
-{
-namespace datagram
-{
-	DatagramDestination::DatagramDestination (i2p::client::ClientDestination& owner): 
-		m_Owner (owner), m_Receiver (nullptr)
-	{
-	}
-
-	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];	
-			CryptoPP::SHA256().CalculateDigest (hash, buf1, len);
-			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, ident));
-	}
-
-	void DatagramDestination::HandleLeaseSetRequestComplete (bool success, I2NPMessage * msg, i2p::data::IdentHash ident)
-	{
-		if (success)
-		{
-			auto remote = m_Owner.FindLeaseSet (ident);
-			if (remote)
-			{
-				SendMsg (msg, remote);
-				return;
-			}	
-		}
-		DeleteI2NPMessage (msg);
-	}	
-		
-	void DatagramDestination::SendMsg (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 = i2p::context.GetRandomNumberGenerator ().GenerateWord32 (0, leases.size () - 1);
-			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");
-			DeleteI2NPMessage (msg);	
-		}	
-	}
-
-	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];
-			CryptoPP::SHA256().CalculateDigest (hash, buf + headerLen, len - headerLen);
-			verified = identity.Verify (hash, 32, signature);
-		}	
-		else	
-			verified = identity.Verify (buf + headerLen, len - headerLen, signature);
-				
-		if (verified)
-		{
-			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
-		CryptoPP::Gunzip decompressor;
-		decompressor.Put (buf, len);
-		decompressor.MessageEnd();
-		uint8_t uncompressed[MAX_DATAGRAM_SIZE];
-		auto uncompressedLen = decompressor.MaxRetrievable ();
-		if (uncompressedLen <= MAX_DATAGRAM_SIZE)
-		{
-			decompressor.Get (uncompressed, uncompressedLen);
-			HandleDatagram (fromPort, toPort, uncompressed, uncompressedLen); 
-		}
-		else
-			LogPrint ("Received datagram size ", uncompressedLen,  " exceeds max size");
-
-	}
-
-	I2NPMessage * DatagramDestination::CreateDataMessage (const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort)
-	{
-		I2NPMessage * msg = NewI2NPMessage ();
-		CryptoPP::Gzip compressor; // default level
-		compressor.Put (payload, len);
-		compressor.MessageEnd();
-		int size = compressor.MaxRetrievable ();
-		uint8_t * buf = msg->GetPayload ();
-		htobe32buf (buf, size); // length
-		buf += 4;
-		compressor.Get (buf, size);
-		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; 
-		FillI2NPMessageHeader (msg, eI2NPData);
-		return msg;
-	}	
-}
-}
-

Datagram.h

@@ -1,52 +0,0 @@
-#ifndef DATAGRAM_H__
-#define DATAGRAM_H__
-
-#include <inttypes.h>
-#include <memory>
-#include <functional>
-#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 (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; };
-
-		private:
-
-			void HandleLeaseSetRequestComplete (bool success, I2NPMessage * msg, i2p::data::IdentHash ident);
-			
-			I2NPMessage * CreateDataMessage (const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort);
-			void SendMsg (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:
-
-			i2p::client::ClientDestination& m_Owner;
-			Receiver m_Receiver;
-	};		
-}
-}
-
-#endif
-

Destination.cpp

@@ -1,621 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <boost/lexical_cast.hpp>
-#include "Log.h"
-#include "util.h"
-#include "ElGamal.h"
-#include "Timestamp.h"
-#include "NetDb.h"
-#include "AddressBook.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_LeaseSet (nullptr), m_IsPublic (isPublic), m_PublishReplyToken (0),
-		m_DatagramDestination (nullptr), m_PublishConfirmationTimer (m_Service), m_CleanupTimer (m_Service)
-	{
-		i2p::crypto::GenerateElGamalKeyPair(i2p::context.GetRandomNumberGenerator (), m_EncryptionPrivateKey, m_EncryptionPublicKey);
-		int inboundTunnelLen = DEFAULT_INBOUND_TUNNEL_LENGTH;
-		int outboundTunnelLen = DEFAULT_OUTBOUND_TUNNEL_LENGTH;
-		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, "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, "Outbound tunnel length set to ", len);
-				}
-			}	
-		}	
-		m_Pool = i2p::tunnel::tunnels.CreateTunnelPool (this, inboundTunnelLen, outboundTunnelLen);  
-		if (m_IsPublic)
-			LogPrint (eLogInfo, "Local address ", i2p::client::GetB32Address(GetIdentHash()), " created");
-		m_StreamingDestination = std::make_shared<i2p::stream::StreamingDestination> (*this); // TODO:
-	}
-
-	ClientDestination::~ClientDestination ()
-	{
-		if (m_IsRunning)	
-			Stop ();
-		for (auto it: m_LeaseSetRequests)
-			delete it.second;
-		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 ("Destination: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void ClientDestination::Start ()
-	{	
-		if (!m_IsRunning)
-		{	
-			m_IsRunning = true;
-			m_Pool->SetLocalDestination (this);
-			m_Pool->SetActive (true);
-			m_Thread = new std::thread (std::bind (&ClientDestination::Run, this));
-			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,
-				this, std::placeholders::_1));
-		}	
-	}
-		
-	void ClientDestination::Stop ()
-	{	
-		if (m_IsRunning)
-		{	
-			m_CleanupTimer.cancel ();
-			m_IsRunning = false;
-			m_StreamingDestination->Stop ();	
-			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->HasNonExpiredLeases ())
-				return it->second;
-			else
-				LogPrint ("All leases of remote LeaseSet expired");
-		}	
-		else
-		{	
-			auto ls = i2p::data::netdb.FindLeaseSet (ident);
-			if (ls)
-			{
-				m_RemoteLeaseSets[ident] = ls;			
-				return ls;
-			}	
-		}
-		return nullptr;
-	}	
-
-	const i2p::data::LeaseSet * ClientDestination::GetLeaseSet ()
-	{
-		if (!m_Pool) return nullptr;
-		if (!m_LeaseSet)
-			UpdateLeaseSet ();
-		return m_LeaseSet;
-	}	
-
-	void ClientDestination::UpdateLeaseSet ()
-	{
-		auto newLeaseSet = new i2p::data::LeaseSet (*m_Pool);
-		if (!m_LeaseSet)
-			m_LeaseSet = newLeaseSet;
-		else
-		{	
-			// TODO: implement it better
-			*m_LeaseSet = *newLeaseSet;
-			delete newLeaseSet;
-		}	
-	}	
-
-	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);
-		m_Service.post ([this,data](void)
-			{
-				this->AddSessionKey (data.k, data.t);
-			});
-		return true;
-	}
-
-	void ClientDestination::ProcessGarlicMessage (I2NPMessage * msg)
-	{
-		m_Service.post (std::bind (&ClientDestination::HandleGarlicMessage, this, msg)); 
-	}
-
-	void ClientDestination::ProcessDeliveryStatusMessage (I2NPMessage * msg)
-	{
-		m_Service.post (std::bind (&ClientDestination::HandleDeliveryStatusMessage, 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 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, "Reply token is ignored for DatabaseStore");
-			offset += 36;
-		}
-		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 ())
-			{
-				it->second->Update (buf + offset, len - offset); 
-				LogPrint (eLogDebug, "Remote LeaseSet updated");
-			}
-			else
-			{	
-				LogPrint (eLogDebug, "New remote LeaseSet added");
-				m_RemoteLeaseSets[buf + DATABASE_STORE_KEY_OFFSET] = std::make_shared<i2p::data::LeaseSet> (buf + offset, len - offset);
-			}	
-		}	
-		else
-			LogPrint (eLogError, "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 (true);
-			delete it1->second;
-			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 ("DatabaseSearchReply for ", key.ToBase64 (), " num=", num);
-		auto it = m_LeaseSetRequests.find (key);
-		if (it != m_LeaseSetRequests.end ())
-		{
-			LeaseSetRequest * 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, "Requesting ", key.ToBase64 (), " at ", peerHash.ToBase64 ());
-						if (SendLeaseSetRequest (key, floodfill, request))
-							found = true;
-					}	
-					else
-					{	
-						LogPrint (eLogInfo, "Found new floodfill. Request it");
-						i2p::data::netdb.RequestDestination (peerHash);
-					}	
-				}
-				if (!found)
-					LogPrint (eLogError, "Suggested floodfills are not presented in netDb"); 
-			}	
-			else
-				LogPrint (eLogInfo, key.ToBase64 (), " was not found on ",  MAX_NUM_FLOODFILLS_PER_REQUEST," floodfills");
-			if (!found)
-			{
-				if (request->requestComplete) request->requestComplete (false);
-				delete request;
-				m_LeaseSetRequests.erase (key);
-			}	
-		}	
-		else	
-			LogPrint ("Request for ", key.ToBase64 (), " not found");
-	}	
-		
-	void ClientDestination::HandleDeliveryStatusMessage (I2NPMessage * msg)
-	{
-		uint32_t msgID = bufbe32toh (msg->GetPayload () + DELIVERY_STATUS_MSGID_OFFSET);
-		if (msgID == m_PublishReplyToken)
-		{
-			LogPrint (eLogDebug, "Publishing confirmed");
-			m_ExcludedFloodfills.clear ();
-			m_PublishReplyToken = 0;
-			i2p::DeleteI2NPMessage (msg);
-		}
-		else
-			i2p::garlic::GarlicDestination::HandleDeliveryStatusMessage (msg);
-	}	
-
-	void ClientDestination::SetLeaseSetUpdated ()
-	{
-		i2p::garlic::GarlicDestination::SetLeaseSetUpdated ();	
-		UpdateLeaseSet ();
-		if (m_IsPublic)
-			Publish ();
-	}
-		
-	void ClientDestination::Publish ()
-	{	
-		if (!m_LeaseSet || !m_Pool) 
-		{
-			LogPrint (eLogError, "Can't publish non-existing LeaseSet");
-			return;
-		}
-		if (m_PublishReplyToken)
-		{
-			LogPrint (eLogInfo, "Publishing is pending");
-			return;
-		}
-		auto outbound = m_Pool->GetNextOutboundTunnel ();
-		if (!outbound)
-		{
-			LogPrint ("Can't publish LeaseSet. No outbound tunnels");
-			return;
-		}
-		std::set<i2p::data::IdentHash> excluded; 
-		auto floodfill = i2p::data::netdb.GetClosestFloodfill (m_LeaseSet->GetIdentHash (), m_ExcludedFloodfills);	
-		if (!floodfill)
-		{
-			LogPrint ("Can't publish LeaseSet. No more floodfills found");
-			m_ExcludedFloodfills.clear ();
-			return;
-		}	
-		m_ExcludedFloodfills.insert (floodfill->GetIdentHash ());
-		LogPrint (eLogDebug, "Publish LeaseSet of ", GetIdentHash ().ToBase32 ());
-		m_PublishReplyToken = i2p::context.GetRandomNumberGenerator ().GenerateWord32 ();
-		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,
-			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, "Publish confirmation was not received in ", PUBLISH_CONFIRMATION_TIMEOUT,  "seconds. Try again");
-				m_PublishReplyToken = 0;
-				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 ("Missing streaming destination");
-			}
-			break;
-			case PROTOCOL_TYPE_DATAGRAM:
-				// datagram protocol
-				if (m_DatagramDestination)
-					m_DatagramDestination->HandleDataMessagePayload (fromPort, toPort, buf, length);
-				else
-					LogPrint ("Missing streaming destination");
-			break;
-			default:
-				LogPrint ("Data: unexpected protocol ", buf[9]);
-		}
-	}	
-
-	void ClientDestination::CreateStream (StreamRequestComplete streamRequestComplete, const i2p::data::IdentHash& dest, int port) {
-		assert(streamRequestComplete);
-		auto leaseSet = FindLeaseSet (dest);
-		if (leaseSet)
-			streamRequestComplete(CreateStream (leaseSet, port));
-		else
-		{
-			RequestDestination (dest,
-				[this, streamRequestComplete, dest, port](bool success)
-				{
-					if (!success)
-						streamRequestComplete (nullptr);
-					else
-					{
-						auto leaseSet = FindLeaseSet (dest);
-						if (leaseSet)
-							streamRequestComplete(CreateStream (leaseSet, 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)
-	{
-		auto dest = std::make_shared<i2p::stream::StreamingDestination> (*this, port); 
-		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 (*this);
-		return m_DatagramDestination;	
-	}
-
-	bool ClientDestination::RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete)
-	{
-		if (!m_Pool || !IsReady ()) 
-		{	
-			if (requestComplete) requestComplete (false);
-			return false;
-		}	
-		m_Service.post (std::bind (&ClientDestination::RequestLeaseSet, this, dest, requestComplete));
-		return true;
-	}
-
-	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)
-		{
-			LeaseSetRequest * request = new LeaseSetRequest (m_Service);
-			request->requestComplete = requestComplete;
-			auto ret = m_LeaseSetRequests.insert (std::pair<i2p::data::IdentHash, LeaseSetRequest *>(dest,request));
-			if (ret.second) // inserted
-			{
-				if (!SendLeaseSetRequest (dest, floodfill, request))
-				{
-					// request failed
-					if (request->requestComplete) request->requestComplete (false);
-					delete request;
-					m_LeaseSetRequests.erase (dest);
-				}
-			}	
-			else // duplicate
-			{
-				LogPrint (eLogError, "Request of ", dest.ToBase64 (), " is pending already");
-				// TODO: queue up requests
-				if (request->requestComplete) request->requestComplete (false);
-				delete request;
-			}	
-		}	
-		else
-			LogPrint (eLogError, "No floodfills found");	
-	}	
-		
-	bool ClientDestination::SendLeaseSetRequest (const i2p::data::IdentHash& dest, 
-		std::shared_ptr<const i2p::data::RouterInfo>  nextFloodfill, LeaseSetRequest * request)
-	{
-		auto replyTunnel = m_Pool->GetNextInboundTunnel ();
-		if (!replyTunnel) LogPrint (eLogError, "No inbound tunnels found");	
-		
-		auto outboundTunnel = m_Pool->GetNextOutboundTunnel ();
-		if (!outboundTunnel) LogPrint (eLogError, "No outbound tunnels found");		
-			
-		if (replyTunnel && outboundTunnel)
-		{	
-			request->excluded.insert (nextFloodfill->GetIdentHash ());
-			request->requestTime = i2p::util::GetSecondsSinceEpoch ();
-			request->requestTimeoutTimer.cancel ();
-
-			CryptoPP::AutoSeededRandomPool rnd;
-			uint8_t replyKey[32], replyTag[32];
-			rnd.GenerateBlock (replyKey, 32); // random session key 
-			rnd.GenerateBlock (replyTag, 32); // random session tag
-			AddSessionKey (replyKey, replyTag);
-
-			I2NPMessage * msg = WrapMessage (nextFloodfill,
-				CreateLeaseSetDatabaseLookupMsg (dest, request->excluded, 
-					replyTunnel.get (), replyKey, replyTag));
-			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,
-				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)
-						 done = !SendLeaseSetRequest (dest, floodfill, it->second);
-					else
-						done = true;
-				}
-				else
-				{	
-					LogPrint (eLogInfo, dest.ToBase64 (), " was not found within ",  MAX_LEASESET_REQUEST_TIMEOUT, " seconds");
-					done = true;
-				}
-				
-				if (done)
-				{
-					if (it->second->requestComplete) it->second->requestComplete (false);
-					delete it->second;
-					m_LeaseSetRequests.erase (it);
-				}	
-			}	
-		}	
-	}
-
-	void ClientDestination::HandleCleanupTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-		{
-			CleanupRoutingSessions ();
-			CleanupRemoteLeaseSets ();
-			m_CleanupTimer.expires_from_now (boost::posix_time::minutes (DESTINATION_CLEANUP_TIMEOUT));
-			m_CleanupTimer.async_wait (std::bind (&ClientDestination::HandleCleanupTimer,
-				this, std::placeholders::_1));
-		}
-	}	
-
-	void ClientDestination::CleanupRemoteLeaseSets ()
-	{
-		for (auto it = m_RemoteLeaseSets.begin (); it != m_RemoteLeaseSets.end ();)
-		{
-			if (!it->second->HasNonExpiredLeases ()) // all leases expired
-			{
-				LogPrint ("Remote LeaseSet ", it->second->GetIdentHash ().ToBase64 (), " expired");
-				it = m_RemoteLeaseSets.erase (it);
-			}	
-			else 
-				it++;
-		}
-	}
-}
-}

Destination.h

@@ -1,149 +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 "CryptoConst.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 LEASESET_REQUEST_TIMEOUT = 5; // in seconds
-	const int MAX_LEASESET_REQUEST_TIMEOUT = 40; // in seconds
-	const int MAX_NUM_FLOODFILLS_PER_REQUEST = 7;
-	const int DESTINATION_CLEANUP_TIMEOUT = 20; // in minutes 
-	
-	// 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 int STREAM_REQUEST_TIMEOUT = 60; //in seconds
-
-	typedef std::function<void (std::shared_ptr<i2p::stream::Stream> stream)> StreamRequestComplete;
-
-	class ClientDestination: public i2p::garlic::GarlicDestination
-	{
-		typedef std::function<void (bool success)> RequestComplete;
-		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;
-		};	
-		
-		
-		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->HasNonExpiredLeases (); };
-			std::shared_ptr<const i2p::data::LeaseSet> FindLeaseSet (const i2p::data::IdentHash& ident);
-			bool RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete = nullptr);
-			
-			// streaming
-			std::shared_ptr<i2p::stream::StreamingDestination> CreateStreamingDestination (int port); // 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
-			const i2p::data::LeaseSet * GetLeaseSet ();
-			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 (I2NPMessage * msg);
-			void ProcessDeliveryStatusMessage (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 HandleDatabaseStoreMessage (const uint8_t * buf, size_t len);
-			void HandleDatabaseSearchReplyMessage (const uint8_t * buf, size_t len);
-			void HandleDeliveryStatusMessage (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, 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 ();
-			
-		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, LeaseSetRequest *> m_LeaseSetRequests;
-
-			std::shared_ptr<i2p::tunnel::TunnelPool> m_Pool;
-			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_CleanupTimer;
-
-		public:
-			
-			// for HTTP only
-			int GetNumRemoteLeaseSets () const { return m_RemoteLeaseSets.size (); };
-	};	
-}	
-}	
-
-#endif

Dockerfile

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

ElGamal.h

@@ -1,89 +0,0 @@
-#ifndef EL_GAMAL_H__
-#define EL_GAMAL_H__
-
-#include <inttypes.h>
-#include <cryptopp/integer.h>
-#include <cryptopp/osrng.h>
-#include <cryptopp/dh.h>
-#include <cryptopp/sha.h>
-#include "CryptoConst.h"
-#include "Log.h"
-
-namespace i2p
-{
-namespace crypto
-{
-
-	class ElGamalEncryption
-	{
-		public:
-
-			ElGamalEncryption (const uint8_t * key)
-			{
-				CryptoPP::AutoSeededRandomPool rnd;	
-				CryptoPP::Integer y (key, 256), k (rnd, CryptoPP::Integer::One(), elgp-1);
-				a = a_exp_b_mod_c (elgg, k, elgp);
-				b1 = a_exp_b_mod_c (y, k, elgp);
-			}
-
-			void Encrypt (const uint8_t * data, int len, uint8_t * encrypted, bool zeroPadding = false)
-			{
-				// calculate b = b1*m mod p
-				uint8_t m[255];
-				m[0] = 0xFF;
-				memcpy (m+33, data, len);
-				CryptoPP::SHA256().CalculateDigest(m+1, m+33, 222);
-				CryptoPP::Integer b (a_times_b_mod_c (b1, CryptoPP::Integer (m, 255), elgp));
-
-				// copy a and b
-				if (zeroPadding)
-				{
-					encrypted[0] = 0;
-					a.Encode (encrypted + 1, 256);
-					encrypted[257] = 0;
-					b.Encode (encrypted + 258, 256);
-				}	
-				else
-				{
-					a.Encode (encrypted, 256);	
-					b.Encode (encrypted + 256, 256);
-				}	
-			}
-
-		private:
-
-			CryptoPP::Integer a, b1;	
-	};
-
-	inline bool ElGamalDecrypt (const uint8_t * key, const uint8_t * encrypted, 
-		uint8_t * data, bool zeroPadding = false)
-	{
-		CryptoPP::Integer x(key, 256), a(zeroPadding? encrypted +1 : encrypted, 256), 
-			b(zeroPadding? encrypted + 258 :encrypted + 256, 256);
-		uint8_t m[255], hash[32];
-		a_times_b_mod_c (b, a_exp_b_mod_c (a, elgp - x - 1, elgp), elgp).Encode (m, 255);
-		CryptoPP::SHA256().CalculateDigest(hash, m+33, 222);
-		for (int i = 0; i < 32; i++)
-			if (hash[i] != m[i+1])
-			{
-				LogPrint ("ElGamal decrypt hash doesn't match");
-				return false;
-			}
-		memcpy (data, m + 33, 222);
-		return true;
-	}	
-
-	inline void GenerateElGamalKeyPair (CryptoPP::RandomNumberGenerator& rnd, uint8_t * priv, uint8_t * pub)
-	{
-#if defined(__x86_64__) || defined(__i386__) || defined(_MSC_VER)	
-		rnd.GenerateBlock (priv, 256);
-		a_exp_b_mod_c (elgg, CryptoPP::Integer (priv, 256), elgp).Encode (pub, 256);
-#else
-		CryptoPP::DH dh (elgp, elgg);
-		dh.GenerateKeyPair(rnd, priv, pub);	
-#endif		
-	}	
-}
-}	
-
-#endif

Garlic.cpp

@@ -1,614 +0,0 @@
-#include <inttypes.h>
-#include "I2PEndian.h"
-#include <map>
-#include <string>
-#include "RouterContext.h"
-#include "I2NPProtocol.h"
-#include "Tunnel.h"
-#include "TunnelPool.h"
-#include "Timestamp.h"
-#include "Destination.h"
-#include "Garlic.h"
-
-namespace i2p
-{
-namespace garlic
-{
-	GarlicRoutingSession::GarlicRoutingSession (GarlicDestination * owner, 
-	    std::shared_ptr<const i2p::data::RoutingDestination> destination, int numTags):
-		m_Owner (owner), m_Destination (destination), m_NumTags (numTags), 
-		m_LeaseSetUpdateStatus (numTags > 0 ? eLeaseSetUpdated : eLeaseSetUpToDate)
-	{
-		// create new session tags and session key
-		m_Rnd.GenerateBlock (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 (eLeaseSetUpToDate)
-	{
-		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 ();
-	}
-	
-	GarlicRoutingSession::UnconfirmedTags * GarlicRoutingSession::GenerateSessionTags ()
-	{
-		auto tags = new UnconfirmedTags (m_NumTags);
-		tags->tagsCreationTime = i2p::util::GetSecondsSinceEpoch ();		
-		for (int i = 0; i < m_NumTags; i++)
-		{
-			m_Rnd.GenerateBlock (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, "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_EXPIRATION_TIMEOUT)
-			{
-				if (m_Owner)
-					m_Owner->RemoveCreatedSession (it->first);
-				delete it->second;
-				it = m_UnconfirmedTagsMsgs.erase (it);
-			}	
-			else
-				it++;
-		}	
-		return !m_SessionTags.empty () || m_UnconfirmedTagsMsgs.empty ();
- 	}
-
-	I2NPMessage * GarlicRoutingSession::WrapSingleMessage (I2NPMessage * msg)
-	{
-		I2NPMessage * 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 ("No garlic tags available. Use ElGamal");
-			if (!m_Destination)
-			{
-				LogPrint ("Can't use ElGamal for unknown destination");
-				return nullptr;
-			}
-			// create ElGamal block
-			ElGamalBlock elGamal;
-			memcpy (elGamal.sessionKey, m_SessionKey, 32); 
-			m_Rnd.GenerateBlock (elGamal.preIV, 32); // Pre-IV
-			uint8_t iv[32]; // IV is first 16 bytes
-			CryptoPP::SHA256().CalculateDigest(iv, elGamal.preIV, 32); 
-			m_Destination->GetElGamalEncryption ()->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
-			CryptoPP::SHA256().CalculateDigest(iv, tag, 32);
-			m_Encryption.SetIV (iv);
-			buf += 32;
-			len += 32;		
-		}	
-		// AES block
-		len += CreateAESBlock (buf, msg);
-		htobe32buf (m->GetPayload (), len);
-		m->len += len + 4;
-		FillI2NPMessageHeader (m, eI2NPGarlic);
-		if (msg)
-			DeleteI2NPMessage (msg);
-		return m;
-	}	
-
-	size_t GarlicRoutingSession::CreateAESBlock (uint8_t * buf, 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);
-		CryptoPP::SHA256().CalculateDigest(payloadHash, buf + blockSize, len);
-		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, const I2NPMessage * msg, UnconfirmedTags * newTags)
-	{
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 5000; // 5 sec
-		uint32_t msgID = m_Rnd.GenerateWord32 ();	
-		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 
-				size += CreateDeliveryStatusClove (payload + size, msgID);
-				if (size > 0) // successive?
-				{
-					(*numCloves)++;
-					if (newTags) // new tags created
-						m_UnconfirmedTagsMsgs[msgID] = newTags;
-					m_Owner->DeliveryStatusSent (shared_from_this (), msgID);
-				}
-				else
-					LogPrint ("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);
-				DeleteI2NPMessage (leaseSet);
-				(*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, const I2NPMessage * msg, bool isDestination)
-	{
-		uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 5000; // 5 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 ();
-		htobe32buf (buf + size, m_Rnd.GenerateWord32 ()); // 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 leases = m_Owner->GetLeaseSet ()->GetNonExpiredLeases ();
-			if (!leases.empty ())
-			{	
-				buf[size] = eGarlicDeliveryTypeTunnel << 5; // delivery instructions flag tunnel
-				size++;
-				uint32_t i = m_Rnd.GenerateWord32 (0, leases.size () - 1);
-				// hash and tunnelID sequence is reversed for Garlic 
-				memcpy (buf + size, leases[i].tunnelGateway, 32); // To Hash
-				size += 32;
-				htobe32buf (buf + size, leases[i].tunnelID); // tunnelID
-				size += 4; 	
-				// create msg 
-				I2NPMessage * msg = CreateDeliveryStatusMsg (msgID);
-				if (m_Owner)
-				{
-					//encrypt 
-					uint8_t key[32], tag[32];
-					m_Rnd.GenerateBlock (key, 32); // random session key 
-					m_Rnd.GenerateBlock (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 ();
-				DeleteI2NPMessage (msg);
-				// fill clove
-				uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 5000; // 5 sec
-				htobe32buf (buf + size, m_Rnd.GenerateWord32 ()); // CloveID
-				size += 4;
-				htobe64buf (buf + size, ts); // Expiration of clove
-				size += 8;
-				memset (buf + size, 0, 3); // certificate of clove
-				size += 3;
-			}
-			else	
-				LogPrint ("All tunnels of local LeaseSet expired");	
-		}
-		else
-			LogPrint ("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 (I2NPMessage * msg)
-	{
-		uint8_t * buf = msg->GetPayload ();
-		uint32_t length = bufbe32toh (buf);
-		buf += 4; // length
-		auto it = m_Tags.find (SessionTag(buf));
-		if (it != m_Tags.end ())
-		{
-			// tag found. Use AES
-			uint8_t iv[32]; // IV is first 16 bytes
-			CryptoPP::SHA256().CalculateDigest(iv, buf, 32);
-			it->second->SetIV (iv);
-			it->second->Decrypt (buf + 32, length - 32, buf + 32);
-			HandleAESBlock (buf + 32, length - 32, it->second, msg->from);
-			m_Tags.erase (it); // tag might be used only once
-		}
-		else
-		{
-			// tag not found. Use ElGamal
-			ElGamalBlock elGamal;
-			if (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
-				CryptoPP::SHA256().CalculateDigest(iv, elGamal.preIV, 32); 
-				decryption->SetIV (iv);
-				decryption->Decrypt(buf + 514, length - 514, buf + 514);
-				HandleAESBlock (buf + 514, length - 514, decryption, msg->from);
-			}	
-			else
-				LogPrint ("Failed to decrypt garlic");
-		}
-		DeleteI2NPMessage (msg);
-
-		// cleanup expired tags
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		if (ts > m_LastTagsCleanupTime + INCOMING_TAGS_EXPIRATION_TIMEOUT)
-		{
-			if (m_LastTagsCleanupTime)
-			{
-				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++;
-				}
-				LogPrint (numExpiredTags, " tags expired for ", GetIdentHash().ToBase64 ());
-			}	
-			m_LastTagsCleanupTime = ts;
-		}	
-	}	
-
-	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, "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, "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
-		if (!CryptoPP::SHA256().VerifyDigest (payloadHash, buf, payloadSize)) // payload hash doesn't match
-		{
-			LogPrint ("Wrong payload hash");
-			return;
-		}		    
-		HandleGarlicPayload (buf, payloadSize, from);
-	}	
-
-	void GarlicDestination::HandleGarlicPayload (uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		int numCloves = buf[0];
-		LogPrint (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 ("Clove encrypted");
-				buf += 32; 
-			}	
-			GarlicDeliveryType deliveryType = (GarlicDeliveryType)((flag >> 5) & 0x03);
-			switch (deliveryType)
-			{
-				case eGarlicDeliveryTypeLocal:
-					LogPrint ("Garlic type local");
-					HandleI2NPMessage (buf, len, from);
-				break;	
-				case eGarlicDeliveryTypeDestination:	
-					LogPrint ("Garlic type destination");
-					buf += 32; // destination. check it later or for multiple destinations
-					HandleI2NPMessage (buf, len, from);
-				break;
-				case eGarlicDeliveryTypeTunnel:
-				{	
-					LogPrint ("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
-					{	
-						I2NPMessage * msg = CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from);
-						tunnel->SendTunnelDataMsg (gwHash, gwTunnel, msg);
-					}	
-					else
-						LogPrint ("No outbound tunnels available for garlic clove");
-					break;
-				}
-				case eGarlicDeliveryTypeRouter:
-					LogPrint ("Garlic type router not supported");
-					buf += 32;
-				break;	
-				default:
-					LogPrint ("Unknow garlic delivery type ", (int)deliveryType);
-			}
-			buf += GetI2NPMessageLength (buf); //  I2NP
-			buf += 4; // CloveID
-			buf += 8; // Date
-			buf += 3; // Certificate
-		}	
-	}	
-	
-	I2NPMessage * GarlicDestination::WrapMessage (std::shared_ptr<const i2p::data::RoutingDestination> destination, 
-		I2NPMessage * msg, bool attachLeaseSet)	
-	{
-		if (attachLeaseSet) // we should maintain this session
-		{	
-			auto session = GetRoutingSession (destination, 32);  // 32 tags by default
-			return session->WrapSingleMessage (msg);	
-		}
-		else // one time session
-		{
-			GarlicRoutingSession session (this, destination, 0); // don't use tag if no LeaseSet
-			return session.WrapSingleMessage (msg);
-		}	
-	}
-
-	std::shared_ptr<GarlicRoutingSession> GarlicDestination::GetRoutingSession (
-		std::shared_ptr<const i2p::data::RoutingDestination> destination, int numTags)
-	{
-		auto it = m_Sessions.find (destination->GetIdentHash ());
-		std::shared_ptr<GarlicRoutingSession> session;
-		if (it != m_Sessions.end ())
-			session = it->second;
-		if (!session)
-		{
-			session = std::make_shared<GarlicRoutingSession> (this, destination, numTags); 
-			std::unique_lock<std::mutex> l(m_SessionsMutex);
-			m_Sessions[destination->GetIdentHash ()] = session;
-		}	
-		return session;
-	}	
-	
-	void GarlicDestination::CleanupRoutingSessions ()
-	{
-		std::unique_lock<std::mutex> l(m_SessionsMutex);
-		for (auto it = m_Sessions.begin (); it != m_Sessions.end ();)
-		{
-			if (!it->second->CleanupExpiredTags ())
-			{
-				LogPrint (eLogInfo, "Routing session to ", it->first.ToBase32 (), " deleted");
-				it = m_Sessions.erase (it);
-			}
-			else
-				it++;
-		}
-	}
-	
-	void GarlicDestination::RemoveCreatedSession (uint32_t msgID)
-	{
-		m_CreatedSessions.erase (msgID);
-	}
-
-	void GarlicDestination::DeliveryStatusSent (std::shared_ptr<GarlicRoutingSession> session, uint32_t msgID)
-	{
-		m_CreatedSessions[msgID] = session;
-	}		
-
-	void GarlicDestination::HandleDeliveryStatusMessage (I2NPMessage * msg)
-	{
-		uint32_t msgID = bufbe32toh (msg->GetPayload ());
-		{
-			auto it = m_CreatedSessions.find (msgID);
-			if (it != m_CreatedSessions.end ())			
-			{
-				it->second->MessageConfirmed (msgID);
-				m_CreatedSessions.erase (it);
-				LogPrint (eLogInfo, "Garlic message ", msgID, " acknowledged");
-			}	
-		}
-		DeleteI2NPMessage (msg);	
-	}
-
-	void GarlicDestination::SetLeaseSetUpdated ()
-	{
-		std::unique_lock<std::mutex> l(m_SessionsMutex);	
-		for (auto it: m_Sessions)
-			it.second->SetLeaseSetUpdated ();
-	}
-
-	void GarlicDestination::ProcessGarlicMessage (I2NPMessage * msg)
-	{
-		HandleGarlicMessage (msg);
-	}
-
-	void GarlicDestination::ProcessDeliveryStatusMessage (I2NPMessage * msg)
-	{
-		HandleDeliveryStatusMessage (msg);
-	}
-
-}	
-}

Garlic.h

@@ -1,163 +0,0 @@
-#ifndef GARLIC_H__
-#define GARLIC_H__
-
-#include <inttypes.h>
-#include <map>
-#include <list>
-#include <string>
-#include <thread>
-#include <mutex>
-#include <memory>
-#include <cryptopp/osrng.h>
-#include "aes.h"
-#include "I2NPProtocol.h"
-#include "LeaseSet.h"
-#include "Queue.h"
-#include "Identity.h"
-
-namespace i2p
-{	
-namespace garlic
-{
-	
-	enum GarlicDeliveryType 
-	{ 
-		eGarlicDeliveryTypeLocal = 0, 
-		eGarlicDeliveryTypeDestination = 1,
-		eGarlicDeliveryTypeRouter = 2,	
-		eGarlicDeliveryTypeTunnel = 3
-	};	
-
-#pragma pack(1)
-	struct ElGamalBlock
-	{
-		uint8_t sessionKey[32];
-		uint8_t preIV[32];
-		uint8_t padding[158];
-	};		
-#pragma pack()	
-
-	const int INCOMING_TAGS_EXPIRATION_TIMEOUT = 960; // 16 minutes			
-	const int OUTGOING_TAGS_EXPIRATION_TIMEOUT = 720; // 12 minutes
-	const int LEASET_CONFIRMATION_TIMEOUT = 4000; // in milliseconds
-	
-	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	
-	};
-		
-	class GarlicDestination;
-	class GarlicRoutingSession: public std::enable_shared_from_this<GarlicRoutingSession>
-	{
-			enum LeaseSetUpdateStatus
-			{
-				eLeaseSetUpToDate = 0,
-				eLeaseSetUpdated,
-				eLeaseSetSubmitted 
-			};
-		
-			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);
-			GarlicRoutingSession (const uint8_t * sessionKey, const SessionTag& sessionTag); // one time encryption
-			~GarlicRoutingSession ();
-			I2NPMessage * WrapSingleMessage (I2NPMessage * msg);
-			void MessageConfirmed (uint32_t msgID);
-			bool CleanupExpiredTags (); // returns true if something left 
-
-			void SetLeaseSetUpdated () { m_LeaseSetUpdateStatus = eLeaseSetUpdated; };
-			
-		private:
-
-			size_t CreateAESBlock (uint8_t * buf, const I2NPMessage * msg);
-			size_t CreateGarlicPayload (uint8_t * payload, const I2NPMessage * msg, UnconfirmedTags * newTags);
-			size_t CreateGarlicClove (uint8_t * buf, 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;
-			CryptoPP::AutoSeededRandomPool m_Rnd;
-	};	
-
-	class GarlicDestination: public i2p::data::LocalDestination
-	{
-		public:
-
-			GarlicDestination (): m_LastTagsCleanupTime (0) {};
-			~GarlicDestination ();
-
-			std::shared_ptr<GarlicRoutingSession> GetRoutingSession (std::shared_ptr<const i2p::data::RoutingDestination> destination, int numTags);	
-			void CleanupRoutingSessions ();
-			void RemoveCreatedSession (uint32_t msgID);
-			I2NPMessage * WrapMessage (std::shared_ptr<const i2p::data::RoutingDestination> destination, 
-			    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 (std::shared_ptr<GarlicRoutingSession> session, uint32_t msgID);
-			
-			virtual void ProcessGarlicMessage (I2NPMessage * msg);
-			virtual void ProcessDeliveryStatusMessage (I2NPMessage * msg);			
-			virtual void SetLeaseSetUpdated ();
-			
-			virtual const i2p::data::LeaseSet * GetLeaseSet () = 0; // TODO
-			virtual void HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from) = 0;
-			
-		protected:
-
-			void HandleGarlicMessage (I2NPMessage * msg);
-			void HandleDeliveryStatusMessage (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
-			std::mutex m_SessionsMutex;
-			std::map<i2p::data::IdentHash, std::shared_ptr<GarlicRoutingSession> > m_Sessions;
-			// incoming
-			std::map<SessionTag, std::shared_ptr<i2p::crypto::CBCDecryption>> m_Tags;
-			uint32_t m_LastTagsCleanupTime;
-			// DeliveryStatus
-			std::map<uint32_t, std::shared_ptr<GarlicRoutingSession> > m_CreatedSessions; // msgID -> session
-	};	
-}	
-}
-
-#endif

HTTPProxy.cpp

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

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
-	{
-		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 content;
-
-				std::vector<boost::asio::const_buffer> to_buffers (int status);
-			};
-
-		public:
-
-			HTTPConnection (boost::asio::ip::tcp::socket * socket): 
-				m_Socket (socket), m_Timer (socket->get_io_service ()), 
-				m_Stream (nullptr), m_BufferLen (0) { Receive (); };
-			virtual ~HTTPConnection() { delete m_Socket; }
-
-		private:
-
-			void Terminate ();
-			void Receive ();
-			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 StartAcceptingTunnels (std::stringstream& s);
-			void StopAcceptingTunnels (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:
-
-			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 (int port);
-			virtual ~HTTPServer ();
-
-			void Start ();
-			void Stop ();
-
-		private:
-
-			void Run ();
- 			void Accept ();
-			void HandleAccept(const boost::system::error_code& ecode);
-			
-		private:
-
-			std::thread * m_Thread;
-			boost::asio::io_service m_Service;
-			boost::asio::io_service::work m_Work;
-			boost::asio::ip::tcp::acceptor m_Acceptor;
-			boost::asio::ip::tcp::socket * m_NewSocket;
-
-		protected:
-			virtual void CreateConnection(boost::asio::ip::tcp::socket * m_NewSocket);
-	};
-}
-}
-
-#endif
-
-

I2PControl.cpp

@@ -1,416 +0,0 @@
-// There is bug in boost 1.49 with gcc 4.7 coming with Debian Wheezy
-#define GCC47_BOOST149 ((BOOST_VERSION == 104900) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 7))
-
-#include "I2PControl.h"
-#include <sstream>
-#include <boost/lexical_cast.hpp>
-#include <boost/date_time/local_time/local_time.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#if !GCC47_BOOST149
-#include <boost/property_tree/json_parser.hpp>
-#endif
-#include "Log.h"
-#include "NetDb.h"
-#include "RouterContext.h"
-#include "Daemon.h"
-#include "Tunnel.h"
-#include "Timestamp.h"
-#include "Transports.h"
-#include "version.h"
-
-namespace i2p
-{
-namespace client
-{
-	I2PControlService::I2PControlService (int port):
-		m_Password (I2P_CONTROL_DEFAULT_PASSWORD), m_IsRunning (false), m_Thread (nullptr),
-		m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
-		m_ShutdownTimer (m_Service)
-	{
-		m_MethodHandlers[I2P_CONTROL_METHOD_AUTHENTICATE] = &I2PControlService::AuthenticateHandler; 
-		m_MethodHandlers[I2P_CONTROL_METHOD_ECHO] = &I2PControlService::EchoHandler; 
-		m_MethodHandlers[I2P_CONTROL_METHOD_I2PCONTROL] = &I2PControlService::I2PControlHandler; 
-		m_MethodHandlers[I2P_CONTROL_METHOD_ROUTER_INFO] = &I2PControlService::RouterInfoHandler; 
-		m_MethodHandlers[I2P_CONTROL_METHOD_ROUTER_MANAGER] = &I2PControlService::RouterManagerHandler; 
-		m_MethodHandlers[I2P_CONTROL_METHOD_NETWORK_SETTING] = &I2PControlService::NetworkSettingHandler; 
-
-		// RouterInfo
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_UPTIME] = &I2PControlService::UptimeHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_VERSION] = &I2PControlService::VersionHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_STATUS] = &I2PControlService::StatusHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_NETDB_KNOWNPEERS] = &I2PControlService::NetDbKnownPeersHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_NETDB_ACTIVEPEERS] = &I2PControlService::NetDbActivePeersHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_NET_STATUS] = &I2PControlService::NetStatusHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_TUNNELS_PARTICIPATING] = &I2PControlService::TunnelsParticipatingHandler;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_BW_IB_1S] = &I2PControlService::InboundBandwidth1S ;
-		m_RouterInfoHandlers[I2P_CONTROL_ROUTER_INFO_BW_OB_1S] = &I2PControlService::OutboundBandwidth1S ;
-
-		// RouterManager	
-		m_RouterManagerHandlers[I2P_CONTROL_ROUTER_MANAGER_SHUTDOWN] = &I2PControlService::ShutdownHandler; 
-		m_RouterManagerHandlers[I2P_CONTROL_ROUTER_MANAGER_SHUTDOWN_GRACEFUL] = &I2PControlService::ShutdownGracefulHandler;
-		m_RouterManagerHandlers[I2P_CONTROL_ROUTER_MANAGER_RESEED] = &I2PControlService::ReseedHandler;
-	}
-
-	I2PControlService::~I2PControlService ()
-	{
-		Stop ();
-	}
-
-	void I2PControlService::Start ()
-	{
-		if (!m_IsRunning)
-		{
-			Accept ();
-			m_IsRunning = true;
-			m_Thread = new std::thread (std::bind (&I2PControlService::Run, this));
-		}
-	}
-
-	void I2PControlService::Stop ()
-	{
-		if (m_IsRunning)
-		{
-			m_IsRunning = false;
-			m_Acceptor.cancel ();	
-			m_Service.stop ();
-			if (m_Thread)
-			{	
-				m_Thread->join (); 
-				delete m_Thread;
-				m_Thread = nullptr;
-			}	
-		}
-	}
-
-	void I2PControlService::Run () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_Service.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "I2PControl: ", ex.what ());
-			}	
-		}	
-	}
-
-	void I2PControlService::Accept ()
-	{
-		auto newSocket = std::make_shared<boost::asio::ip::tcp::socket> (m_Service);
-		m_Acceptor.async_accept (*newSocket, std::bind (&I2PControlService::HandleAccept, this,
-			std::placeholders::_1, newSocket));
-	}
-
-	void I2PControlService::HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket)
-	{
-		if (ecode != boost::asio::error::operation_aborted)
-			Accept ();
-
-		if (!ecode)
-		{
-			LogPrint (eLogInfo, "New I2PControl request from ", socket->remote_endpoint ());
-			std::this_thread::sleep_for (std::chrono::milliseconds(5));
-			ReadRequest (socket);	
-		}
-		else
-			LogPrint (eLogError, "I2PControl accept error: ",  ecode.message ());
-	}
-
-	void I2PControlService::ReadRequest (std::shared_ptr<boost::asio::ip::tcp::socket> socket)
-	{
-		auto request = std::make_shared<I2PControlBuffer>();
-		socket->async_read_some (
-#if BOOST_VERSION >= 104900
-			boost::asio::buffer (*request),  
-#else
-			boost::asio::buffer (request->data (), request->size ()), 
-#endif              
-			std::bind(&I2PControlService::HandleRequestReceived, this, 
-			std::placeholders::_1, std::placeholders::_2, socket, request));
-	}
-
-	void I2PControlService::HandleRequestReceived (const boost::system::error_code& ecode,
- 		size_t bytes_transferred, std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
-		std::shared_ptr<I2PControlBuffer> buf)
-	{
-		if (ecode)
-		{
-			LogPrint (eLogError, "I2PControl read error: ", ecode.message ());
-		}
-		else
-		{
-			try
-			{
-				bool isHtml = !memcmp (buf->data (), "POST", 4);
-				std::stringstream ss;
-				ss.write (buf->data (), bytes_transferred);
-				if (isHtml)
-				{
-					std::string header;
-					while (!ss.eof () && header != "\r")
-						std::getline(ss, header);
-					if (ss.eof ())
-					{
-						LogPrint (eLogError, "Malformed I2PControl request. HTTP header expected");
-						return; // TODO:
-					}
-				}
-#if GCC47_BOOST149
-				LogPrint (eLogError, "json_read is not supported due bug in boost 1.49 with gcc 4.7");
-#else
-				boost::property_tree::ptree pt;
-				boost::property_tree::read_json (ss, pt);
-
-				std::string method = pt.get<std::string>(I2P_CONTROL_PROPERTY_METHOD);
-				auto it = m_MethodHandlers.find (method);
-				if (it != m_MethodHandlers.end ())
-				{
-					std::ostringstream response;
-					response << "{\"id\":" << pt.get<std::string>(I2P_CONTROL_PROPERTY_ID) << ",\"result\":{";					
-
-					(this->*(it->second))(pt.get_child (I2P_CONTROL_PROPERTY_PARAMS), response);
-					response << "},\"jsonrpc\":\"2.0\"}";
-					SendResponse (socket, buf, response, isHtml);
-				}	
-				else
-					LogPrint (eLogWarning, "Unknown I2PControl method ", method);
-#endif
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "I2PControl handle request: ", ex.what ());
-			}
-			catch (...)
-			{
-				LogPrint (eLogError, "I2PControl handle request unknown exception");
-			}
-		}
-	}
-
-	void I2PControlService::InsertParam (std::ostringstream& ss, const std::string& name, int value) const
-	{
-		ss << "\"" << name << "\":" << value;
-	} 
-
-	void I2PControlService::InsertParam (std::ostringstream& ss, const std::string& name, const std::string& value) const
-	{
-		ss << "\"" << name << "\":";	
-		if (value.length () > 0)
-			ss << "\"" << value << "\"";
-		else
-			ss << "null";
-	} 
-		
-	void I2PControlService::InsertParam (std::ostringstream& ss, const std::string& name, double value) const
-	{
-		ss << "\"" << name << "\":" << std::fixed << std::setprecision(2) << value;
-	}	
-
-	void I2PControlService::SendResponse (std::shared_ptr<boost::asio::ip::tcp::socket> socket,
-		std::shared_ptr<I2PControlBuffer> buf, std::ostringstream& response, bool isHtml)
-	{
-		size_t len = response.str ().length (), offset = 0;
-		if (isHtml)
-		{
-			std::ostringstream header;
-			header << "HTTP/1.1 200 OK\r\n";
-			header << "Connection: close\r\n";
-			header << "Content-Length: " << boost::lexical_cast<std::string>(len) << "\r\n";
-			header << "Content-Type: application/json\r\n";
-			header << "Date: ";
-			auto facet = new boost::local_time::local_time_facet ("%a, %d %b %Y %H:%M:%S GMT");
-			header.imbue(std::locale (header.getloc(), facet));
-			header << boost::posix_time::second_clock::local_time() << "\r\n"; 
-			header << "\r\n";
-			offset = header.str ().size ();
-			memcpy (buf->data (), header.str ().c_str (), offset);
-		}	
-		memcpy (buf->data () + offset, response.str ().c_str (), len);
-		boost::asio::async_write (*socket, boost::asio::buffer (buf->data (), offset + len), 
-			boost::asio::transfer_all (),
-			std::bind(&I2PControlService::HandleResponseSent, this, 
-				std::placeholders::_1, std::placeholders::_2, socket, buf));
-	}
-
-	void I2PControlService::HandleResponseSent (const boost::system::error_code& ecode, std::size_t bytes_transferred,
-		std::shared_ptr<boost::asio::ip::tcp::socket> socket, std::shared_ptr<I2PControlBuffer> buf)
-	{
-		if (ecode)
-			LogPrint (eLogError, "I2PControl write error: ", ecode.message ());
-		socket->close ();
-	}
-
-// handlers
-
-	void I2PControlService::AuthenticateHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		int api = params.get<int> (I2P_CONTROL_PARAM_API);
-		auto password = params.get<std::string> (I2P_CONTROL_PARAM_PASSWORD);
-		LogPrint (eLogDebug, "I2PControl Authenticate API=", api, " Password=", password);
-		if (password != m_Password)
-			LogPrint (eLogError, "I2PControl Authenticate Invalid password ", password, " expected ", m_Password);
-		InsertParam (results, I2P_CONTROL_PARAM_API, api);
-		results << ",";
-		std::string token = boost::lexical_cast<std::string>(i2p::util::GetSecondsSinceEpoch ());
-		m_Tokens.insert (token);	
-		InsertParam (results, I2P_CONTROL_PARAM_TOKEN, token);
-	}	
-
-	void I2PControlService::EchoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		auto echo = params.get<std::string> (I2P_CONTROL_PARAM_ECHO);
-		LogPrint (eLogDebug, "I2PControl Echo Echo=", echo);
-		InsertParam (results, I2P_CONTROL_PARAM_RESULT, echo);	
-	}
-
-
-// I2PControl
-
-	void I2PControlService::I2PControlHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		LogPrint (eLogDebug, "I2PControl I2PControl");
-		for (auto& it: params)
-		{
-			LogPrint (eLogDebug, it.first);
-			auto it1 = m_I2PControlHandlers.find (it.first);
-			if (it1 != m_I2PControlHandlers.end ())
-				(this->*(it1->second))(it.second.data ());	
-			else
-				LogPrint (eLogError, "I2PControl NetworkSetting unknown request ", it.first);			
-		}	
-	}
-
-// RouterInfo
-
-	void I2PControlService::RouterInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		LogPrint (eLogDebug, "I2PControl RouterInfo");
-		for (auto it = params.begin (); it != params.end (); it++)
-		{
-			if (it != params.begin ()) results << ",";	
-			LogPrint (eLogDebug, it->first);
-			auto it1 = m_RouterInfoHandlers.find (it->first);
-			if (it1 != m_RouterInfoHandlers.end ())
-				(this->*(it1->second))(results);	
-			else
-				LogPrint (eLogError, "I2PControl RouterInfo unknown request ", it->first);
-		}
-	}
-
-	void I2PControlService::UptimeHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_UPTIME, (int)i2p::context.GetUptime ()*1000);	
-	}
-
-	void I2PControlService::VersionHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_VERSION, VERSION);	
-	}	
-
-	void I2PControlService::StatusHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_STATUS, "???"); // TODO:
-	}
-		
-	void I2PControlService::NetDbKnownPeersHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_NETDB_KNOWNPEERS, i2p::data::netdb.GetNumRouters ());	
-	}
-
-	void I2PControlService::NetDbActivePeersHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_NETDB_ACTIVEPEERS, (int)i2p::transport::transports.GetPeers ().size ());	
-	}
-
-	void I2PControlService::NetStatusHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_NET_STATUS, (int)i2p::context.GetStatus ());
-	}
-
-	void I2PControlService::TunnelsParticipatingHandler (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_TUNNELS_PARTICIPATING, (int)i2p::tunnel::tunnels.GetTransitTunnels ().size ());
-	}
-
-	void I2PControlService::InboundBandwidth1S (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_BW_IB_1S, (double)i2p::transport::transports.GetInBandwidth ());
-	}
-
-	void I2PControlService::OutboundBandwidth1S (std::ostringstream& results)
-	{
-		InsertParam (results, I2P_CONTROL_ROUTER_INFO_BW_OB_1S, (double)i2p::transport::transports.GetOutBandwidth ());
-	}
-
-// RouterManager
-	
-	void I2PControlService::RouterManagerHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		LogPrint (eLogDebug, "I2PControl RouterManager");
-		for (auto it = params.begin (); it != params.end (); it++)
-		{
-			if (it != params.begin ()) results << ",";	
-			LogPrint (eLogDebug, it->first);
-			auto it1 = m_RouterManagerHandlers.find (it->first);
-			if (it1 != m_RouterManagerHandlers.end ())
-				(this->*(it1->second))(results);	
-			else
-				LogPrint (eLogError, "I2PControl RouterManager unknown request ", it->first);			
-		}
-	}	
-
-
-	void I2PControlService::ShutdownHandler (std::ostringstream& results)	
-	{
-		LogPrint (eLogInfo, "Shutdown requested");
-		InsertParam (results, I2P_CONTROL_ROUTER_MANAGER_SHUTDOWN, "");
-		m_ShutdownTimer.expires_from_now (boost::posix_time::seconds(1)); // 1 second to make sure response has been sent
-		m_ShutdownTimer.async_wait (
-			[](const boost::system::error_code& ecode)
-		    {
-				Daemon.running = 0; 
-			});
-	}
-
-	void I2PControlService::ShutdownGracefulHandler (std::ostringstream& results)
-	{
-		i2p::context.SetAcceptsTunnels (false);
-		int timeout = i2p::tunnel::tunnels.GetTransitTunnelsExpirationTimeout ();
-		LogPrint (eLogInfo, "Graceful shutdown requested. Will shutdown after ", timeout, " seconds");
-		InsertParam (results, I2P_CONTROL_ROUTER_MANAGER_SHUTDOWN_GRACEFUL, "");
-		m_ShutdownTimer.expires_from_now (boost::posix_time::seconds(timeout + 1)); // + 1 second
-		m_ShutdownTimer.async_wait (
-			[](const boost::system::error_code& ecode)
-		    {
-				Daemon.running = 0; 
-			});
-	}
-
-	void I2PControlService::ReseedHandler (std::ostringstream& results)
-	{
-		LogPrint (eLogInfo, "Reseed requested");
-		InsertParam (results, I2P_CONTROL_ROUTER_MANAGER_SHUTDOWN, "");	
-		i2p::data::netdb.Reseed ();
-	}
-
-// network setting
-	void I2PControlService::NetworkSettingHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
-	{
-		LogPrint (eLogDebug, "I2PControl NetworkSetting");
-		for (auto it = params.begin (); it != params.end (); it++)
-		{
-			if (it != params.begin ()) results << ",";	
-			LogPrint (eLogDebug, it->first);
-			auto it1 = m_NetworkSettingHandlers.find (it->first);
-			if (it1 != m_NetworkSettingHandlers.end ())
-				(this->*(it1->second))(it->second.data (), results);	
-			else
-				LogPrint (eLogError, "I2PControl NetworkSetting unknown request ", it->first);			
-		}
-	}
-
-}
-}

I2PService.cpp

@@ -1,80 +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, "Remote destination ", dest, " not found");
-			streamRequestComplete (nullptr);
-		}
-	}
-
-	void TCPIPAcceptor::Start ()
-	{
-		m_Acceptor.listen ();
-		Accept ();
-	}
-
-	void TCPIPAcceptor::Stop ()
-	{
-		m_Acceptor.close();
-		m_Timer.cancel ();
-		ClearHandlers();
-	}
-
-	void TCPIPAcceptor::Accept ()
-	{
-		auto newSocket = new 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, boost::asio::ip::tcp::socket * socket)
-	{
-		if (!ecode)
-		{
-			LogPrint(eLogDebug,"--- ",GetName()," accepted");
-			auto handler = CreateHandler(socket);
-			if (handler) {
-				AddHandler(handler);
-				handler->Handle();
-			} else {
-				socket->close();
-				delete socket;
-			}
-			Accept();
-		}
-		else
-		{
-			if (ecode != boost::asio::error::operation_aborted)
-				LogPrint (eLogError,"--- ",GetName()," Closing socket on accept because: ", ecode.message ());
-			delete socket;
-		}
-	}
-
-}
-}

I2PTunnel.cpp

@@ -1,305 +0,0 @@
-#include <cassert>
-#include "base64.h"
-#include "Log.h"
-#include "Destination.h"
-#include "ClientContext.h"
-#include "I2PTunnel.h"
-
-namespace i2p
-{
-namespace client
-{
-	I2PTunnelConnection::I2PTunnelConnection (I2PService * owner, 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,
-	    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,
-	    boost::asio::ip::tcp::socket * socket, const boost::asio::ip::tcp::endpoint& target, bool quiet):
-		I2PServiceHandler(owner), m_Socket (socket), m_Stream (stream),
-		m_RemoteEndpoint (target), m_IsQuiet (quiet)
-	{
-	}
-
-	I2PTunnelConnection::~I2PTunnelConnection ()
-	{
-	}	
-
-	void I2PTunnelConnection::I2PConnect (const uint8_t * msg, size_t len)
-	{
-		if (m_Stream)
-		{
-			if (msg)
-				m_Stream->Send (msg, len); // connect and send
-			else	
-				m_Stream->Send (m_Buffer, 0); // connect
-		}
-		StreamReceive ();
-		Receive ();
-	}
-		
-	void I2PTunnelConnection::Connect ()
-	{
-		if (m_Socket)
-			m_Socket->async_connect (m_RemoteEndpoint, std::bind (&I2PTunnelConnection::HandleConnect,
-				shared_from_this (), std::placeholders::_1));
-	}	
-		
-	void I2PTunnelConnection::Terminate ()
-	{
-		if (Kill()) return;
-		if (m_Stream)
-		{
-			m_Stream->Close ();
-			m_Stream.reset ();
-		}	
-		m_Socket->close ();
-		Done(shared_from_this ());
-	}			
-
-	void I2PTunnelConnection::Receive ()
-	{
-		m_Socket->async_read_some (boost::asio::buffer(m_Buffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),                
-			std::bind(&I2PTunnelConnection::HandleReceived, shared_from_this (), 
-			std::placeholders::_1, std::placeholders::_2));
-	}	
-	
-	void I2PTunnelConnection::HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (ecode)
-		{
-			LogPrint ("I2PTunnel read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			if (m_Stream)
-				m_Stream->Send (m_Buffer, bytes_transferred);
-			Receive ();
-		}
-	}	
-
-	void I2PTunnelConnection::HandleWrite (const boost::system::error_code& ecode)
-	{
-		if (ecode)
-		{
-			LogPrint ("I2PTunnel write error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-			StreamReceive ();
-	}
-
-	void I2PTunnelConnection::StreamReceive ()
-	{
-		if (m_Stream)
-			m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, I2P_TUNNEL_CONNECTION_BUFFER_SIZE),
-				std::bind (&I2PTunnelConnection::HandleStreamReceive, shared_from_this (),
-					std::placeholders::_1, std::placeholders::_2),
-				I2P_TUNNEL_CONNECTION_MAX_IDLE);
-	}	
-
-	void I2PTunnelConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
-	{
-		if (ecode)
-		{
-			LogPrint ("I2PTunnel stream read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{
-			boost::asio::async_write (*m_Socket, boost::asio::buffer (m_StreamBuffer, bytes_transferred),
-        		std::bind (&I2PTunnelConnection::HandleWrite, shared_from_this (), std::placeholders::_1));
-		}
-	}
-
-	void I2PTunnelConnection::HandleConnect (const boost::system::error_code& ecode)
-	{
-		if (ecode)
-		{
-			LogPrint ("I2PTunnel connect error: ", ecode.message ());
-			Terminate ();
-		}
-		else
-		{
-			LogPrint ("I2PTunnel connected");
-			if (m_IsQuiet)
-				StreamReceive ();
-			else
-			{
-				// send destination first like received from I2P
-				std::string dest = m_Stream->GetRemoteIdentity ().ToBase64 ();
-				dest += "\n";
-				memcpy (m_StreamBuffer, dest.c_str (), dest.size ());
-				HandleStreamReceive (boost::system::error_code (), dest.size ());
-			}	
-			Receive ();	
-		}
-	}
-
-	/* 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, 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;
-			boost::asio::ip::tcp::socket * m_Socket;
-	};
-
-	void I2PClientTunnelHandler::Handle()
-	{
-		GetOwner()->GetLocalDestination ()->CreateStream ( 
-			std::bind (&I2PClientTunnelHandler::HandleStreamRequestComplete, shared_from_this(), std::placeholders::_1), 
-			m_DestinationIdentHash, m_DestinationPort);
-	}
-
-	void I2PClientTunnelHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
-	{
-		if (stream)
-		{
-			if (Kill()) return;
-			LogPrint (eLogInfo,"New I2PTunnel connection");
-			auto connection = std::make_shared<I2PTunnelConnection>(GetOwner(), m_Socket, stream);
-			GetOwner()->AddHandler (connection);
-			connection->I2PConnect ();
-			Done(shared_from_this());
-		}
-		else
-		{
-			LogPrint (eLogError,"I2P Client Tunnel Issue when creating the stream, check the previous warnings for more info.");
-			Terminate();
-		}
-	}
-
-	void I2PClientTunnelHandler::Terminate()
-	{
-		if (Kill()) return;
-		if (m_Socket)
-		{
-			m_Socket->close();
-			delete m_Socket;
-			m_Socket = nullptr;
-		}
-		Done(shared_from_this());
-	}
-
-	I2PClientTunnel::I2PClientTunnel (const std::string& destination, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort): 
-		TCPIPAcceptor (port,localDestination), m_Destination (destination), m_DestinationIdentHash (nullptr), m_DestinationPort (destinationPort)
-	{}	
-
-	void I2PClientTunnel::Start ()
-	{
-		TCPIPAcceptor::Start ();
-		GetIdentHash();
-	}
-
-	void I2PClientTunnel::Stop ()
-	{
-		TCPIPAcceptor::Stop();
-		auto *originalIdentHash = m_DestinationIdentHash;
-		m_DestinationIdentHash = nullptr;
-		delete originalIdentHash;
-	}
-
-	/* HACK: maybe we should create a caching IdentHash provider in AddressBook */
-	const i2p::data::IdentHash * I2PClientTunnel::GetIdentHash ()
-	{
-		if (!m_DestinationIdentHash)
-		{
-			i2p::data::IdentHash identHash;
-			if (i2p::client::context.GetAddressBook ().GetIdentHash (m_Destination, identHash))
-				m_DestinationIdentHash = new i2p::data::IdentHash (identHash);
-			else
-				LogPrint (eLogWarning,"Remote destination ", m_Destination, " not found");
-		}
-		return m_DestinationIdentHash;
-	}
-
-	std::shared_ptr<I2PServiceHandler> I2PClientTunnel::CreateHandler(boost::asio::ip::tcp::socket * socket)
-	{
-		const i2p::data::IdentHash *identHash = GetIdentHash();
-		if (identHash)
-			return  std::make_shared<I2PClientTunnelHandler>(this, *identHash, m_DestinationPort, socket);
-		else
-			return nullptr;
-	}
-
-	I2PServerTunnel::I2PServerTunnel (const std::string& address, int port, 
-	    std::shared_ptr<ClientDestination> localDestination, int inport): 
-		I2PService (localDestination), m_Endpoint (boost::asio::ip::address::from_string (address), port),  m_IsAccessList (false)
-	{
-		m_PortDestination = localDestination->CreateStreamingDestination (inport > 0 ? inport : port);
-	}
-	
-	void I2PServerTunnel::Start ()
-	{
-		Accept ();
-	}
-
-	void I2PServerTunnel::Stop ()
-	{
-		ClearHandlers ();
-	}	
-
-	void I2PServerTunnel::SetAccessList (const std::set<i2p::data::IdentHash>& accessList)
-	{
-		m_AccessList = accessList;
-		m_IsAccessList = true;		
-	}
-
-	void I2PServerTunnel::Accept ()
-	{
-		if (m_PortDestination)
-			m_PortDestination->SetAcceptor (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
-
-		auto localDestination = GetLocalDestination ();	
-		if (localDestination)
-		{
-			if (!localDestination->IsAcceptingStreams ()) // set it as default if not set yet
-				localDestination->AcceptStreams (std::bind (&I2PServerTunnel::HandleAccept, this, std::placeholders::_1));
-		}
-		else
-			LogPrint ("Local destination not set for server tunnel");
-	}
-
-	void I2PServerTunnel::HandleAccept (std::shared_ptr<i2p::stream::Stream> stream)
-	{
-		if (stream)
-		{	
-			if (m_IsAccessList)
-			{
-				if (!m_AccessList.count (stream->GetRemoteIdentity ().GetIdentHash ()))
-				{
-					LogPrint (eLogWarning, "Address ", stream->GetRemoteIdentity ().GetIdentHash ().ToBase32 (), " is not in white list. Incoming connection dropped");
-					stream->Close ();
-					return;
-				}
-			}
-			auto conn = std::make_shared<I2PTunnelConnection> (this, stream, new boost::asio::ip::tcp::socket (GetService ()), m_Endpoint);
-			AddHandler (conn);
-			conn->Connect ();
-		}	
-	}
-}		
-}	

I2PTunnel.h

@@ -1,110 +0,0 @@
-#ifndef I2PTUNNEL_H__
-#define I2PTUNNEL_H__
-
-#include <inttypes.h>
-#include <string>
-#include <set>
-#include <memory>
-#include <boost/asio.hpp>
-#include "Identity.h"
-#include "Destination.h"
-#include "Streaming.h"
-#include "I2PService.h"
-
-namespace i2p
-{
-namespace client
-{
-	const size_t I2P_TUNNEL_CONNECTION_BUFFER_SIZE = 8192;
-	const int I2P_TUNNEL_CONNECTION_MAX_IDLE = 3600; // in seconds	
-	const int I2P_TUNNEL_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
-
-
-	class I2PTunnelConnection: public I2PServiceHandler, public std::enable_shared_from_this<I2PTunnelConnection>
-	{
-		public:
-
-			I2PTunnelConnection (I2PService * owner, boost::asio::ip::tcp::socket * socket,
-				std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port = 0); // to I2P
-			I2PTunnelConnection (I2PService * owner, 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,  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 ();
-			
-		private:
-
-			void Terminate ();	
-
-			void Receive ();
-			void HandleReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);	
-			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::unique_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 I2PClientTunnel: public TCPIPAcceptor
-	{
-		protected:
-
-			// Implements TCPIPAcceptor
-			std::shared_ptr<I2PServiceHandler> CreateHandler(boost::asio::ip::tcp::socket * socket);
-			const char* GetName() { return "I2P Client Tunnel"; }
-
-		public:
-
-			I2PClientTunnel (const std::string& destination, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0);
-			~I2PClientTunnel () {}
-	
-			void Start ();
-			void Stop ();
-
-		private:
-
-			const i2p::data::IdentHash * GetIdentHash ();
-
-			std::string m_Destination;
-			const i2p::data::IdentHash * m_DestinationIdentHash;
-			int m_DestinationPort;	
-	};	
-
-	class I2PServerTunnel: public I2PService
-	{
-		public:
-
-			I2PServerTunnel (const std::string& address, int port, 
-				std::shared_ptr<ClientDestination> localDestination, int inport = 0);	
-
-			void Start ();
-			void Stop ();
-
-			void SetAccessList (const std::set<i2p::data::IdentHash>& accessList); 
-
-		private:
-
-			void Accept ();
-			void HandleAccept (std::shared_ptr<i2p::stream::Stream> stream);
-
-		private:
-
-			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;			
-	};
-}
-}	
-
-#endif

LeaseSet.cpp

@@ -1,141 +0,0 @@
-#include <string.h>
-#include "I2PEndian.h"
-#include <cryptopp/dsa.h>
-#include <cryptopp/osrng.h>
-#include "CryptoConst.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, int len)
-	{
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer ();
-	}
-
-	LeaseSet::LeaseSet (const i2p::tunnel::TunnelPool& pool)
-	{	
-		// header
-		const i2p::data::LocalDestination * localDestination = pool.GetLocalDestination ();
-		if (!localDestination)
-		{
-			m_BufferLen = 0;
-			LogPrint (eLogError, "Destination for local LeaseSet doesn't exist");
-			return;
-		}	
-		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;
-		auto tunnels = pool.GetInboundTunnels (5); // 5 tunnels maximum
-		m_Buffer[m_BufferLen] = tunnels.size (); // num leases
-		m_BufferLen++;
-		// leases
-		CryptoPP::AutoSeededRandomPool rnd;	
-		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
-			ts += rnd.GenerateWord32 (0, 5); // + random milliseconds
-			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 ("Local LeaseSet of ", tunnels.size (), " leases created");
-
-		ReadFromBuffer ();
-	}
-
-	void LeaseSet::Update (const uint8_t * buf, int len)
-	{	
-		m_Leases.clear ();
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer ();
-	}
-	
-	void LeaseSet::ReadFromBuffer ()	
-	{	
-		size_t size = m_Identity.FromBuffer (m_Buffer, m_BufferLen);
-		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 ("LeaseSet num=", (int)num);
-
-		// process leases
-		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
-			m_Leases.push_back (lease);
-
-			// check if lease's gateway is in our netDb
-			if (!netdb.FindRouter (lease.tunnelGateway))
-			{
-				// if not found request it
-				LogPrint ("Lease's tunnel gateway not found. Requested");
-				netdb.RequestDestination (lease.tunnelGateway);
-			}	
-		}	
-		
-		// verify
-		if (!m_Identity.Verify (m_Buffer, leases - m_Buffer, leases))
-			LogPrint ("LeaseSet verification failed");
-	}				
-	
-	const std::vector<Lease> LeaseSet::GetNonExpiredLeases (bool withThreshold) const
-	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		std::vector<Lease> leases;
-		for (auto& it: m_Leases)
-		{
-			auto endDate = it.endDate;
-			if (!withThreshold)
-				endDate -= i2p::tunnel::TUNNEL_EXPIRATION_THRESHOLD*1000;
-			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::HasNonExpiredLeases () const
-	{
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		for (auto& it: m_Leases)
-			if (ts < it.endDate) return true;
-		return false;
-	}	
-}		
-}	

LeaseSet.h

@@ -1,73 +0,0 @@
-#ifndef LEASE_SET_H__
-#define LEASE_SET_H__
-
-#include <inttypes.h>
-#include <string.h>
-#include <vector>
-#include "Identity.h"
-
-namespace i2p
-{
-
-namespace tunnel
-{
-	class TunnelPool;
-}
-
-namespace data
-{	
-	struct Lease
-	{
-		IdentHash tunnelGateway;
-		uint32_t tunnelID;
-		uint64_t endDate;
-
-		bool operator< (const Lease& other) const 
-		{
-			if (endDate != other.endDate)
-				return endDate > other.endDate;
-			else
-				return tunnelID < other.tunnelID; 
-		}	
-	};	
-
-	const int MAX_LS_BUFFER_SIZE = 3072;	
-	class LeaseSet: public RoutingDestination
-	{
-		public:
-
-			LeaseSet (const uint8_t * buf, int len);
-			LeaseSet (const LeaseSet& ) = default;
-			LeaseSet (const i2p::tunnel::TunnelPool& pool);
-			LeaseSet& operator=(const LeaseSet& ) = default;
-			void Update (const uint8_t * buf, int len);
-			const IdentityEx& GetIdentity () const { return m_Identity; };			
-
-			const uint8_t * GetBuffer () const { return m_Buffer; };
-			size_t GetBufferLen () const { return m_BufferLen; };	
-
-			// implements RoutingDestination
-			const IdentHash& GetIdentHash () const { return m_Identity.GetIdentHash (); };
-			const std::vector<Lease>& GetLeases () const { return m_Leases; };
-			const std::vector<Lease> GetNonExpiredLeases (bool withThreshold = true) const;
-			bool HasExpiredLeases () const;
-			bool HasNonExpiredLeases () const;
-			const uint8_t * GetEncryptionPublicKey () const { return m_EncryptionKey; };
-			bool IsDestination () const { return true; };
-
-		private:
-
-			void ReadFromBuffer ();
-			
-		private:
-
-			std::vector<Lease> m_Leases;
-			IdentityEx m_Identity;
-			uint8_t m_EncryptionKey[256];
-			uint8_t m_Buffer[MAX_LS_BUFFER_SIZE];
-			size_t m_BufferLen;
-	};	
-}		
-}	
-
-#endif

Log.cpp

@@ -1,43 +0,0 @@
-#include "Log.h"
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-Log * g_Log = nullptr;
-
-static const char * g_LogLevelStr[eNumLogLevels] =
-{
-	"error", // eLogError
-	"warn",  // eLogWarning
-	"info",  // eLogInfo
-	"debug"	 // eLogDebug 
-};
-
-void LogMsg::Process()
-{
-	output << boost::posix_time::second_clock::local_time().time_of_day () <<  
-		"/" << g_LogLevelStr[level] << " - ";
-	output << s.str();
-}
-
-void Log::Flush ()
-{
-	if (m_LogStream)
-		m_LogStream->flush();
-}
-
-void Log::SetLogFile (const std::string& fullFilePath)
-{
-	auto logFile = new std::ofstream (fullFilePath, std::ofstream::out | std::ofstream::binary | std::ofstream::trunc);
-	if (logFile->is_open ())
-	{
-		SetLogStream (logFile);
-		LogPrint("Logging to file ",  fullFilePath, " enabled.");
-	}	
-	else
-		delete logFile;
-}
-
-void Log::SetLogStream (std::ostream * logStream)
-{
-	if (m_LogStream) delete m_LogStream;	
-	m_LogStream = logStream;
-}

Log.h

@@ -1,117 +0,0 @@
-#ifndef LOG_H__
-#define LOG_H__
-
-#include <string>
-#include <iostream>
-#include <sstream>
-#include <fstream>
-#include <functional>
-#include "Queue.h"
-
-enum LogLevel
-{
-	eLogError = 0,
-	eLogWarning,
-	eLogInfo,
-	eLogDebug,	
-	eNumLogLevels
-};
-
-struct LogMsg
-{
-	std::stringstream s;
-	std::ostream& output;	
-	LogLevel level;
-
-	LogMsg (std::ostream& o = std::cout, LogLevel l = eLogInfo): output (o), level (l) {};
-	
-	void Process();
-};
-
-class Log: public i2p::util::MsgQueue<LogMsg>
-{
-	public:
-
-		Log (): m_LogStream (nullptr) { SetOnEmpty (std::bind (&Log::Flush, this)); };
-		~Log () { delete m_LogStream; };
-
-		void SetLogFile (const std::string& fullFilePath);
-		void SetLogStream (std::ostream * logStream);
-		std::ostream * GetLogStream () const { return m_LogStream; };	
-
-	private:
-
-		void Flush ();
-
-	private:
-		
-		std::ostream * m_LogStream;
-};
-
-extern Log * g_Log;
-
-inline void StartLog (const std::string& fullFilePath)
-{
-	if (!g_Log)
-	{	
-		g_Log = new Log ();
-		if (fullFilePath.length () > 0)
-			g_Log->SetLogFile (fullFilePath);
-	}	
-}
-
-inline void StartLog (std::ostream * s)
-{
-	if (!g_Log)
-	{	
-		g_Log = new Log ();
-		if (s)
-			g_Log->SetLogStream (s);
-	}	
-}
-
-inline void StopLog ()
-{
-	if (g_Log)
-	{
-		delete g_Log;
-		g_Log = nullptr;
-	}		
-}
-
-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) 
-{
-	LogMsg * msg = (g_Log && g_Log->GetLogStream ()) ? new LogMsg (*g_Log->GetLogStream (), level) : 
-		new LogMsg (std::cout, level);
-	LogPrint (msg->s, args...);
-	msg->s << std::endl;
-	if (g_Log)	
-		g_Log->Put (msg);
-	else
-	{
-		msg->Process ();
-		delete msg;
-	}
-}
-
-template<typename... TArgs>
-void LogPrint (TArgs... args) 
-{
-	LogPrint (eLogInfo, args...);
-}	
-
-#endif

Makefile

@@ -1,33 +1,63 @@
 UNAME := $(shell uname -s)
 SHLIB := libi2pd.so
-I2PD  := i2p
-GREP := fgrep
+ARLIB := libi2pd.a
+SHLIB_CLIENT := libi2pdclient.so
+ARLIB_CLIENT := libi2pdclient.a
+I2PD  := i2pd
+GREP := grep
 DEPS := obj/make.dep
 
+LIB_SRC_DIR := libi2pd
+LIB_CLIENT_SRC_DIR := libi2pd_client
+DAEMON_SRC_DIR := daemon
+
 include filelist.mk
 
-USE_AESNI  := yes
-USE_STATIC := no
+USE_AESNI	:= yes
+USE_AVX		:= yes
+USE_STATIC	:= no
+USE_MESHNET	:= no
+USE_UPNP	:= no
 
-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
-	DAEMON_SRC += DaemonWin32.cpp
+ifeq ($(WEBSOCKETS),1)
+	NEEDED_CXXFLAGS += -DWITH_EVENTS
 endif
 
-all: mk_build_dir $(SHLIB) $(I2PD)
+ifeq ($(UNAME),Darwin)
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	ifeq ($(HOMEBREW),1)
+		include Makefile.homebrew
+	else
+		include Makefile.osx
+	endif
+else ifeq ($(shell echo $(UNAME) | $(GREP) -Ec '(Free|Open)BSD'),1)
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	include Makefile.bsd
+else ifeq ($(UNAME),Linux)
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	include Makefile.linux
+else
+	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32Service.cpp Win32/Win32App.cpp
+	include Makefile.mingw
+endif
 
-mk_build_dir:
-	mkdir -p obj
+ifeq ($(USE_MESHNET),yes)
+	NEEDED_CXXFLAGS += -DMESHNET
+endif
 
-api: $(SHLIB)
+NEEDED_CXXFLAGS += -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR)
+
+all: mk_obj_dir $(ARLIB) $(ARLIB_CLIENT) $(I2PD)
+
+mk_obj_dir:
+	@mkdir -p obj
+	@mkdir -p obj/Win32
+	@mkdir -p obj/$(LIB_SRC_DIR)
+	@mkdir -p obj/$(LIB_CLIENT_SRC_DIR)
+	@mkdir -p obj/$(DAEMON_SRC_DIR)
+
+api: mk_obj_dir $(SHLIB) $(ARLIB)
+api_client: mk_obj_dir $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
 
 ## NOTE: The NEEDED_CXXFLAGS are here so that CXXFLAGS can be specified at build time
 ## **without** overwriting the CXXFLAGS which we need in order to build.
@@ -36,38 +66,60 @@ api: $(SHLIB)
 ## -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
+deps: mk_obj_dir
 	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) -MM *.cpp > $(DEPS)
 	@sed -i -e '/\.o:/ s/^/obj\//' $(DEPS)
 
-obj/%.o : %.cpp
-	@mkdir -p obj
+obj/%.o: %.cpp
 	$(CXX) $(CXXFLAGS) $(NEEDED_CXXFLAGS) $(INCFLAGS) $(CPU_FLAGS) -c -o $@ $<
 
 # '-' is 'ignore if missing' on first run
 -include $(DEPS)
 
-$(I2PD):  $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
-	$(CXX) -o $@ $^ $(LDLIBS) $(LDFLAGS)
+DAEMON_OBJS += $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
+$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT)
+	$(CXX) -o $@ $^ $(LDFLAGS) $(LDLIBS)
 
 $(SHLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
 ifneq ($(USE_STATIC),yes)
 	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
 endif
 
+$(SHLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
+	$(CXX) $(LDFLAGS) $(LDLIBS) -shared -o $@ $^
+
+$(ARLIB): $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
+	ar -r $@ $^
+
+$(ARLIB_CLIENT): $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
+	ar -r $@ $^
+
 clean:
 	rm -rf obj
-	$(RM) $(I2PD) $(SHLIB)
+	rm -rf docs/generated
+	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT)
 
-LATEST_TAG=$(shell git describe --tags --abbrev=0 master)
+strip: $(I2PD) $(SHLIB_CLIENT) $(SHLIB)
+	strip $^
+
+LATEST_TAG=$(shell git describe --tags --abbrev=0 openssl)
+BRANCH=$(shell git rev-parse --abbrev-ref HEAD)
 dist:
 	git archive --format=tar.gz -9 --worktree-attributes \
 	    --prefix=i2pd_$(LATEST_TAG)/ $(LATEST_TAG) -o i2pd_$(LATEST_TAG).tar.gz
 
+last-dist:
+	git archive --format=tar.gz -9 --worktree-attributes \
+	    --prefix=i2pd_$(LATEST_TAG)/ $(BRANCH) -o ../i2pd_$(LATEST_TAG).orig.tar.gz
+
+doxygen:
+	doxygen -s docs/Doxyfile
+
 .PHONY: all
 .PHONY: clean
 .PHONY: deps
+.PHONY: doxygen
 .PHONY: dist
 .PHONY: api
-.PHONY: mk_build_dir
+.PHONY: api_client
+.PHONY: mk_obj_dir

Makefile.bsd

@@ -1,4 +1,4 @@
-CXX = g++
+CXX = clang++
 CXXFLAGS = -O2
 ## 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.
@@ -6,7 +6,7 @@ CXXFLAGS = -O2
 ## (e.g. -fstack-protector-strong -Wformat -Werror=format-security), we do not want to remove
 ## -std=c++11. If you want to remove this variable please do so in a way that allows setting
 ## custom FLAGS to work at build-time.
-NEEDED_CXXFLAGS = -std=c++11
+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 = -lcryptopp -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

Makefile.homebrew

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

Makefile.linux

@@ -1,5 +1,6 @@
-CXXFLAGS = -g -Wall
-INCFLAGS =
+# set defaults instead redefine
+CXXFLAGS ?= -g -Wall -Wextra -Wno-unused-parameter -pedantic -Wno-misleading-indentation
+INCFLAGS ?=
 
 ## NOTE: The NEEDED_CXXFLAGS are here so that custom CXXFLAGS can be specified at build time
 ## **without** overwriting the CXXFLAGS which we need in order to build.
@@ -8,15 +9,17 @@ INCFLAGS =
 ## -std=c++11. If you want to remove this variable please do so in a way that allows setting
 ## custom FLAGS to work at build-time.
 
-# detect proper flag for c++11 support by gcc
+# detect proper flag for c++11 support by compilers
 CXXVER := $(shell $(CXX) -dumpversion)
-ifeq ($(shell expr match ${CXXVER} "4\.[0-9][0-9]"),4) # >= 4.10
+ifeq ($(shell expr match $(CXX) 'clang'),5)
+	NEEDED_CXXFLAGS += -std=c++11 
+else ifeq ($(shell expr match ${CXXVER} "4\.[0-9][0-9]"),4) # gcc >= 4.10
 	NEEDED_CXXFLAGS += -std=c++11
 else ifeq ($(shell expr match ${CXXVER} "4\.[7-9]"),3) # >= 4.7
-	NEEDED_CXXFLAGS += -std=c++11
+	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 $(CXX) 'clang'),5)
+else ifeq ($(shell expr match ${CXXVER} "[5-6]\.[0-9]"),3) # gcc >= 5.0
 	NEEDED_CXXFLAGS += -std=c++11
 else # not supported
 	$(error Compiler too old)
@@ -25,31 +28,43 @@ 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)/libcryptopp.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
+	LDLIBS  = $(LIBDIR)/libboost_system.a
+	LDLIBS += $(LIBDIR)/libboost_date_time.a
+	LDLIBS += $(LIBDIR)/libboost_filesystem.a
+	LDLIBS += $(LIBDIR)/libboost_program_options.a
+	LDLIBS += $(LIBDIR)/libssl.a
+	LDLIBS += $(LIBDIR)/libcrypto.a
+	LDLIBS += $(LIBDIR)/libz.a
+	LDLIBS += -lpthread -static-libstdc++ -static-libgcc -lrt -ldl
+	USE_AESNI := no
 else
-  LDLIBS = -lcryptopp -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
 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)
+	CXXFLAGS += -DUSE_UPNP
+ifeq ($(USE_STATIC),yes)
+	LDLIBS += $(LIBDIR)/libminiupnpc.a
+else
+	LDLIBS += -lminiupnpc
+endif
 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
+ifneq ($(shell $(GREP) -c aes /proc/cpuinfo),0)
+	CPU_FLAGS += -maes -DAESNI
 endif
 endif
+
+ifeq ($(USE_AVX),yes)
+#check if AVX supported by CPU
+ifneq ($(shell $(GREP) -c avx /proc/cpuinfo),0)
+	CPU_FLAGS += -mavx
+endif
 endif

Makefile.mingw

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

Makefile.osx

@@ -1,21 +1,33 @@
 CXX = clang++
-CXXFLAGS = -g -Wall -std=c++11 -DCRYPTOPP_DISABLE_ASM -DMAC_OSX
-#CXXFLAGS = -g -O2 -Wall -std=c++11 -DCRYPTOPP_DISABLE_ASM
-INCFLAGS = -I/usr/local/include
+CXXFLAGS = -Os -Wall -std=c++11 -DMAC_OSX
+#CXXFLAGS = -g -O2 -Wall -std=c++11
+INCFLAGS = -I/usr/local/include 
 LDFLAGS = -Wl,-rpath,/usr/local/lib -L/usr/local/lib
-LDLIBS = -lcryptopp -lboost_system -lboost_date_time -lboost_filesystem -lboost_regex -lboost_program_options -lpthread
 
-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
 
-# 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)
+ifeq ($(USE_UPNP),yes)
+  LDFLAGS += -ldl
+  CXXFLAGS += -DUSE_UPNP
+ifeq ($(USE_STATIC),yes)
+  LDLIBS += /usr/local/lib/libminiupnpc.a
+else
+  LDLIBS += -lminiupnpc
+endif
+endif
+
+ifeq ($(USE_AESNI),1)
   CXXFLAGS += -maes -DAESNI
+else
+  CXXFLAGS += -msse
+endif
+
+ifeq ($(USE_AVX),1)
+  CXXFLAGS += -mavx
 endif
 
 # Disabled, since it will be the default make rule. I think its better

NTCPSession.cpp

@@ -1,967 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include "I2PEndian.h"
-#include <cryptopp/dh.h>
-#include "base64.h"
-#include "Log.h"
-#include "Timestamp.h"
-#include "CryptoConst.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)
-	{
-		CryptoPP::DH dh (elgp, elgg);
-		uint8_t sharedKey[256];
-		if (!dh.Agree (sharedKey, m_DHKeysPair->privateKey, pubKey))
-		{    
-		    LogPrint (eLogError, "Couldn't create shared key");
-			Terminate ();
-			return;
-		};
-
-		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, "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 ());
-			for (auto it: m_SendQueue)
-				DeleteI2NPMessage (it);
-			m_SendQueue.clear ();
-			if (m_NextMessage)	
-			{	
-				i2p::DeleteI2NPMessage (m_NextMessage);
-				m_NextMessage = nullptr;
-			}	
-			m_TerminationTimer.cancel ();
-			LogPrint (eLogInfo, "NTCP session terminated");
-		}	
-	}	
-
-	void NTCPSession::Connected ()
-	{
-		m_IsEstablished = true;
-
-		delete m_Establisher;
-		m_Establisher = nullptr;
-		
-		delete m_DHKeysPair;
-		m_DHKeysPair = nullptr;	
-
-		SendTimeSyncMessage ();
-		PostI2NPMessage (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->publicKey;
-		memcpy (m_Establisher->phase1.pubKey, x, 256);
-		CryptoPP::SHA256().CalculateDigest(m_Establisher->phase1.HXxorHI, x, 256);
-		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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "Phase 1 read error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				Terminate ();
-		}
-		else
-		{	
-			// verify ident
-			uint8_t digest[32];
-			CryptoPP::SHA256().CalculateDigest(digest, m_Establisher->phase1.pubKey, 256);
-			const uint8_t * ident = i2p::context.GetRouterInfo ().GetIdentHash ();
-			for (int i = 0; i < 32; i++)
-			{	
-				if ((m_Establisher->phase1.HXxorHI[i] ^ ident[i]) != digest[i])
-				{
-					LogPrint (eLogError, "Wrong ident");
-					Terminate ();
-					return;
-				}	
-			}	
-			
-			SendPhase2 ();
-		}	
-	}	
-
-	void NTCPSession::SendPhase2 ()
-	{
-		if (!m_DHKeysPair)
-			m_DHKeysPair = transports.GetNextDHKeysPair ();
-		const uint8_t * y = m_DHKeysPair->publicKey;
-		memcpy (m_Establisher->phase2.pubKey, y, 256);
-		uint8_t xy[512];
-		memcpy (xy, m_Establisher->phase1.pubKey, 256);
-		memcpy (xy + 256, y, 256);
-		CryptoPP::SHA256().CalculateDigest(m_Establisher->phase2.encrypted.hxy, xy, 512); 
-		uint32_t tsB = htobe32 (i2p::util::GetSecondsSinceEpoch ());
-		m_Establisher->phase2.encrypted.timestamp = tsB;
-		// TODO: fill filler
-
-		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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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->publicKey, 256);
-			memcpy (xy + 256, m_Establisher->phase2.pubKey, 256);
-			if (!CryptoPP::SHA256().VerifyDigest(m_Establisher->phase2.encrypted.hxy, xy, 512)) 
-			{
-				LogPrint (eLogError, "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;
-			// TODO: fill padding with random data
-			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); // 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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogError, "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 (eLogError, "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);
-			m_RemoteIdentity.FromBuffer (buf + 2, size);
-			if (m_Server.FindNTCPSession (m_RemoteIdentity.GetIdentHash ()))
-			{
-				LogPrint (eLogError, "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), 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 (eLogError, "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;	
-
-		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, "signature verification failed");
-			Terminate ();
-			return;
-		}	
-		m_RemoteIdentity.DropVerifier (); 
-
-		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)
-	{
-		if (ecode)
-        {
-			LogPrint (eLogWarning, "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, "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);
-
-			// verify 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 (m_Establisher->phase2.encrypted.timestamp); // tsB
-
-			if (!s.Verify (m_RemoteIdentity, m_ReceiveBuffer))
-			{	
-				LogPrint (eLogError, "signature verification failed");
-				Terminate ();
-				return;
-			}	
-			m_RemoteIdentity.DropVerifier (); 
-			LogPrint (eLogInfo, "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)
-        {
-			LogPrint (eLogError, "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 (eLogError, "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
-		{	
-			// descrypt header and extract length
-			uint8_t buf[16];
-			m_Decryption.Decrypt (encrypted, buf);
-			uint16_t dataSize = bufbe16toh (buf);
-			if (dataSize)
-			{
-				// new message
-				if (dataSize > NTCP_MAX_MESSAGE_SIZE)
-				{
-					LogPrint (eLogError, "NTCP data size ", dataSize, " exceeds max size");
-					return false;
-				}
-				m_NextMessage = dataSize <= I2NP_MAX_SHORT_MESSAGE_SIZE - 2 ? NewI2NPShortMessage () : NewI2NPMessage ();
-				memcpy (m_NextMessage->buf, buf, 16);
-				m_NextMessageOffset = 16;
-				m_NextMessage->offset = 2; // size field
-				m_NextMessage->len = dataSize + 2; 
-			}	
-			else
-			{	
-				// timestamp
-				LogPrint ("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
-			m_Handler.PutNextMessage (m_NextMessage);
-			m_NextMessage = nullptr;
-		}
-		return true;	
- 	}	
-
-	void NTCPSession::Send (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<I2NPMessage *>{ msg }));	
-	}
-
-	boost::asio::const_buffers_1 NTCPSession::CreateMsgBuffer (I2NPMessage * msg)
-	{
-		uint8_t * sendBuffer;
-		int len;
-
-		if (msg)
-		{	
-			// regular I2NP
-			if (msg->offset < 2)
-			{
-				LogPrint (eLogError, "Malformed I2NP message");
-				i2p::DeleteI2NPMessage (msg);
-			}	
-			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;
-		// TODO: fill padding 
-		m_Adler.CalculateDigest (sendBuffer + len + 2 + padding, 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<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<I2NPMessage *> msgs)
-	{
-		m_IsSending = false;
-		for (auto it: msgs)
-			if (it) i2p::DeleteI2NPMessage (it);
-		if (ecode)
-        {
-			LogPrint (eLogWarning, "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::SendI2NPMessage (I2NPMessage * msg)
-	{
-		m_Server.GetService ().post (std::bind (&NTCPSession::PostI2NPMessage, shared_from_this (), msg));  
-	}	
-
-	void NTCPSession::PostI2NPMessage (I2NPMessage * msg)
-	{
-		if (msg)
-		{
-			if (m_IsTerminated)
-			{
-				DeleteI2NPMessage (msg);
-				return;
-			}
-			if (m_IsSending)
-				m_SendQueue.push_back (msg);
-			else	
-				Send (msg);
-		}	
-	}	
-
-	void NTCPSession::SendI2NPMessages (const std::vector<I2NPMessage *>& msgs)
-	{
-		m_Server.GetService ().post (std::bind (&NTCPSession::PostI2NPMessages, shared_from_this (), msgs));  
-	}	
-
-	void NTCPSession::PostI2NPMessages (std::vector<I2NPMessage *> msgs)
-	{
-		if (m_IsTerminated)
-		{
-			for (auto it: msgs)
-				DeleteI2NPMessage (it);
-			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 ("No activity fo ", NTCP_TERMINATION_TIMEOUT, " seconds");
-			//Terminate ();
-			m_Socket.close ();// invoke Terminate () from HandleReceive 
-		}	
-	}	
-
-//-----------------------------------------
-	NTCPServer::NTCPServer (int port):
-		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, "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, "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 ("NTCP server: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void NTCPServer::AddNTCPSession (std::shared_ptr<NTCPSession> session)
-	{
-		if (session)
-		{
-			std::unique_lock<std::mutex> l(m_NTCPSessionsMutex);	
-			m_NTCPSessions[session->GetRemoteIdentity ().GetIdentHash ()] = session;
-		}
-	}	
-
-	void NTCPServer::RemoveNTCPSession (std::shared_ptr<NTCPSession> session)
-	{
-		if (session)
-		{
-			std::unique_lock<std::mutex> l(m_NTCPSessionsMutex);	
-			m_NTCPSessions.erase (session->GetRemoteIdentity ().GetIdentHash ());
-		}
-	}	
-
-	std::shared_ptr<NTCPSession> NTCPServer::FindNTCPSession (const i2p::data::IdentHash& ident)
-	{
-		std::unique_lock<std::mutex> l(m_NTCPSessionsMutex);	
-		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 (eLogInfo, "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 (eLogInfo, ep.address (), " is banned for ", it->second - ts, " more seconds");
-						conn = nullptr;
-					}
-					else
-						m_BanList.erase (it);
-				}
-				if (conn)
-					conn->ServerLogin ();
-			}
-			else
-				LogPrint (eLogError, "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 (eLogInfo, "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 (eLogInfo, ep.address (), " is banned for ", it->second - ts, " more seconds");
-						conn = nullptr;
-					}
-					else
-						m_BanList.erase (it);
-				}
-				if (conn)
-					conn->ServerLogin ();
-			}
-			else
-				LogPrint (eLogError, "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 (eLogInfo, "Connecting to ", address ,":",  port);
-		m_Service.post([conn, this]()
-			{           
-				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, "Connect error: ", ecode.message ());
-			if (ecode != boost::asio::error::operation_aborted)
-				i2p::data::netdb.SetUnreachable (conn->GetRemoteIdentity ().GetIdentHash (), true);
-			conn->Terminate ();
-		}
-		else
-		{
-			LogPrint (eLogInfo, "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 (eLogInfo, addr, " has been banned for ", NTCP_BAN_EXPIRATION_TIMEOUT, " seconds");
-	}
-}	
-}	

NetDb.h

@@ -1,135 +0,0 @@
-#ifndef NETDB_H__
-#define NETDB_H__
-
-#include <inttypes.h>
-#include <set>
-#include <map>
-#include <list>
-#include <string>
-#include <thread>
-#include <mutex>
-#include <boost/filesystem.hpp>
-#include "Queue.h"
-#include "I2NPProtocol.h"
-#include "RouterInfo.h"
-#include "LeaseSet.h"
-#include "Tunnel.h"
-#include "TunnelPool.h"
-#include "Reseed.h"
-
-namespace i2p
-{
-namespace data
-{		
-	class RequestedDestination
-	{	
-		public:
-
-			typedef std::function<void (std::shared_ptr<RouterInfo>)> RequestComplete;
-
-			RequestedDestination (const IdentHash& destination, bool isExploratory = false):
-				m_Destination (destination), m_IsExploratory (isExploratory), m_CreationTime (0) {};
-			~RequestedDestination () { if (m_RequestComplete) m_RequestComplete (nullptr); };			
-
-			const IdentHash& GetDestination () const { return m_Destination; };
-			int GetNumExcludedPeers () const { return m_ExcludedPeers.size (); };
-			const std::set<IdentHash>& GetExcludedPeers () { return m_ExcludedPeers; };
-			void ClearExcludedPeers ();
-			bool IsExploratory () const { return m_IsExploratory; };
-			bool IsExcluded (const IdentHash& ident) const { return m_ExcludedPeers.count (ident); };
-			uint64_t GetCreationTime () const { return m_CreationTime; };
-			I2NPMessage * CreateRequestMessage (std::shared_ptr<const RouterInfo>, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel);
-			I2NPMessage * CreateRequestMessage (const IdentHash& floodfill);
-			
-			void SetRequestComplete (const RequestComplete& requestComplete) { m_RequestComplete = requestComplete; };
-			bool IsRequestComplete () const { return m_RequestComplete != nullptr; };
-			void Success (std::shared_ptr<RouterInfo> r);
-			void Fail ();
-			
-		private:
-
-			IdentHash m_Destination;
-			bool m_IsExploratory;
-			std::set<IdentHash> m_ExcludedPeers;
-			uint64_t m_CreationTime;
-			RequestComplete m_RequestComplete;
-	};	
-	
-	class NetDb
-	{
-		public:
-
-			NetDb ();
-			~NetDb ();
-
-			void Start ();
-			void Stop ();
-			
-			void AddRouterInfo (const uint8_t * buf, int len);
-			void AddRouterInfo (const IdentHash& ident, const uint8_t * buf, int len);
-			void 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;
-
-			void RequestDestination (const IdentHash& destination, RequestedDestination::RequestComplete requestComplete = nullptr);			
-			
-			void HandleDatabaseStoreMsg (I2NPMessage * msg);
-			void HandleDatabaseSearchReplyMsg (I2NPMessage * msg);
-			void HandleDatabaseLookupMsg (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) 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 (I2NPMessage * msg);
-
-			void Reseed ();
-
-			// for web interface and stats
-			int GetNumRouters () const { return m_RouterInfos.size (); };
-			int GetNumFloodfills () const { return m_Floodfills.size (); };
-			int GetNumLeaseSets () const { return m_LeaseSets.size (); };
-			
-		private:
-
-			bool CreateNetDb(boost::filesystem::path directory);
-			void Load (const char * directory);
-			void SaveUpdated (const char * directory);
-			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;
-			std::mutex m_RequestedDestinationsMutex;
-			std::map<IdentHash, std::unique_ptr<RequestedDestination> > m_RequestedDestinations;
-			
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			i2p::util::Queue<I2NPMessage> m_Queue; // of I2NPDatabaseStoreMsg
-
-			Reseeder * m_Reseeder;
-
-			static const char m_NetDbPath[];
-	};
-
-	extern NetDb netdb;
-}
-}
-
-#endif

Profiling.cpp

@@ -1,128 +0,0 @@
-#include <boost/filesystem.hpp>
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/ini_parser.hpp>
-#include "base64.h"
-#include "util.h"
-#include "Profiling.h"
-
-namespace i2p
-{
-namespace data
-{
-	RouterProfile::RouterProfile (const IdentHash& identHash):
-		m_IdentHash (identHash), m_LastUpdateTime (boost::posix_time::second_clock::local_time()),
-		m_NumTunnelsAgreed (0), m_NumTunnelsDeclined (0),
-		m_NumTunnelsNonReplied (0)
-	{
-	}
-
-	void RouterProfile::UpdateTime ()
-	{
-		m_LastUpdateTime = boost::posix_time::second_clock::local_time();
-	}	
-		
-	void RouterProfile::Save ()
-	{
-		// fill sections
-		boost::property_tree::ptree participation;
-		participation.put (PEER_PROFILE_PARTICIPATION_AGREED, m_NumTunnelsAgreed);
-		participation.put (PEER_PROFILE_PARTICIPATION_DECLINED, m_NumTunnelsDeclined);
-		participation.put (PEER_PROFILE_PARTICIPATION_NON_REPLIED, m_NumTunnelsNonReplied);
-		// fill property tree
-		boost::property_tree::ptree pt;
-		pt.put (PEER_PROFILE_LAST_UPDATE_TIME, boost::posix_time::to_simple_string (m_LastUpdateTime));
-		pt.put_child (PEER_PROFILE_SECTION_PARTICIPATION, participation);
-		
-		// save to file
-		auto path = i2p::util::filesystem::GetDefaultDataDir() / PEER_PROFILES_DIRECTORY;
-		if (!boost::filesystem::exists (path))
-		{
-			// Create directory is necessary
-			if (!boost::filesystem::create_directory (path))
-			{	
-				LogPrint (eLogError, "Failed to create directory ", path);
-				return;
-			}			
-			const char * chars = GetBase64SubstitutionTable (); // 64 bytes
-			for (int i = 0; i < 64; i++)
-			{
-				auto path1 = path / (std::string ("p") + chars[i]);
-				if (!boost::filesystem::create_directory (path1)) 
-				{
-					LogPrint (eLogError, "Failed to create directory ", path1);
-					return;
-				}			
-			}				
-		}
-		std::string base64 = m_IdentHash.ToBase64 ();
-		path = path / (std::string ("p") + base64[0]);
-		auto filename = path / (std::string (PEER_PROFILE_PREFIX) + base64 + ".txt");
-		try
-		{
-			boost::property_tree::write_ini (filename.string (), pt);
-		}
-		catch (std::exception& ex)
-		{
-			LogPrint (eLogError, "Can't write ", filename, ": ", ex.what ());
-		}
-	}	
-
-	void RouterProfile::Load ()
-	{
-		std::string base64 = m_IdentHash.ToBase64 ();
-		auto path = i2p::util::filesystem::GetDefaultDataDir() / PEER_PROFILES_DIRECTORY;
-		path /= std::string ("p") + base64[0];
-		auto filename = path / (std::string (PEER_PROFILE_PREFIX) + base64 + ".txt");
-		if (boost::filesystem::exists (filename))
-		{	
-			boost::property_tree::ptree pt;
-			try
-			{
-				boost::property_tree::read_ini (filename.string (), pt);
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Can't read ", filename, ": ", ex.what ());
-				return;
-			}
-			try
-			{	
-				auto t = pt.get (PEER_PROFILE_LAST_UPDATE_TIME, "");
-				if (t.length () > 0)
-					m_LastUpdateTime = boost::posix_time::time_from_string (t);
-				// read participations
-				auto participations = pt.get_child (PEER_PROFILE_SECTION_PARTICIPATION);
-				m_NumTunnelsAgreed = participations.get (PEER_PROFILE_PARTICIPATION_AGREED, 0);
-				m_NumTunnelsDeclined = participations.get (PEER_PROFILE_PARTICIPATION_DECLINED, 0);
-				m_NumTunnelsNonReplied = participations.get (PEER_PROFILE_PARTICIPATION_NON_REPLIED, 0);
-			}	
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "Can't read profile ", base64, " :", ex.what ());
-			}	
-		}	
-	}	
-		
-	void RouterProfile::TunnelBuildResponse (uint8_t ret)
-	{
-		if (ret > 0)
-			m_NumTunnelsDeclined++;
-		else
-			m_NumTunnelsAgreed++;
-		UpdateTime ();
-	}	
-
-	void RouterProfile::TunnelNonReplied ()
-	{
-		m_NumTunnelsNonReplied++;
-		UpdateTime ();
-	}	
-		
-	std::shared_ptr<RouterProfile> GetRouterProfile (const IdentHash& identHash)
-	{
-		auto profile = std::make_shared<RouterProfile> (identHash);
-		profile->Load (); // if possible
-		return profile;
-	}		
-}		
-}	

README.md

@@ -1,124 +1,76 @@
 i2pd
 ====
 
-I2P router written in C++
+[Русская версия](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 binaries](https://github.com/PurpleI2P/i2pd/releases/latest). 
+See [documentation](https://i2pd.readthedocs.io/en/latest/) for how to build 
+i2pd from source on your OS.
+
+**Supported systems:**
+
+* GNU/Linux x86/x64  - [![Build Status](https://travis-ci.org/PurpleI2P/i2pd.svg?branch=openssl)](https://travis-ci.org/PurpleI2P/i2pd)  
+* Windows        - [![Build status](https://ci.appveyor.com/api/projects/status/1908qe4p48ff1x23?svg=true)](https://ci.appveyor.com/project/PurpleI2P/i2pd)  
+* Mac OS X
+* 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: 1K7Ds6KUeR8ya287UC4rYTjvC96vXyZbDY   
+ZEC: t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ  
+DASH: Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF   
+LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59  
+DOGE: DNXLQKziRPAsD9H3DFNjk4fLQrdaSX893Y  
+ANC: AQJYweYYUqM1nVfLqfoSMpUMfzxvS4Xd7z   
+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.
-
-Requirements for Linux/FreeBSD/OSX
-----------------------------------
-
-GCC 4.6 or newer, Boost 1.46 or newer, crypto++. Clang can be used instead of
-GCC.
-
-Requirements for Windows
-------------------------
-
-VS2013 (known to work with 12.0.21005.1 or newer), Boost 1.46 or newer,
-crypto++ 5.62. See Win32/README-Build.txt for instructions on how to build i2pd
-and its dependencies.
-
-Downloads
-------------
-
-Official binary releases could be found at:
-http://download.i2p.io/purplei2p/i2pd/releases/
-
-
-Build Statuses
----------------
-
-- Linux x64      - [![Build Status](https://jenkins.greyhat.no/buildStatus/icon?job=i2pd-linux)](https://jenkins.nordcloud.no/job/i2pd-linux/)
-- Linux ARM      - To be added
-- Mac OS X       - Got it working, but not well tested. (Only works with clang, not GCC.)
-- Microsoft VC13 - To be added
-
-
-Testing
--------
-
-First, build it.
-
-On Ubuntu/Debian based
-* sudo apt-get install libboost-dev libboost-filesystem-dev libboost-program-options-dev libboost-regex-dev libcrypto++-dev libboost-date-time-dev
-* $ cd i2pd
-* $ make
-
-Then, run it:
-
-$ ./i2p
-
-The client should now reseed by itself.
-
-To visit an I2P page, you need to find the b32 address of your destination.
-After that, go to the webconsole and add it behind the url. (Remove http:// from the address)
-
-This should resulting in for example:
-http://localhost:7070/4oes3rlgrpbkmzv4lqcfili23h3cvpwslqcfjlk6vvguxyggspwa.b32.i2p
-
-
-Cmdline options
----------------
-
-* --host=               - The external IP (deprecated). 
-* --port=               - The port to listen on
-* --httpport=           - The http port to listen on
-* --log=                - Enable or disable logging to file. 1 for yes, 0 for no.
-* --daemon=             - Enable or disable daemon mode. 1 for yes, 0 for no.
-* --service=            - 1 if uses system folders (/var/run/i2pd.pid, /var/log/i2pd.log, /var/lib/i2pd).
-* --v6=                 - 1 if supports communication through ipv6, off by default
-* --floodfill=          - 1 if router is floodfill, off by default
-* --bandwidth=          - L if bandwidth is limited to 32Kbs/sec, O if not. Always O if floodfill, otherwise L by default.
-* --httpproxyport=      - The port to listen on (HTTP Proxy)
-* --socksproxyport=     - The port to listen on (SOCKS Proxy)
-* --proxykeys=          - optional keys file for proxy's local destination
-* --ircport=            - The local port of IRC tunnel to listen on. 6668 by default
-* --ircdest=            - I2P destination address of IRC server. For example irc.postman.i2p
-* --irckeys=            - optional keys file for tunnel's local destination 
-* --eepkeys=            - File name containing destination keys, for example privKeys.dat.
-                          The file will be created if it does not already exist (issue #110).
-* --eephost=            - Address incoming trafic forward to. 127.0.0.1 by default
-* --eepport=            - Port incoming trafic forward to. 80 by default
-* --samport=            - Port of SAM bridge. Usually 7656. SAM is off if not specified
-* --bobport=            - Port of BOB command channel. Usually 2827. BOB is off if not specified
-* --i2pcontrolport=     - Port of I2P control service. Usually 7650. I2PControl is off if not specified
-* --conf=               - Config file (default: ~/.i2pd/i2p.conf or /var/lib/i2pd/i2p.conf)
-                          This parameter will be silently ignored if the specified config file does not exist.
-                          Options specified on the command line take precedence over those in the config file.
-
-Config files
-------------
-
-INI-like, syntax is the following : <key> = <value>.
-All command-line parameters are allowed as keys, for example:
-
-i2p.conf:
-
-	log = 1
-	v6 = 0
-	ircdest = irc.postman.i2p
-
-tunnels.cfg (filename of this config is subject of change):
-
-	 ; outgoing tunnel, to remote service    
-	[tunnel1]  
-	type = client      ; mandatory   
-	port = <integer>   ; mandatory, bind our side of tunnel to this local port  
-	keys = <filename>  ; optional  
-	destination     = <ident>    ; mandatory  
-	destinationport = <integer>  ; optional, port of remote i2p service  
-	   
-	 ; incoming tunnel, for local service(s)   
-	[tunnel2]   
-	type = server      ; mandatory   
-	host = <ident>     ; mandatory, hostname of our i2p service   
-	keys = <filename>  ; mandatory, hostname keys   
-	port = <integer>   ; mandatory, forward incoming connections from i2p to this port      
-	inport = <integer> ; optional, i2p service port   
-	accesslist = <ident>[,<ident>] ; optional, comma-separated list of i2p idents, allowed to connect to service  
-
-Note: '<ident>' type is a string like <hostname.i2p> or <abracadabra.b32.i2p>  

Reseed.cpp

@@ -1,824 +0,0 @@
-#include <string.h>
-#include <fstream>
-#include <sstream>
-#include <boost/regex.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/lexical_cast.hpp>
-#include <cryptopp/asn.h>
-#include <cryptopp/base64.h>
-#include <cryptopp/crc.h>
-#include <cryptopp/hmac.h>
-#include <cryptopp/zinflate.h>
-#include "I2PEndian.h"
-#include "Reseed.h"
-#include "Log.h"
-#include "Identity.h"
-#include "CryptoConst.h"
-#include "NetDb.h"
-#include "util.h"
-
-
-namespace i2p
-{
-namespace data
-{
-
-	static std::vector<std::string> httpReseedHostList = {
-				// "http://193.150.121.66/netDb/",  // unstable
-				// "http://us.reseed.i2p2.no/",     // misconfigured, not serving reseed data
-				// "http://jp.reseed.i2p2.no/",     // Really outdated RIs
-				"http://netdb.i2p2.no/",            // only SU3 (v2) support
-				"http://i2p.mooo.com/netDb/",
-				"http://uk.reseed.i2p2.no/",
-				"http://i2p-netdb.innovatio.no/"
-			};
-
-	//TODO: Remember to add custom port support. Not all serves on 443
-	static std::vector<std::string> httpsReseedHostList = {
-				// "https://193.150.121.66/netDb/",  // unstable
-				// "https://i2p-netdb.innovatio.no/",// Vuln to POODLE
-				"https://netdb.i2p2.no/",            // Only SU3 (v2) support
-				"https://reseed.i2p-projekt.de/",    // Only HTTPS
-				"https://cowpuncher.drollette.com/netdb/",  // Only HTTPS and SU3 (v2) support -- will move to a new location
-				// following hosts are fine but don't support AES256 
-				/*"https://i2p.mooo.com/netDb/",
-				"https://link.mx24.eu/",             // Only HTTPS and SU3 (v2) support
-				"https://i2pseed.zarrenspry.info/",  // Only HTTPS and SU3 (v2) support
-				"https://ieb9oopo.mooo.com/"         // Only HTTPS and SU3 (v2) support*/
-			};
-	
-	Reseeder::Reseeder()
-	{
-	}
-
-	Reseeder::~Reseeder()
-	{
-	}
-
-	bool Reseeder::reseedNow()
-	{
-		// This method is deprecated
-		try
-		{
-			std::string reseedHost = httpReseedHostList[(rand() % httpReseedHostList.size())];
-			LogPrint("Reseeding from ", reseedHost);
-			std::string content = i2p::util::http::httpRequest(reseedHost);
-			if (content == "")
-			{
-				LogPrint("Reseed failed");
-				return false;
-			}
-			boost::regex e("<\\s*A\\s+[^>]*href\\s*=\\s*\"([^\"]*)\"", boost::regex::normal | boost::regbase::icase);
-			boost::sregex_token_iterator i(content.begin(), content.end(), e, 1);
-			boost::sregex_token_iterator j;
-			//TODO: Ugly code, try to clean up.
-			//TODO: Try to reduce N number of variables
-			std::string name;
-			std::string routerInfo;
-			std::string tmpUrl;
-			std::string filename;
-			std::string ignoreFileSuffix = ".su3";
-			boost::filesystem::path root = i2p::util::filesystem::GetDataDir();
-			while (i != j)
-			{
-				name = *i++;
-				if (name.find(ignoreFileSuffix)!=std::string::npos)
-					continue;
-				LogPrint("Downloading ", name);
-				tmpUrl = reseedHost;
-				tmpUrl.append(name);
-				routerInfo = i2p::util::http::httpRequest(tmpUrl);
-				if (routerInfo.size()==0)
-					continue;
-				filename = root.string();
-#ifndef _WIN32
-				filename += "/netDb/r";
-#else
-				filename += "\\netDb\\r";
-#endif
-				filename += name.at(11); // first char in id
-#ifndef _WIN32
-				filename.append("/");
-#else
-				filename.append("\\");
-#endif
-				filename.append(name.c_str());
-				std::ofstream outfile (filename, std::ios::binary);
-				outfile << routerInfo;
-				outfile.close();
-			}
-			return true;
-		}
-		catch (std::exception& ex)
-		{
-			//TODO: error reporting
-			return false;
-		}
-		return false;
-	}	
-
-	int Reseeder::ReseedNowSU3 ()
-	{
-		CryptoPP::AutoSeededRandomPool rnd;
-		auto ind = rnd.GenerateWord32 (0, httpReseedHostList.size() - 1 +  httpsReseedHostList.size () - 1);
-		std::string reseedHost = (ind < httpReseedHostList.size()) ? httpReseedHostList[ind] : 
-			httpsReseedHostList[ind - httpReseedHostList.size()]; 
-		return ReseedFromSU3 (reseedHost, ind >= httpReseedHostList.size());
-	}
-
-	int Reseeder::ReseedFromSU3 (const std::string& host, bool https)
-	{
-		std::string url = host + "i2pseeds.su3";
-		LogPrint (eLogInfo, "Dowloading SU3 from ", host);
-		std::string su3 = https ? HttpsRequest (url) : i2p::util::http::httpRequest (url);
-		if (su3.length () > 0)
-		{
-			std::stringstream s(su3);
-			return ProcessSU3Stream (s);
-		}
-		else
-		{
-			LogPrint (eLogWarning, "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, "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, "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, "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, "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
-				i2p::crypto::RSASHA5124096RawVerifier verifier(it->second);
-				verifier.Update (tbs, tbsLen);
-				if (!verifier.Verify (signature))
-					LogPrint (eLogWarning, "SU3 signature verification failed");
-				delete[] signature;
-				delete[] tbs;
-				s.seekg (pos, std::ios::beg);
-			}
-			else
-				LogPrint (eLogWarning, "Signature type ", signatureType, " is not supported");
-		}
-		else
-			LogPrint (eLogWarning, "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; 
-				uint8_t crc32[4];
-				s.read ((char *)crc32, 4);	
-				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);
-				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, "SU3 archive data descriptor not found");
-						return numFiles;
-					}								
-	
-					s.read ((char *)crc32, 4);	
-					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, "Proccessing file ", localFileName, " ", compressedSize, " bytes");
-				if (!compressedSize)
-				{
-					LogPrint (eLogWarning, "Unexpected size 0. Skipped");
-					continue;
-				}	
-				
-				uint8_t * compressed = new uint8_t[compressedSize];
-				s.read ((char *)compressed, compressedSize);
-				if (compressionMethod) // we assume Deflate
-				{
-					CryptoPP::Inflator decompressor;
-					decompressor.Put (compressed, compressedSize);	
-					decompressor.MessageEnd();
-					if (decompressor.MaxRetrievable () <= uncompressedSize)
-					{
-						uint8_t * uncompressed = new uint8_t[uncompressedSize];	
-						decompressor.Get (uncompressed, uncompressedSize);	
-						if (CryptoPP::CRC32().VerifyDigest (crc32, uncompressed, uncompressedSize))
-						{
-							i2p::data::netdb.AddRouterInfo (uncompressed, uncompressedSize);
-							numFiles++;
-						}
-						else
-							LogPrint (eLogError, "CRC32 verification failed");
-						delete[] uncompressed;
-					}
-					else
-						LogPrint (eLogError, "Actual uncompressed size ", decompressor.MaxRetrievable (), " exceed ", uncompressedSize, " from header");
-				}	
-				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, "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;
-	}
-
-	const char CERTIFICATE_HEADER[] = "-----BEGIN CERTIFICATE-----";
-	const char CERTIFICATE_FOOTER[] = "-----END CERTIFICATE-----";
-	void Reseeder::LoadCertificate (const std::string& filename)
-	{
-		std::ifstream s(filename, std::ifstream::binary);
-		if (s.is_open ())	
-		{
-			s.seekg (0, std::ios::end);
-			size_t len = s.tellg ();
-			s.seekg (0, std::ios::beg);
-			char buf[2048];
-			s.read (buf, len);
-			std::string cert (buf, len);
-			// assume file in pem format
-			auto pos1 = cert.find (CERTIFICATE_HEADER);	
-			auto pos2 = cert.find (CERTIFICATE_FOOTER);	
-			if (pos1 == std::string::npos || pos2 == std::string::npos)
-			{
-				LogPrint (eLogError, "Malformed certificate file");
-				return;
-			}	
-			pos1 += strlen (CERTIFICATE_HEADER);
-			pos2 -= pos1;
-			std::string base64 = cert.substr (pos1, pos2);
-
-			CryptoPP::ByteQueue queue;
-			CryptoPP::Base64Decoder decoder; // regular base64 rather than I2P 
-			decoder.Attach (new CryptoPP::Redirector (queue));
-			decoder.Put ((const uint8_t *)base64.data(), base64.length());
-			decoder.MessageEnd ();
-			
-			LoadCertificate (queue);
-		}
-		else
-			LogPrint (eLogError, "Can't open certificate file ", filename);
-	}
-
-	std::string Reseeder::LoadCertificate (CryptoPP::ByteQueue& queue)
-	{
-		// extract X.509
-		CryptoPP::BERSequenceDecoder x509Cert (queue);
-		CryptoPP::BERSequenceDecoder tbsCert (x509Cert);
-		// version
-		uint32_t ver;
-		CryptoPP::BERGeneralDecoder context (tbsCert, CryptoPP::CONTEXT_SPECIFIC | CryptoPP::CONSTRUCTED);
-		CryptoPP::BERDecodeUnsigned<uint32_t>(context, ver, CryptoPP::INTEGER);
-		// serial
-		CryptoPP::Integer serial;
-   		serial.BERDecode(tbsCert);	
-		// signature
-		CryptoPP::BERSequenceDecoder signature (tbsCert);
-   		signature.SkipAll();
-		
-		// issuer
-		std::string name;
-		CryptoPP::BERSequenceDecoder issuer (tbsCert);
-		{
-			CryptoPP::BERSetDecoder c (issuer);	c.SkipAll();
-			CryptoPP::BERSetDecoder st (issuer); st.SkipAll();
-			CryptoPP::BERSetDecoder l (issuer); l.SkipAll();
-			CryptoPP::BERSetDecoder o (issuer); o.SkipAll();
-			CryptoPP::BERSetDecoder ou (issuer); ou.SkipAll();
-			CryptoPP::BERSetDecoder cn (issuer);
-			{		
-				CryptoPP::BERSequenceDecoder attributes (cn);
-				{			
-					CryptoPP::BERGeneralDecoder ident(attributes, CryptoPP::OBJECT_IDENTIFIER);
-					ident.SkipAll ();
-					CryptoPP::BERDecodeTextString (attributes, name, CryptoPP::UTF8_STRING);
-				}	
-			}	
-		}	
-   		issuer.SkipAll();
-		// validity
-		CryptoPP::BERSequenceDecoder validity (tbsCert);
-   		validity.SkipAll();
-		// subject
-		CryptoPP::BERSequenceDecoder subject (tbsCert);
-   		subject.SkipAll();
-		// public key
-		CryptoPP::BERSequenceDecoder publicKey (tbsCert);
-		{			
-			CryptoPP::BERSequenceDecoder ident (publicKey);
-			ident.SkipAll ();
-			CryptoPP::BERGeneralDecoder key (publicKey, CryptoPP::BIT_STRING);
-			key.Skip (1); // FIXME: probably bug in crypto++
-			CryptoPP::BERSequenceDecoder keyPair (key);
-			CryptoPP::Integer n;
-   			n.BERDecode (keyPair);
-			if (name.length () > 0) 
-			{	
-				PublicKey value;
-				n.Encode (value, 512);
-				m_SigningKeys[name] = value;
-			}		
-			else
-				LogPrint (eLogWarning, "Unknown issuer. Skipped");
-		}	
-   		publicKey.SkipAll();
-		
-		tbsCert.SkipAll();
-		x509Cert.SkipAll();
-		return name;
-	}	
-	
-	void Reseeder::LoadCertificates ()
-	{
-		boost::filesystem::path reseedDir = i2p::util::filesystem::GetCertificatesDir() / "reseed";
-		
-		if (!boost::filesystem::exists (reseedDir))
-		{
-			LogPrint (eLogWarning, "Reseed certificates not loaded. ", reseedDir, " doesn't exist");
-			return;
-		}
-
-		int numCertificates = 0;
-		boost::filesystem::directory_iterator end; // empty
-		for (boost::filesystem::directory_iterator it (reseedDir); it != end; ++it)
-		{
-			if (boost::filesystem::is_regular_file (it->status()) && it->path ().extension () == ".crt")
-			{	
-				LoadCertificate (it->path ().string ());
-				numCertificates++;
-			}	
-		}	
-		LogPrint (eLogInfo, numCertificates, " certificates loaded");
-	}	
-
-	std::string Reseeder::HttpsRequest (const std::string& address)
-	{
-		i2p::util::http::url u(address);
-		TlsSession session (u.host_, 443);
-		
-		// 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";	
-		session.Send ((uint8_t *)ss.str ().c_str (), ss.str ().length ());
-
-		// read response
-		std::stringstream rs;
-		while (session.Receive (rs))
-			;
-		return i2p::util::http::GetHttpContent (rs);
-	}	
-
-	TlsSession::TlsSession (const std::string& host, int port):
-		m_Seqn (0)
-	{
-		m_Site.connect(host, boost::lexical_cast<std::string>(port));
-		if (m_Site.good ())
-		{
-			Handshake ();
-		}
-		else
-			LogPrint (eLogError, "Can't connect to ", host, ":", port);
-	}	
-	
-	void TlsSession::Handshake ()
-	{
-		static uint8_t clientHello[] = 
-		{
-			0x16, // handshake
-			0x03, 0x03, // version (TLS 1.2)
-			0x00, 0x2F, // length of handshake
-			// handshake
-			0x01, // handshake type (client hello)
-			0x00, 0x00, 0x2B, // length of handshake payload 
-			// client hello
-			0x03, 0x03, // highest version supported (TLS 1.2)
-			0x45, 0xFA, 0x01, 0x19, 0x74, 0x55, 0x18, 0x36, 
-			0x42, 0x05, 0xC1, 0xDD, 0x4A, 0x21, 0x80, 0x80, 
-			0xEC, 0x37, 0x11, 0x93, 0x16, 0xF4, 0x66, 0x00, 
-			0x12, 0x67, 0xAB, 0xBA, 0xFF, 0x29, 0x13, 0x9E, // 32 random bytes
-			0x00, // session id length
-			0x00, 0x02, // chiper suites length
-			0x00, 0x3D, // RSA_WITH_AES_256_CBC_SHA256
-			0x01, // compression methods length
-			0x00,  // no compression
-			0x00, 0x00 // extensions length
-		};	
-
-		static uint8_t changeCipherSpecs[] =
-		{
-			0x14, // change cipher specs
-			0x03, 0x03, // version (TLS 1.2)
-			0x00, 0x01, // length
-			0x01 // type
-		};
-
-		static uint8_t finished[] =
-		{
-			0x16, // handshake
-			0x03, 0x03, // version (TLS 1.2)
-			0x00, 0x50, // length of handshake (80 bytes)
-			// handshake (encrypted)
-			// unencrypted context
-			//  0x14 handshake type (finished)
-			// 0x00, 0x00, 0x0C  length of handshake payload 
-			// 12 bytes of verified data
-		};
-	
-		// send ClientHello
-		m_Site.write ((char *)clientHello, sizeof (clientHello));
-		m_FinishedHash.Update (clientHello + 5, sizeof (clientHello) - 5);
-		// read ServerHello
-		uint8_t type;
-		m_Site.read ((char *)&type, 1); 
-		uint16_t version;
-		m_Site.read ((char *)&version, 2); 
-		uint16_t length;
-		m_Site.read ((char *)&length, 2); 
-		length = be16toh (length);
-		char * serverHello = new char[length];
-		m_Site.read (serverHello, length);
-		m_FinishedHash.Update ((uint8_t *)serverHello, length);
-		uint8_t serverRandom[32];
-		if (serverHello[0] == 0x02) // handshake type server hello
-			memcpy (serverRandom, serverHello + 6, 32);
-		else
-			LogPrint (eLogError, "Unexpected handshake type ", (int)serverHello[0]);
-		delete[] serverHello;
-		// read Certificate
-		m_Site.read ((char *)&type, 1); 
-		m_Site.read ((char *)&version, 2); 
-		m_Site.read ((char *)&length, 2); 
-		length = be16toh (length);
-		char * certificate = new char[length];
-		m_Site.read (certificate, length);
-		m_FinishedHash.Update ((uint8_t *)certificate, length);
-		CryptoPP::RSA::PublicKey publicKey;
-		// 0 - handshake type
-		// 1 - 3 - handshake payload length
-		// 4 - 6 - length of array of certificates
-		// 7 - 9 - length of certificate
-		if (certificate[0] == 0x0B) // handshake type certificate
-			publicKey = ExtractPublicKey ((uint8_t *)certificate + 10, length - 10);
-		else
-			LogPrint (eLogError, "Unexpected handshake type ", (int)certificate[0]);
-		delete[] certificate;
-		// read ServerHelloDone
-		m_Site.read ((char *)&type, 1); 
-		m_Site.read ((char *)&version, 2); 
-		m_Site.read ((char *)&length, 2); 
-		length = be16toh (length);
-		char * serverHelloDone = new char[length];
-		m_Site.read (serverHelloDone, length);
-		m_FinishedHash.Update ((uint8_t *)serverHelloDone, length);
-		if (serverHelloDone[0] != 0x0E) // handshake type hello done
-			LogPrint (eLogError, "Unexpected handshake type ", (int)serverHelloDone[0]);
-		delete[] serverHelloDone;
-		// our turn now
-		// generate secret key
-		uint8_t secret[48]; 
-		secret[0] = 3; secret[1] = 3; // version
-		m_Rnd.GenerateBlock (secret + 2, 46); // 46 random bytes
-		// encrypt RSA
- 		CryptoPP::RSAES_PKCS1v15_Encryptor encryptor(publicKey);
-		size_t encryptedLen = encryptor.CiphertextLength (48); // number of bytes for encrypted 48 bytes, usually 256 (2048 bits key)
-		uint8_t * encrypted = new uint8_t[encryptedLen + 2]; // + 2 bytes for length
-		htobe16buf (encrypted, encryptedLen); // first two bytes means length 
-		encryptor.Encrypt (m_Rnd, secret, 48, encrypted + 2);
-		// send ClientKeyExchange
-		// 0x10 - handshake type "client key exchange"
-		SendHandshakeMsg (0x10, encrypted, encryptedLen + 2);
-		delete[] encrypted;
-		// send ChangeCipherSpecs
-		m_Site.write ((char *)changeCipherSpecs, sizeof (changeCipherSpecs));
-		// calculate master secret
-		uint8_t masterSecret[48], random[64];
-		memcpy (random, clientHello + 11, 32);
-		memcpy (random + 32, serverRandom, 32);
-		PRF (secret, "master secret", random, 64, 48, masterSecret);
-		// expand master secret			
-		uint8_t keys[128]; // clientMACKey(32), serverMACKey(32), clientKey(32), serverKey(32)
-		memcpy (random, serverRandom, 32);
-		memcpy (random + 32, clientHello + 11, 32);
-		PRF (masterSecret, "key expansion", random, 64, 128, keys); 
-		memcpy (m_MacKey, keys, 32);
-		m_Encryption.SetKey (keys + 64);
-		m_Decryption.SetKey (keys + 96);
-
-		// send finished
-		uint8_t finishedHashDigest[32], finishedPayload[40], encryptedPayload[80];
-		finishedPayload[0] = 0x14; // handshake type (finished)
-		finishedPayload[1] = 0; finishedPayload[2] = 0; finishedPayload[3] = 0x0C; // 12 bytes
-		m_FinishedHash.Final (finishedHashDigest);
-		PRF (masterSecret, "client finished", finishedHashDigest, 32, 12, finishedPayload + 4);
-		uint8_t mac[32];
-		CalculateMAC (0x16, finishedPayload, 16, mac);
-		Encrypt (finishedPayload, 16, mac, encryptedPayload);
-		m_Site.write ((char *)finished, sizeof (finished));
-		m_Site.write ((char *)encryptedPayload, 80);
-		// read ChangeCipherSpecs
-		uint8_t changeCipherSpecs1[6];
-		m_Site.read ((char *)changeCipherSpecs1, 6);
-		// read finished
-		m_Site.read ((char *)&type, 1); 
-		m_Site.read ((char *)&version, 2); 
-		m_Site.read ((char *)&length, 2); 
-		length = be16toh (length);
-		char * finished1 = new char[length];
-		m_Site.read (finished1, length);
-		delete[] finished1;
-	}
-
-	void TlsSession::SendHandshakeMsg (uint8_t handshakeType, uint8_t * data, size_t len)
-	{
-		uint8_t handshakeHeader[9];
-		handshakeHeader[0] = 0x16; // handshake
- 		handshakeHeader[1] = 0x03; handshakeHeader[2] = 0x03; // version is always TLS 1.2 (3,3) 
-		htobe16buf (handshakeHeader + 3, len + 4); // length of payload
-		//payload starts
-		handshakeHeader[5] = handshakeType; // handshake type
-		handshakeHeader[6] = 0; // highest byte of payload length is always zero
-		htobe16buf (handshakeHeader + 7, len); // length of data
-		m_Site.write ((char *)handshakeHeader, 9);
-		m_FinishedHash.Update (handshakeHeader + 5, 4); // only payload counts
-		m_Site.write ((char *)data, len);
-		m_FinishedHash.Update (data, len);
-	}
-
-	void TlsSession::PRF (const uint8_t * secret, const char * label, const uint8_t * random, size_t randomLen,
-		size_t len, uint8_t * buf)
-	{
-		// secret is assumed 48 bytes	
-		// random is not more than 64 bytes
- 		CryptoPP::HMAC<CryptoPP::SHA256> hmac (secret, 48);	
-		uint8_t seed[96]; size_t seedLen;
-		seedLen = strlen (label);	
-		memcpy (seed, label, seedLen);
-		memcpy (seed + seedLen, random, randomLen);
-		seedLen += randomLen;
-
-		size_t offset = 0;
-		uint8_t a[128];
-		hmac.CalculateDigest (a, seed, seedLen);
-		while (offset < len)
-		{
-			memcpy (a + 32, seed, seedLen);
-			hmac.CalculateDigest (buf + offset, a, seedLen + 32);
-			offset += 32;
-			hmac.CalculateDigest (a, a, 32);
-		}
-	}
-
-	size_t TlsSession::Encrypt (const uint8_t * in, size_t len, const uint8_t * mac, uint8_t * out)
-	{
-		size_t size = 0;
-		m_Rnd.GenerateBlock (out, 16); // iv
-		size += 16;
-		m_Encryption.SetIV (out);
-		memcpy (out + size, in, len);
-		size += len;
-		memcpy (out + size, mac, 32);
-		size += 32;	
-		uint8_t paddingSize = len + 1;
-		paddingSize &= 0x0F;  // %16
-		if (paddingSize > 0) paddingSize = 16 - paddingSize;
-		memset (out + size, paddingSize, paddingSize + 1); // paddind and last byte are equal to padding size
-		size += paddingSize + 1;
-		m_Encryption.Encrypt (out + 16, size - 16, out + 16);
-		return size;	
-	}
-
-	size_t TlsSession::Decrypt (uint8_t * buf, size_t len)
-	{
-		m_Decryption.SetIV (buf);
-		m_Decryption.Decrypt (buf + 16, len - 16, buf + 16);
-		return len - 48 - buf[len -1] - 1; // IV(16), mac(32) and padding
-	}
-
-	void TlsSession::CalculateMAC (uint8_t type, const uint8_t * buf, size_t len, uint8_t * mac)
-	{
-		uint8_t header[13]; // seqn (8) + type (1) + version (2) + length (2)
-		htobe64buf (header, m_Seqn);
-		header[8] = type; header[9] = 3; header[10] = 3; // 3,3 means TLS 1.2 
-		htobe16buf (header + 11, len);
-		CryptoPP::HMAC<CryptoPP::SHA256> hmac (m_MacKey, 32);	
-		hmac.Update (header, 13);
-		hmac.Update (buf, len);
-		hmac.Final (mac);	
-		m_Seqn++;
-	}
-
-	CryptoPP::RSA::PublicKey TlsSession::ExtractPublicKey (const uint8_t * certificate, size_t len)
-	{
-		CryptoPP::ByteQueue queue;
-		queue.Put (certificate, len);	
-		queue.MessageEnd ();
-		// extract X.509
-		CryptoPP::BERSequenceDecoder x509Cert (queue);
-		CryptoPP::BERSequenceDecoder tbsCert (x509Cert);
-		// version
-		uint32_t ver;
-		CryptoPP::BERGeneralDecoder context (tbsCert, CryptoPP::CONTEXT_SPECIFIC | CryptoPP::CONSTRUCTED);
-		CryptoPP::BERDecodeUnsigned<uint32_t>(context, ver, CryptoPP::INTEGER);
-		// serial
-		CryptoPP::Integer serial;
-   		serial.BERDecode(tbsCert);	
-		// signature
-		CryptoPP::BERSequenceDecoder signature (tbsCert);
-   		signature.SkipAll();
-		// issuer
-		CryptoPP::BERSequenceDecoder issuer (tbsCert);
-   		issuer.SkipAll();
-		// validity
-		CryptoPP::BERSequenceDecoder validity (tbsCert);
-   		validity.SkipAll();
-		// subject
-		CryptoPP::BERSequenceDecoder subject (tbsCert);
-   		subject.SkipAll();
-		// public key
-		CryptoPP::BERSequenceDecoder publicKey (tbsCert);			
-		CryptoPP::BERSequenceDecoder ident (publicKey);
-		ident.SkipAll ();
-		CryptoPP::BERGeneralDecoder key (publicKey, CryptoPP::BIT_STRING);
-		key.Skip (1); // FIXME: probably bug in crypto++
-		CryptoPP::BERSequenceDecoder keyPair (key);
-		CryptoPP::Integer n, e;
-		n.BERDecode (keyPair);
-		e.BERDecode (keyPair);
-
-		CryptoPP::RSA::PublicKey ret; 
-		ret.Initialize (n, e);
-		return ret;
-	}		
-
-	void TlsSession::Send (const uint8_t * buf, size_t len)
-	{
-		uint8_t * out = new uint8_t[len + 64 + 5]; // 64 = 32 mac + 16 iv + upto 16 padding, 5 = header
-		out[0] = 0x17; // application data
-		out[1] = 0x03; out[2] = 0x03; // version
-		uint8_t mac[32];
-		CalculateMAC (0x17, buf, len, mac);
-		size_t encryptedLen = Encrypt (buf, len, mac, out + 5);
-		htobe16buf (out + 3, encryptedLen);
-		m_Site.write ((char *)out, encryptedLen + 5);
-		delete[] out;
-	}
-
-	bool TlsSession::Receive (std::ostream& rs)
-	{
-		if (m_Site.eof ()) return false;
-		uint8_t type; uint16_t version, length;
-		m_Site.read ((char *)&type, 1); 
-		m_Site.read ((char *)&version, 2); 
-		m_Site.read ((char *)&length, 2); 
-		length = be16toh (length);
-		uint8_t * buf = new uint8_t[length];
-		m_Site.read ((char *)buf, length);
-		size_t decryptedLen = Decrypt (buf, length);
-		rs.write ((char *)buf + 16, decryptedLen);
-		delete[] buf;
-		return true;
-	}
-}
-}
-

Reseed.h

@@ -1,82 +0,0 @@
-#ifndef RESEED_H
-#define RESEED_H
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <map>
-#include <cryptopp/osrng.h>
-#include <cryptopp/rsa.h>
-#include <boost/asio.hpp>
-#include "Identity.h"
-#include "aes.h"
-
-namespace i2p
-{
-namespace data
-{
-
-	class Reseeder
-	{
-		typedef Tag<512> PublicKey;	
-		
-		public:
-		
-			Reseeder();
-			~Reseeder();
-			bool reseedNow(); // depreacted
-			int ReseedNowSU3 ();
-
-			void LoadCertificates ();
-			
-		private:
-
-			void LoadCertificate (const std::string& filename);
-			std::string LoadCertificate (CryptoPP::ByteQueue& queue); // returns issuer's name
-			
-			int ReseedFromSU3 (const std::string& host, bool https = false);
-			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;
-	};
-
-	class TlsSession
-	{
-		public:
-
-			TlsSession (const std::string& host, int port);
-			void Send (const uint8_t * buf, size_t len);
-			bool Receive (std::ostream& rs);
-
-		private:
-
-			void Handshake ();
-			void SendHandshakeMsg (uint8_t handshakeType, uint8_t * data, size_t len);
-			CryptoPP::RSA::PublicKey ExtractPublicKey (const uint8_t * certificate, size_t len);
-			void PRF (const uint8_t * secret, const char * label, const uint8_t * random, size_t randomLen,
-				size_t len, uint8_t * buf);
-			void CalculateMAC (uint8_t type, const uint8_t * buf, size_t len, uint8_t * mac);
-			size_t Encrypt (const uint8_t * in, size_t len, const uint8_t * mac, uint8_t * out);
-			size_t Decrypt (uint8_t * buf, size_t len); // pyaload is buf + 16		
-
-		private:
-
-			uint64_t m_Seqn;
-			boost::asio::ip::tcp::iostream m_Site;
-			CryptoPP::SHA256 m_FinishedHash;
-			CryptoPP::AutoSeededRandomPool m_Rnd;
-			i2p::crypto::CBCEncryption m_Encryption;
-			i2p::crypto::CBCDecryption m_Decryption; 
-			uint8_t m_MacKey[32]; // client	
-	};
-}
-}
-
-#endif

RouterContext.cpp

@@ -1,301 +0,0 @@
-#include <fstream>
-#include <cryptopp/dh.h>
-#include <cryptopp/dsa.h>
-#include <boost/lexical_cast.hpp>
-#include "CryptoConst.h"
-#include "RouterContext.h"
-#include "Timestamp.h"
-#include "I2NPProtocol.h"
-#include "NetDb.h"
-#include "util.h"
-#include "version.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 ()
-	{
-		m_StartupTime = i2p::util::GetSecondsSinceEpoch ();
-		if (!Load ())
-			CreateNewRouter ();
-		UpdateRouterInfo ();
-	}
-
-	void RouterContext::CreateNewRouter ()
-	{
-		m_Keys = i2p::data::CreateRandomKeys ();
-		SaveKeys ();
-		NewRouterInfo ();
-	}
-
-	void RouterContext::NewRouterInfo ()
-	{
-		i2p::data::RouterInfo routerInfo;
-		routerInfo.SetRouterIdentity (GetIdentity ());
-		int port = i2p::util::config::GetArg("-port", 0);
-		if (!port)
-			port = m_Rnd.GenerateWord32 (9111, 30777); // I2P network ports range
-		routerInfo.AddSSUAddress (i2p::util::config::GetCharArg("-host", "127.0.0.1"), port, routerInfo.GetIdentHash ());
-		routerInfo.AddNTCPAddress (i2p::util::config::GetCharArg("-host", "127.0.0.1"), port);
-		routerInfo.SetCaps (i2p::data::RouterInfo::eReachable | 
-			i2p::data::RouterInfo::eSSUTesting | i2p::data::RouterInfo::eSSUIntroducer); // LR, BC
-		routerInfo.SetProperty ("coreVersion", I2P_VERSION);
-		routerInfo.SetProperty ("netId", "2");
-		routerInfo.SetProperty ("router.version", I2P_VERSION);
-		routerInfo.SetProperty ("stat_uptime", "90m");
-		routerInfo.CreateBuffer (m_Keys);
-		m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
-	}
-
-	void RouterContext::UpdateRouterInfo ()
-	{
-		m_RouterInfo.CreateBuffer (m_Keys);
-		m_RouterInfo.SaveToFile (i2p::util::filesystem::GetFullPath (ROUTER_INFO));
-		m_LastUpdateTime = i2p::util::GetSecondsSinceEpoch ();
-	}	
-
-	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& routerInfo, uint32_t tag)
-	{
-		bool ret = false;
-		auto address = routerInfo.GetSSUAddress ();
-		if (address)
-		{	
-			ret = m_RouterInfo.AddIntroducer (address, tag);
-			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 (ROUTER_INFO_PROPERTY_LEASESETS);
-			m_RouterInfo.DeleteProperty (ROUTER_INFO_PROPERTY_ROUTERS);
-		}
-		UpdateRouterInfo ();
-	}
-
-	void RouterContext::SetHighBandwidth ()
-	{
-		if (!m_RouterInfo.IsHighBandwidth ())
-		{
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () | i2p::data::RouterInfo::eHighBandwidth);
-			UpdateRouterInfo ();
-		}
-	}
-
-	void RouterContext::SetLowBandwidth ()
-	{
-		if (m_RouterInfo.IsHighBandwidth ())
-		{
-			m_RouterInfo.SetCaps (m_RouterInfo.GetCaps () & ~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 form 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 ("Our v6 MTU=", mtu);
-				if (mtu > 1472) mtu = 1472; 
-			}	
-			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 (ROUTER_INFO_PROPERTY_LEASESETS, boost::lexical_cast<std::string>(i2p::data::netdb.GetNumLeaseSets ()));
-			m_RouterInfo.SetProperty (ROUTER_INFO_PROPERTY_ROUTERS, boost::lexical_cast<std::string>(i2p::data::netdb.GetNumRouters ()));
-			UpdateRouterInfo (); 
-		}
-	}
-		
-	bool RouterContext::Load ()
-	{
-		std::ifstream fk (i2p::util::filesystem::GetFullPath (ROUTER_KEYS).c_str (), std::ifstream::binary | std::ofstream::in);
-		if (!fk.is_open ())	return false;
-		
-		i2p::data::Keys keys;	
-		fk.read ((char *)&keys, sizeof (keys));
-		m_Keys = keys;
-
-		i2p::data::RouterInfo routerInfo(i2p::util::filesystem::GetFullPath (ROUTER_INFO)); // TODO
-		m_RouterInfo.Update (routerInfo.GetBuffer (), routerInfo.GetBufferLen ());
-		m_RouterInfo.SetProperty ("coreVersion", I2P_VERSION);
-		m_RouterInfo.SetProperty ("router.version", I2P_VERSION);
-
-		if (IsUnreachable ())
-			SetReachable (); // we assume reachable until we discover firewall through peer tests
-		
-		return true;
-	}
-
-	void RouterContext::SaveKeys ()
-	{	
-		std::ofstream fk (i2p::util::filesystem::GetFullPath (ROUTER_KEYS).c_str (), std::ofstream::binary | std::ofstream::out);
-		i2p::data::Keys keys;
-		memcpy (keys.privateKey, m_Keys.GetPrivateKey (), sizeof (keys.privateKey));
-		memcpy (keys.signingPrivateKey, m_Keys.GetSigningPrivateKey (), sizeof (keys.signingPrivateKey));
-		auto& ident = GetIdentity ().GetStandardIdentity ();	
-		memcpy (keys.publicKey, ident.publicKey, sizeof (keys.publicKey));
-		memcpy (keys.signingKey, ident.signingKey, sizeof (keys.signingKey));
-		fk.write ((char *)&keys, sizeof (keys));	
-	}
-
-	void RouterContext::HandleI2NPMessage (const uint8_t * buf, size_t len, std::shared_ptr<i2p::tunnel::InboundTunnel> from)
-	{
-		i2p::HandleI2NPMessage (CreateI2NPMessage (buf, GetI2NPMessageLength (buf), from));
-	}
-
-	uint32_t RouterContext::GetUptime () const
-	{
-		return i2p::util::GetSecondsSinceEpoch () - m_StartupTime;
-	}	
-}

RouterInfo.cpp

@@ -1,663 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include "I2PEndian.h"
-#include <fstream>
-#include <boost/lexical_cast.hpp>
-#include <cryptopp/sha.h>
-#include <cryptopp/dsa.h>
-#include "CryptoConst.h"
-#include "base64.h"
-#include "Timestamp.h"
-#include "Log.h"
-#include "RouterInfo.h"
-#include "RouterContext.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)
-	{
-		if (!m_Buffer)	
-			m_Buffer = new uint8_t[MAX_RI_BUFFER_SIZE];
-		m_IsUpdated = true;
-		m_IsUnreachable = false;
-		m_SupportedTransports = 0;
-		m_Caps = 0;
-		m_Addresses.clear ();
-		m_Properties.clear ();
-		memcpy (m_Buffer, buf, len);
-		m_BufferLen = len;
-		ReadFromBuffer (true);
-		// don't delete buffer until save to file
-	}	
-		
-	void RouterInfo::SetRouterIdentity (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)
-			{
-				LogPrint(eLogError, "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, "Can't open file ", m_FullPath);
-			return false;		
-		}
-		return true;
-	}	
-
-	void RouterInfo::ReadFromFile ()
-	{
-		if (LoadFile ())
-			ReadFromBuffer (false); 
-	}	
-
-	void RouterInfo::ReadFromBuffer (bool verifySignature)
-	{
-		size_t identityLen = m_RouterIdentity.FromBuffer (m_Buffer, m_BufferLen);
-		std::stringstream str (std::string ((char *)m_Buffer + identityLen, m_BufferLen - identityLen));
-		ReadFromStream (str);
-		if (verifySignature)
-		{	
-			// verify signature
-			int l = m_BufferLen - m_RouterIdentity.GetSignatureLen ();
-			if (!m_RouterIdentity.Verify ((uint8_t *)m_Buffer, l, (uint8_t *)m_Buffer + l))
-			{	
-				LogPrint (eLogError, "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));
-		bool introducers = false;
-		for (int i = 0; i < numAddresses; i++)
-		{
-			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));
-			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)
-						{
-							m_SupportedTransports |= eNTCPV4; // TODO:
-							address.addressString = value;
-						}
-						else
-						{	
-							// TODO: resolve address for SSU
-							LogPrint (eLogWarning, "Unexpected SSU address ", value);
-							isValidAddress = false;
-						}	
-					}	
-					else
-					{
-						// add supported protocol
-						if (address.host.is_v4 ())
-							m_SupportedTransports |= (address.transportStyle == eTransportNTCP) ? eNTCPV4 : eSSUV4;	
-						else
-							m_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 (isValidAddress)
-				m_Addresses.push_back(address);
-		}	
-		// read peers
-		uint8_t numPeers;
-		s.read ((char *)&numPeers, sizeof (numPeers));
-		s.seekg (numPeers*32, std::ios_base::cur); // TODO: read peers
-		// read properties
-		uint16_t size, r = 0;
-		s.read ((char *)&size, sizeof (size));
-		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);
-		}		
-
-		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_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) 
-		{
-			caps += CAPS_FLAG_HIGH_BANDWIDTH3; // highest bandwidth
-			caps += CAPS_FLAG_FLOODFILL; // floodfill  
-		}	
-		else
-			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 ());
-	}	
-
-	const uint8_t * RouterInfo::LoadBuffer ()
-	{
-		if (!m_Buffer)
-		{
-			if (LoadFile ())
-				LogPrint ("Buffer for ", GetIdentHashAbbreviation (), " 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);
-			f.write ((char *)m_Buffer, m_BufferLen);
-		}	
-		else
-			LogPrint (eLogError, "Can't save to file");
-	}
-	
-	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;
-		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);
-		m_Addresses.push_back(addr);	
-		m_SupportedTransports |= addr.host.is_v6 () ? eNTCPV6 : eSSUV4;
-		m_Caps |= eSSUTesting; 
-		m_Caps |= eSSUIntroducer; 
-	}	
-
-	bool RouterInfo::AddIntroducer (const Address * address, uint32_t tag)
-	{
-		for (auto& addr : m_Addresses)
-		{
-			if (addr.transportStyle == eTransportSSU && addr.host.is_v4 ())
-			{	
-				for (auto intro: addr.introducers)
-					if (intro.iTag == tag) return false; // already presented
-				Introducer x;
-				x.iHost = address->host;
-				x.iPort = address->port;
-				x.iTag = tag;
-				memcpy (x.iKey, address->key, 32); // TODO: replace to Tag<32>
-				addr.introducers.push_back (x);
-				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::IsFloodfill () const
-	{
-		return m_Caps & Caps::eFloodfill;
-	}	
-
-	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;
-	}	
-}
-}

SSU.cpp

@@ -1,547 +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: ", ex.what ());
-			}	
-		}	
-	}
-
-	void SSUServer::RunV6 () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_ServiceV6.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU V6 server: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void SSUServer::RunReceivers () 
-	{ 
-		while (m_IsRunning)
-		{
-			try
-			{	
-				m_ReceiversService.run ();
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint (eLogError, "SSU receivers: ", 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));
-			Receive ();
-		}
-		else
-		{	
-			LogPrint ("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));
-			ReceiveV6 ();
-		}
-		else
-		{	
-			LogPrint ("SSU V6 receive error: ", ecode.message ());
-			delete packet;
-		}	
-	}
-
-	void SSUServer::HandleReceivedPackets (std::vector<SSUPacket *> packets)
-	{
-		std::shared_ptr<SSUSession> session;	
-		for (auto it1: packets)
-		{
-			auto packet = it1;
-			if (!session || session->GetRemoteEndpoint () != packet->from) // we received packet for other session than previous
-			{
-				if (session) session->FlushData ();
-				auto it = m_Sessions.find (packet->from);
-				if (it != m_Sessions.end ())
-					session = it->second;
-				if (!session)
-				{
-					session = std::make_shared<SSUSession> (*this, packet->from);
-					session->WaitForConnect ();
-					{
-						std::unique_lock<std::mutex> l(m_SessionsMutex);
-						m_Sessions[packet->from] = session;
-					}	
-					LogPrint ("New SSU session from ", packet->from.address ().to_string (), ":", packet->from.port (), " created");
-				}
-			}
-			session->ProcessNextMessage (packet->buf, packet->len, packet->from);
-			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 it = m_Sessions.find (e);
-		if (it != m_Sessions.end ())
-			return it->second;
-		else
-			return nullptr;
-	}
-		
-	std::shared_ptr<SSUSession> SSUServer::GetSession (std::shared_ptr<const i2p::data::RouterInfo> router, bool peerTest)
-	{
-		std::shared_ptr<SSUSession> session;
-		if (router)
-		{
-			auto address = router->GetSSUAddress (!context.SupportsV6 ());
-			if (address)
-			{
-				boost::asio::ip::udp::endpoint remoteEndpoint (address->host, address->port);
-				auto it = m_Sessions.find (remoteEndpoint);
-				if (it != m_Sessions.end ())
-					session = it->second;
-				else
-				{
-					// otherwise create new session					
-					session = std::make_shared<SSUSession> (*this, remoteEndpoint, router, peerTest);
-					{
-						std::unique_lock<std::mutex> l(m_SessionsMutex);
-						m_Sessions[remoteEndpoint] = session;
-					}
-					if (!router->UsesIntroducer ())
-					{
-						// connect directly						
-						LogPrint ("Creating new SSU session to [", router->GetIdentHashAbbreviation (), "] ",
-							remoteEndpoint.address ().to_string (), ":", remoteEndpoint.port ());
-						session->Connect ();
-					}
-					else
-					{
-						// connect through introducer
-						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++)
-							{
-								introducer = &(address->introducers[i]);
-								it = m_Sessions.find (boost::asio::ip::udp::endpoint (introducer->iHost, introducer->iPort));
-								if (it != m_Sessions.end ())
-								{
-									introducerSession = it->second;
-									break; 
-								}	
-							}
-
-							if (introducerSession) // session found 
-								LogPrint ("Session to introducer already exists");
-							else // create new
-							{
-								LogPrint ("Creating new session to introducer");
-								introducer = &(address->introducers[0]); // TODO:
-								boost::asio::ip::udp::endpoint introducerEndpoint (introducer->iHost, introducer->iPort);
-								introducerSession = std::make_shared<SSUSession> (*this, introducerEndpoint, router);
-								std::unique_lock<std::mutex> l(m_SessionsMutex);
-								m_Sessions[introducerEndpoint] = introducerSession;													
-							}	
-							// introduce
-							LogPrint ("Introduce new SSU session to [", router->GetIdentHashAbbreviation (), 
-									"] 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->iTag, introducer->iKey);
-						}
-						else
-						{	
-							LogPrint (eLogWarning, "Can't connect to unreachable router. No introducers presented");
-							std::unique_lock<std::mutex> l(m_SessionsMutex);
-							m_Sessions.erase (remoteEndpoint);
-							session.reset ();
-						}	
-					}
-				}
-			}
-			else
-				LogPrint (eLogWarning, "Router ", router->GetIdentHashAbbreviation (), " doesn't have SSU address");
-		}
-		return session;
-	}
-
-	void SSUServer::DeleteSession (std::shared_ptr<SSUSession> session)
-	{
-		if (session)
-		{
-			session->Close ();
-			std::unique_lock<std::mutex> l(m_SessionsMutex);	
-			m_Sessions.erase (session->GetRemoteEndpoint ());
-		}	
-	}	
-
-	void SSUServer::DeleteAllSessions ()
-	{
-		std::unique_lock<std::mutex> l(m_SessionsMutex);
-		for (auto it: m_Sessions)
-			it.second->Close ();
-		m_Sessions.clear ();
-	}
-
-	template<typename Filter>
-	std::shared_ptr<SSUSession> SSUServer::GetRandomSession (Filter filter)
-	{
-		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 = i2p::context.GetRandomNumberGenerator ().GenerateWord32 (0, filteredSessions.size ()-1);
-			return filteredSessions[ind];
-		}
-		return nullptr;	
-	}
-
-	std::shared_ptr<SSUSession> SSUServer::GetRandomEstablishedSession (std::shared_ptr<const SSUSession> excluded)
-	{
-		return GetRandomSession (
-			[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 = GetRandomSession (
-				[&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 router = it1->GetRemoteRouter ();
-						if (router && i2p::context.AddIntroducer (*router, it1->GetRelayTag ()))
-						{	
-							newList.push_back (it1->GetRemoteEndpoint ());
-							if (newList.size () >= SSU_MAX_NUM_INTRODUCERS) break;
-						}	
-					}	
-				}	
-			}	
-			m_Introducers = newList;
-			if (m_Introducers.empty ())
-			{
-				auto introducer = i2p::data::netdb.GetRandomIntroducer ();
-				if (introducer)
-					GetSession (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 (eLogInfo, numDeleted, " peer tests have been expired");
-			SchedulePeerTestsCleanupTimer ();
-		}
-	}
-}
-}
-

Signature.h

@@ -1,417 +0,0 @@
-#ifndef SIGNATURE_H__
-#define SIGNATURE_H__
-
-#include <inttypes.h>
-#include <cryptopp/dsa.h>
-#include <cryptopp/rsa.h>
-#include <cryptopp/asn.h>
-#include <cryptopp/oids.h>
-#include <cryptopp/osrng.h>
-#include <cryptopp/eccrypto.h>
-#include "CryptoConst.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 (CryptoPP::RandomNumberGenerator& rnd, 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.Initialize (dsap, dsaq, dsag, CryptoPP::Integer (signingKey, DSA_PUBLIC_KEY_LENGTH));
-			}
-	
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const
-			{
-				CryptoPP::DSA::Verifier verifier (m_PublicKey);
-				return verifier.VerifyMessage (buf, len, signature, DSA_SIGNATURE_LENGTH);
-			}	
-
-			size_t GetPublicKeyLen () const { return DSA_PUBLIC_KEY_LENGTH; };
-			size_t GetSignatureLen () const { return DSA_SIGNATURE_LENGTH; };
-			
-		private:
-
-			CryptoPP::DSA::PublicKey m_PublicKey;
-	};
-
-	class DSASigner: public Signer
-	{
-		public:
-
-			DSASigner (const uint8_t * signingPrivateKey)
-			{
-				m_PrivateKey.Initialize (dsap, dsaq, dsag, CryptoPP::Integer (signingPrivateKey, DSA_PRIVATE_KEY_LENGTH));
-			}
-
-			void Sign (CryptoPP::RandomNumberGenerator& rnd, const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				CryptoPP::DSA::Signer signer (m_PrivateKey);
-				signer.SignMessage (rnd, buf, len, signature);
-			}
-
-		private:
-
-			CryptoPP::DSA::PrivateKey m_PrivateKey;
-	};
-
-	inline void CreateDSARandomKeys (CryptoPP::RandomNumberGenerator& rnd, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CryptoPP::DSA::PrivateKey privateKey;
-		CryptoPP::DSA::PublicKey publicKey;
-		privateKey.Initialize (rnd, dsap, dsaq, dsag);
-		privateKey.MakePublicKey (publicKey);
-		privateKey.GetPrivateExponent ().Encode (signingPrivateKey, DSA_PRIVATE_KEY_LENGTH);	
-		publicKey.GetPublicElement ().Encode (signingPublicKey, DSA_PUBLIC_KEY_LENGTH);
-	}	
-
-	template<typename Hash, size_t keyLen>
-	class ECDSAVerifier: public Verifier
-	{		
-		public:
-
-			template<typename Curve>
-			ECDSAVerifier (Curve curve, const uint8_t * signingKey)
-			{
-				m_PublicKey.Initialize (curve, 
-					CryptoPP::ECP::Point (CryptoPP::Integer (signingKey, keyLen/2), 
-					CryptoPP::Integer (signingKey + keyLen/2, keyLen/2)));
-			}
-
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const
-			{
-				typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::Verifier verifier (m_PublicKey);
-				return verifier.VerifyMessage (buf, len, signature, keyLen); // signature length
-			}	
-
-			size_t GetPublicKeyLen () const { return keyLen; };
-			size_t GetSignatureLen () const { return keyLen; }; // signature length = key length
-			
-		private:
-
-			typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::PublicKey m_PublicKey;
-	};
-
-	template<typename Hash>
-	class ECDSASigner: public Signer
-	{
-		public:
-
-			template<typename Curve>
-			ECDSASigner (Curve curve, const uint8_t * signingPrivateKey, size_t keyLen)
-			{
-				m_PrivateKey.Initialize (curve, CryptoPP::Integer (signingPrivateKey, keyLen/2)); // private key length
-			}
-
-			void Sign (CryptoPP::RandomNumberGenerator& rnd, const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::Signer signer (m_PrivateKey);
-				signer.SignMessage (rnd, buf, len, signature);
-			}
-
-		private:
-
-			typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::PrivateKey m_PrivateKey;
-	};
-
-	template<typename Hash, typename Curve>
-	inline void CreateECDSARandomKeys (CryptoPP::RandomNumberGenerator& rnd, Curve curve, 
-		size_t keyLen, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::PrivateKey privateKey;
-		typename CryptoPP::ECDSA<CryptoPP::ECP, Hash>::PublicKey publicKey;
-		privateKey.Initialize (rnd, curve);
-		privateKey.MakePublicKey (publicKey);
-		privateKey.GetPrivateExponent ().Encode (signingPrivateKey, keyLen/2);	
-		auto q = publicKey.GetPublicElement ();
-		q.x.Encode (signingPublicKey, keyLen/2);
-		q.y.Encode (signingPublicKey + keyLen/2, keyLen/2);
-	}	
-
-// ECDSA_SHA256_P256
-	const size_t ECDSAP256_KEY_LENGTH = 64;	
-	class ECDSAP256Verifier: public ECDSAVerifier<CryptoPP::SHA256, ECDSAP256_KEY_LENGTH>
-	{
-		public:
-
-			ECDSAP256Verifier (const uint8_t * signingKey): 
-				ECDSAVerifier (CryptoPP::ASN1::secp256r1(), signingKey)
-			{
-			}			
-	};	
-
-	class ECDSAP256Signer: public ECDSASigner<CryptoPP::SHA256>
-	{
-		public:
-
-			ECDSAP256Signer (const uint8_t * signingPrivateKey):
-				ECDSASigner (CryptoPP::ASN1::secp256r1(), signingPrivateKey, ECDSAP256_KEY_LENGTH)
-			{
-			}
-	};
-
-	inline void CreateECDSAP256RandomKeys (CryptoPP::RandomNumberGenerator& rnd, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys<CryptoPP::SHA256> (rnd, CryptoPP::ASN1::secp256r1(), ECDSAP256_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}	
-
-// ECDSA_SHA384_P384
-	const size_t ECDSAP384_KEY_LENGTH = 96;
-	class ECDSAP384Verifier: public ECDSAVerifier<CryptoPP::SHA384, ECDSAP384_KEY_LENGTH>
-	{
-		public:
-
-			ECDSAP384Verifier (const uint8_t * signingKey): 
-				ECDSAVerifier (CryptoPP::ASN1::secp384r1(), signingKey)
-			{
-			}			
-	};	
-
-	class ECDSAP384Signer: public ECDSASigner<CryptoPP::SHA384>
-	{
-		public:
-
-			ECDSAP384Signer (const uint8_t * signingPrivateKey):
-				ECDSASigner (CryptoPP::ASN1::secp384r1(), signingPrivateKey, ECDSAP384_KEY_LENGTH)
-			{
-			}
-	};
-
-	inline void CreateECDSAP384RandomKeys (CryptoPP::RandomNumberGenerator& rnd, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys<CryptoPP::SHA384> (rnd, CryptoPP::ASN1::secp384r1(), ECDSAP384_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}	
-
-// ECDSA_SHA512_P521
-	const size_t ECDSAP521_KEY_LENGTH = 132;
-	class ECDSAP521Verifier: public ECDSAVerifier<CryptoPP::SHA512, ECDSAP521_KEY_LENGTH>
-	{
-		public:
-
-			ECDSAP521Verifier (const uint8_t * signingKey): 
-				ECDSAVerifier (CryptoPP::ASN1::secp521r1(), signingKey)
-			{
-			}			
-	};	
-
-	class ECDSAP521Signer: public ECDSASigner<CryptoPP::SHA512>
-	{
-		public:
-
-			ECDSAP521Signer (const uint8_t * signingPrivateKey):
-				ECDSASigner (CryptoPP::ASN1::secp521r1(), signingPrivateKey, ECDSAP521_KEY_LENGTH)
-			{
-			}
-	};
-
-	inline void CreateECDSAP521RandomKeys (CryptoPP::RandomNumberGenerator& rnd, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CreateECDSARandomKeys<CryptoPP::SHA512> (rnd, CryptoPP::ASN1::secp521r1(), ECDSAP521_KEY_LENGTH, signingPrivateKey, signingPublicKey);
-	}
-
-// RSA
-	template<typename Hash, size_t keyLen>	
-	class RSAVerifier: public Verifier
-	{
-		public:
-
-			RSAVerifier (const uint8_t * signingKey)
-			{
-				m_PublicKey.Initialize (CryptoPP::Integer (signingKey, keyLen), CryptoPP::Integer (rsae));
-			}
-
-			bool Verify (const uint8_t * buf, size_t len, const uint8_t * signature) const 
-			{
-				typename CryptoPP::RSASS<CryptoPP::PKCS1v15, Hash>::Verifier verifier (m_PublicKey);
-				return verifier.VerifyMessage (buf, len, signature, keyLen); // signature length
-			}
-			size_t GetPublicKeyLen () const { return keyLen; }
-			size_t GetSignatureLen () const { return keyLen; }	
-			size_t GetPrivateKeyLen () const { return GetSignatureLen ()*2; };
-
-		private:
-			
-			CryptoPP::RSA::PublicKey m_PublicKey;			
-	};	
-
-	
-	template<typename Hash>
-	class RSASigner: public Signer
-	{
-		public:
-
-			RSASigner (const uint8_t * signingPrivateKey, size_t keyLen)
-			{
-				m_PrivateKey.Initialize (CryptoPP::Integer (signingPrivateKey, keyLen/2),
-				    rsae,                 			
-					CryptoPP::Integer (signingPrivateKey + keyLen/2, keyLen/2));
-			}
-
-			void Sign (CryptoPP::RandomNumberGenerator& rnd, const uint8_t * buf, int len, uint8_t * signature) const
-			{
-				typename CryptoPP::RSASS<CryptoPP::PKCS1v15, Hash>::Signer signer (m_PrivateKey);
-				signer.SignMessage (rnd, buf, len, signature);
-			}
-			
-		private:
-
-			CryptoPP::RSA::PrivateKey m_PrivateKey;
-	};		
-
-	inline void CreateRSARandomKeys (CryptoPP::RandomNumberGenerator& rnd, 
-		size_t publicKeyLen, uint8_t * signingPrivateKey, uint8_t * signingPublicKey)
-	{
-		CryptoPP::RSA::PrivateKey privateKey;
-		privateKey.Initialize (rnd, publicKeyLen*8, rsae);
-		privateKey.GetModulus ().Encode (signingPrivateKey, publicKeyLen);	
-		privateKey.GetPrivateExponent ().Encode (signingPrivateKey + publicKeyLen, publicKeyLen);	
-		privateKey.GetModulus ().Encode (signingPublicKey, publicKeyLen);
-	}	
-
-	
-//  RSA_SHA256_2048
-	const size_t RSASHA2562048_KEY_LENGTH = 256;
-	class RSASHA2562048Verifier: public RSAVerifier<CryptoPP::SHA256, RSASHA2562048_KEY_LENGTH> 
-	{
-		public:
-
-			RSASHA2562048Verifier (const uint8_t * signingKey): RSAVerifier (signingKey) 
-			{
-			}
-	};
-
-	class RSASHA2562048Signer: public RSASigner<CryptoPP::SHA256> 
-	{
-		public:
-
-			RSASHA2562048Signer (const uint8_t * signingPrivateKey): 
-				RSASigner (signingPrivateKey, RSASHA2562048_KEY_LENGTH*2) 
-			{
-			}
-	};
-
-//  RSA_SHA384_3072
-	const size_t RSASHA3843072_KEY_LENGTH = 384;
-	class RSASHA3843072Verifier: public RSAVerifier<CryptoPP::SHA384, RSASHA3843072_KEY_LENGTH> 
-	{
-		public:
-
-			RSASHA3843072Verifier (const uint8_t * signingKey): RSAVerifier (signingKey) 
-			{
-			}
-	};
-
-	class RSASHA3843072Signer: public RSASigner<CryptoPP::SHA384> 
-	{
-		public:
-
-			RSASHA3843072Signer (const uint8_t * signingPrivateKey): 
-				RSASigner (signingPrivateKey, RSASHA3843072_KEY_LENGTH*2) 
-			{
-			}
-	};
-
-//  RSA_SHA512_4096
-	const size_t RSASHA5124096_KEY_LENGTH = 512;
-	class RSASHA5124096Verifier: public RSAVerifier<CryptoPP::SHA512, RSASHA5124096_KEY_LENGTH> 
-	{
-		public:
-
-			RSASHA5124096Verifier (const uint8_t * signingKey): RSAVerifier (signingKey) 
-			{
-			}
-	};
-
-	class RSASHA5124096Signer: public RSASigner<CryptoPP::SHA512> 
-	{
-		public:
-
-			RSASHA5124096Signer (const uint8_t * signingPrivateKey): 
-				RSASigner (signingPrivateKey, RSASHA5124096_KEY_LENGTH*2) 
-			{
-			}
-	};
-
-// Raw verifiers	
-	class RawVerifier
-	{
-		public:
-			
-			virtual ~RawVerifier () {};
-			virtual void Update (const uint8_t * buf, size_t len) = 0;
-			virtual bool Verify (const uint8_t * signature) = 0;
-	};		
-
-	template<typename Hash, size_t keyLen>
-	class RSARawVerifier: public RawVerifier
-	{
-		public:
-
-			RSARawVerifier (const uint8_t * signingKey):
-				n (signingKey, keyLen)
-			{
-			}
-
-			void Update (const uint8_t * buf, size_t len)
-			{
-				m_Hash.Update (buf, len);
-			}
-			
-			bool Verify (const uint8_t * signature)
-			{
-				// RSA encryption first
-				CryptoPP::Integer enSig (a_exp_b_mod_c (CryptoPP::Integer (signature, keyLen), 
-					CryptoPP::Integer (i2p::crypto::rsae), n)); // s^e mod n 
-				uint8_t enSigBuf[keyLen];
-				enSig.Encode (enSigBuf, keyLen);
-
-				uint8_t digest[Hash::DIGESTSIZE];
-				m_Hash.Final (digest);
-				if ((int)keyLen < Hash::DIGESTSIZE) return false; // can't verify digest longer than key
-				// we assume digest is right aligned, at least for PKCS#1 v1.5 padding 
-				return !memcmp (enSigBuf + (keyLen - Hash::DIGESTSIZE), digest, Hash::DIGESTSIZE); 				
-			}
-
-		private:
-
-			CryptoPP::Integer n; // RSA modulus	
-			Hash m_Hash;
-	};	
-
-	class RSASHA5124096RawVerifier: public RSARawVerifier<CryptoPP::SHA512, RSASHA5124096_KEY_LENGTH> 
-	{
-		public:
-
-			RSASHA5124096RawVerifier (const uint8_t * signingKey): RSARawVerifier (signingKey) 
-			{
-			}
-	};
-}
-}
-
-#endif
-

Streaming.cpp

@@ -1,857 +0,0 @@
-#include <cryptopp/gzip.h>
-#include "Log.h"
-#include "RouterInfo.h"
-#include "RouterContext.h"
-#include "Tunnel.h"
-#include "Timestamp.h"
-#include "Destination.h"
-#include "Streaming.h"
-
-namespace i2p
-{
-namespace stream
-{
-	Stream::Stream (boost::asio::io_service& service, StreamingDestination& local, 
-		std::shared_ptr<const i2p::data::LeaseSet> remote, int port): m_Service (service),
-		m_SendStreamID (0), m_SequenceNumber (0), m_LastReceivedSequenceNumber (-1), 
-		m_Status (eStreamStatusNew), m_IsAckSendScheduled (false), m_LocalDestination (local), 
-		m_RemoteLeaseSet (remote), m_ReceiveTimer (m_Service), m_ResendTimer (m_Service), 
-		m_AckSendTimer (m_Service),  m_NumSentBytes (0), m_NumReceivedBytes (0), m_Port (port), 
-		m_WindowSize (MIN_WINDOW_SIZE), m_RTT (INITIAL_RTT), m_RTO (INITIAL_RTO),
-		m_LastWindowSizeIncreaseTime (0), m_NumResendAttempts (0)
-	{
-		m_RecvStreamID = i2p::context.GetRandomNumberGenerator ().GenerateWord32 ();
-		m_RemoteIdentity = remote->GetIdentity ();
-		UpdateCurrentRemoteLease ();
-	}	
-
-	Stream::Stream (boost::asio::io_service& service, StreamingDestination& local):
-		m_Service (service), m_SendStreamID (0), m_SequenceNumber (0), m_LastReceivedSequenceNumber (-1), 
-		m_Status (eStreamStatusNew), m_IsAckSendScheduled (false), m_LocalDestination (local),
-		m_ReceiveTimer (m_Service), m_ResendTimer (m_Service), m_AckSendTimer (m_Service), 
-		m_NumSentBytes (0), m_NumReceivedBytes (0), m_Port (0),  m_WindowSize (MIN_WINDOW_SIZE), 
-		m_RTT (INITIAL_RTT), m_RTO (INITIAL_RTO), m_LastWindowSizeIncreaseTime (0), m_NumResendAttempts (0)
-	{
-		m_RecvStreamID = i2p::context.GetRandomNumberGenerator ().GenerateWord32 ();
-	}
-
-	Stream::~Stream ()
-	{	
-		Terminate ();
-		while (!m_ReceiveQueue.empty ())
-		{
-			auto packet = m_ReceiveQueue.front ();
-			m_ReceiveQueue.pop ();
-			delete packet;
-		}
-		
-		for (auto it: m_SentPackets)
-			delete it;
-		m_SentPackets.clear ();
-		
-		for (auto it: m_SavedPackets)
-			delete it;
-		m_SavedPackets.clear ();
-			
-		LogPrint (eLogDebug, "Stream deleted");
-	}	
-
-	void Stream::Terminate ()
-	{
-		m_AckSendTimer.cancel ();
-		m_ReceiveTimer.cancel ();
-		m_ResendTimer.cancel ();
-	}	
-		
-	void Stream::HandleNextPacket (Packet * packet)
-	{
-		m_NumReceivedBytes += packet->GetLength ();
-		if (!m_SendStreamID) 
-			m_SendStreamID = packet->GetReceiveStreamID (); 	
-
-		if (!packet->IsNoAck ()) // ack received
-			ProcessAck (packet);
-		
-		int32_t receivedSeqn = packet->GetSeqn ();
-		bool isSyn = packet->IsSYN ();
-		if (!receivedSeqn && !isSyn)
-		{
-			// plain ack
-			LogPrint (eLogDebug, "Plain ACK received");
-			delete packet;
-			return;
-		}
-
-		LogPrint (eLogDebug, "Received seqn=", receivedSeqn); 
-		if (isSyn || receivedSeqn == m_LastReceivedSequenceNumber + 1)
-		{			
-			// we have received next in sequence message
-			ProcessPacket (packet);
-			
-			// we should also try stored messages if any
-			for (auto it = m_SavedPackets.begin (); it != m_SavedPackets.end ();)
-			{			
-				if ((*it)->GetSeqn () == (uint32_t)(m_LastReceivedSequenceNumber + 1))
-				{
-					Packet * savedPacket = *it;
-					m_SavedPackets.erase (it++);
-
-					ProcessPacket (savedPacket);
-				}
-				else
-					break;
-			}
-
-			// schedule ack for last message
-			if (m_Status == eStreamStatusOpen)
-			{
-				if (!m_IsAckSendScheduled)
-				{
-					m_IsAckSendScheduled = true;
-					m_AckSendTimer.expires_from_now (boost::posix_time::milliseconds(ACK_SEND_TIMEOUT));
-					m_AckSendTimer.async_wait (std::bind (&Stream::HandleAckSendTimer,
-						shared_from_this (), std::placeholders::_1));
-				}
-			}	
-			else if (isSyn)
-				// we have to send SYN back to incoming connection
-				SendBuffer (); // also sets m_IsOpen				
-		}	
-		else 
-		{	
-			if (receivedSeqn <= m_LastReceivedSequenceNumber)
-			{
-				// we have received duplicate
-				LogPrint (eLogWarning, "Duplicate message ", receivedSeqn, " received");
-				SendQuickAck (); // resend ack for previous message again
-				delete packet; // packet dropped
-			}	
-			else
-			{
-				LogPrint (eLogWarning, "Missing messages from ", m_LastReceivedSequenceNumber + 1, " to ", receivedSeqn - 1);
-				// save message and wait for missing message again
-				SavePacket (packet);
-				if (m_LastReceivedSequenceNumber >= 0)
-				{	
-					// send NACKs for missing messages ASAP
-					if (m_IsAckSendScheduled)
-					{
-						m_IsAckSendScheduled = false;	
-						m_AckSendTimer.cancel ();
-					}
-					SendQuickAck ();
-				}	
-				else
-				{
-					// wait for SYN
-					m_IsAckSendScheduled = true;
-					m_AckSendTimer.expires_from_now (boost::posix_time::milliseconds(ACK_SEND_TIMEOUT));
-					m_AckSendTimer.async_wait (std::bind (&Stream::HandleAckSendTimer,
-						shared_from_this (), std::placeholders::_1));
-				}			
-			}	
-		}	
-	}	
-
-	void Stream::SavePacket (Packet * packet)
-	{
-		m_SavedPackets.insert (packet);
-	}	
-
-	void Stream::ProcessPacket (Packet * packet)
-	{
-		// process flags
-		uint32_t receivedSeqn = packet->GetSeqn ();
-		uint16_t flags = packet->GetFlags ();
-		LogPrint (eLogDebug, "Process seqn=", receivedSeqn, ", flags=", flags);
-		
-		const uint8_t * optionData = packet->GetOptionData ();
-		if (flags & PACKET_FLAG_SYNCHRONIZE)
-			LogPrint (eLogDebug, "Synchronize");
-
-		if (flags & PACKET_FLAG_DELAY_REQUESTED)
-		{
-			optionData += 2;
-		}	
-		
-		if (flags & PACKET_FLAG_FROM_INCLUDED)
-		{
-			optionData += m_RemoteIdentity.FromBuffer (optionData, packet->GetOptionSize ());
-			LogPrint (eLogInfo, "From identity ", m_RemoteIdentity.GetIdentHash ().ToBase64 ());		
-			if (!m_RemoteLeaseSet)
-				LogPrint (eLogDebug, "Incoming stream from ", m_RemoteIdentity.GetIdentHash ().ToBase64 ());
-		}	
-
-		if (flags & PACKET_FLAG_MAX_PACKET_SIZE_INCLUDED)
-		{
-			uint16_t maxPacketSize = bufbe16toh (optionData);
-			LogPrint (eLogDebug, "Max packet size ", maxPacketSize);
-			optionData += 2;
-		}	
-		
-		if (flags & PACKET_FLAG_SIGNATURE_INCLUDED)
-		{
-			LogPrint (eLogDebug, "Signature");
-			uint8_t signature[256]; 
-			auto signatureLen = m_RemoteIdentity.GetSignatureLen ();
-			memcpy (signature, optionData, signatureLen);
-			memset (const_cast<uint8_t *>(optionData), 0, signatureLen);
-			if (!m_RemoteIdentity.Verify (packet->GetBuffer (), packet->GetLength (), signature))
-			{  
-				LogPrint (eLogError, "Signature verification failed");
-			    Close ();
-				flags |= PACKET_FLAG_CLOSE;
-			}	
-			memcpy (const_cast<uint8_t *>(optionData), signature, signatureLen);
-			optionData += signatureLen;
-		}	
-
-		packet->offset = packet->GetPayload () - packet->buf;
-		if (packet->GetLength () > 0)
-		{	
-			m_ReceiveQueue.push (packet);
-			m_ReceiveTimer.cancel ();
-		}	
-		else
-			delete packet;
-		
-		m_LastReceivedSequenceNumber = receivedSeqn;
-
-		if (flags & PACKET_FLAG_CLOSE)
-		{
-			LogPrint (eLogInfo, "Closed");
-			m_Status = eStreamStatusReset;
-			Close ();
-		}
-	}	
-
-	void Stream::ProcessAck (Packet * packet)
-	{
-		bool acknowledged = false;
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		uint32_t ackThrough = packet->GetAckThrough ();
-		int nackCount = packet->GetNACKCount ();
-		for (auto it = m_SentPackets.begin (); it != m_SentPackets.end ();)
-		{			
-			auto seqn = (*it)->GetSeqn ();
-			if (seqn <= ackThrough)
-			{
-				if (nackCount > 0)
-				{
-					bool nacked = false;
-					for (int i = 0; i < nackCount; i++)
-						if (seqn == packet->GetNACK (i))
-						{
-							nacked = true;
-							break;
-						}
-					if (nacked)
-					{
-						LogPrint (eLogDebug, "Packet ", seqn, " NACK");
-						it++;
-						continue;
-					}	
-				}
-				auto sentPacket = *it;
-				uint64_t rtt = ts - sentPacket->sendTime;
-				m_RTT = (m_RTT*seqn + rtt)/(seqn + 1);
-				m_RTO = m_RTT*1.5; // TODO: implement it better
-				LogPrint (eLogDebug, "Packet ", seqn, " acknowledged rtt=", rtt);
-				m_SentPackets.erase (it++);
-				delete sentPacket;	
-				acknowledged = true;
-				if (m_WindowSize < WINDOW_SIZE)
-					m_WindowSize++; // slow start
-				else
-				{
-					// linear growth
-					if (ts > m_LastWindowSizeIncreaseTime + m_RTT)
-					{
-						m_WindowSize++;
-						if (m_WindowSize > MAX_WINDOW_SIZE) m_WindowSize = MAX_WINDOW_SIZE;
-						m_LastWindowSizeIncreaseTime = ts;
-					}
-				}
-			}
-			else
-				break;
-		}
-		if (m_SentPackets.empty ())
-			m_ResendTimer.cancel ();
-		if (acknowledged)
-		{
-			m_NumResendAttempts = 0;
-			SendBuffer ();
-		}	
-		if (m_Status == eStreamStatusClosing)
-			Close (); // all outgoing messages have been sent
-	}		
-		
-	size_t Stream::Send (const uint8_t * buf, size_t len)
-	{
-		if (len > 0 && buf)
-		{
-			std::unique_lock<std::mutex> l(m_SendBufferMutex);
-			m_SendBuffer.clear ();
-			m_SendBuffer.write ((const char *)buf, len);
-		}	
-		m_Service.post (std::bind (&Stream::SendBuffer, shared_from_this ()));
-		return len;
-	}	
-
-	void Stream::SendBuffer ()
-	{	
-		int numMsgs = m_WindowSize - m_SentPackets.size ();
-		if (numMsgs <= 0) return; // window is full 
-		
-		bool isNoAck = m_LastReceivedSequenceNumber < 0; // first packet
-		std::vector<Packet *> packets;
-		{
-			std::unique_lock<std::mutex> l(m_SendBufferMutex);
-			while ((m_Status == eStreamStatusNew) || (IsEstablished () && !m_SendBuffer.eof () && numMsgs > 0))
-			{
-				Packet * p = new Packet ();
-				uint8_t * packet = p->GetBuffer ();
-				// TODO: implement setters
-				size_t size = 0;
-				htobe32buf (packet + size, m_SendStreamID);
-				size += 4; // sendStreamID
-				htobe32buf (packet + size, m_RecvStreamID);
-				size += 4; // receiveStreamID
-				htobe32buf (packet + size, m_SequenceNumber++);
-				size += 4; // sequenceNum
-				if (isNoAck)			
-					htobe32buf (packet + size, m_LastReceivedSequenceNumber);
-				else
-					htobuf32 (packet + size, 0);
-				size += 4; // ack Through
-				packet[size] = 0; 
-				size++; // NACK count
-				packet[size] = m_RTO/1000;
-				size++; // resend delay
-				if (m_Status == eStreamStatusNew)
-				{	
-					//  initial packet
-					m_Status = eStreamStatusOpen;
-					uint16_t flags = PACKET_FLAG_SYNCHRONIZE | PACKET_FLAG_FROM_INCLUDED | 
-						PACKET_FLAG_SIGNATURE_INCLUDED | PACKET_FLAG_MAX_PACKET_SIZE_INCLUDED;
-					if (isNoAck) flags |= PACKET_FLAG_NO_ACK;
-					htobe16buf (packet + size, flags);
-					size += 2; // flags
-					size_t identityLen = m_LocalDestination.GetOwner ().GetIdentity ().GetFullLen ();
-					size_t signatureLen = m_LocalDestination.GetOwner ().GetIdentity ().GetSignatureLen ();
-					htobe16buf (packet + size, identityLen + signatureLen + 2); // identity + signature + packet size
-					size += 2; // options size
-					m_LocalDestination.GetOwner ().GetIdentity ().ToBuffer (packet + size, identityLen); 
-					size += identityLen; // from
-					htobe16buf (packet + size, STREAMING_MTU);
-					size += 2; // max packet size
-					uint8_t * signature = packet + size; // set it later
-					memset (signature, 0, signatureLen); // zeroes for now
-					size += signatureLen; // signature
-					m_SendBuffer.read ((char *)(packet + size), STREAMING_MTU - size);
-					size += m_SendBuffer.gcount (); // payload
-					m_LocalDestination.GetOwner ().Sign (packet, size, signature);
-				}	
-				else
-				{
-					// follow on packet
-					htobuf16 (packet + size, 0);
-					size += 2; // flags
-					htobuf16 (packet + size, 0); // no options
-					size += 2; // options size
-					m_SendBuffer.read((char *)(packet + size), STREAMING_MTU - size);  
-					size += m_SendBuffer.gcount (); // payload
-				}	
-				p->len = size;
-				packets.push_back (p);
-				numMsgs--;
-			}
-		}	
-		if (packets.size () > 0)
-		{
-			m_IsAckSendScheduled = false;	
-			m_AckSendTimer.cancel ();
-			bool isEmpty = m_SentPackets.empty ();
-			auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-			for (auto it: packets)
-			{
-				it->sendTime = ts;
-				m_SentPackets.insert (it);
-			}
-			SendPackets (packets);
-			if (m_Status == eStreamStatusClosing && m_SendBuffer.eof ())
-				SendClose ();
-			if (isEmpty)
-				ScheduleResend ();
-		}	
-	}
-		
-	void Stream::SendQuickAck ()
-	{
-		int32_t lastReceivedSeqn = m_LastReceivedSequenceNumber;
-		if (!m_SavedPackets.empty ())
-		{
-			int32_t seqn = (*m_SavedPackets.rbegin ())->GetSeqn ();
-			if (seqn > lastReceivedSeqn) lastReceivedSeqn = seqn;
-		}	
-		if (lastReceivedSeqn < 0) 
-		{	
-			LogPrint (eLogError, "No packets have been received yet");
-			return;
-		}
-		
-		Packet p;
-		uint8_t * packet = p.GetBuffer ();	
-		size_t size = 0;
-		htobe32buf (packet + size, m_SendStreamID);
-		size += 4; // sendStreamID
-		htobe32buf (packet + size, m_RecvStreamID);
-		size += 4; // receiveStreamID
-		htobuf32 (packet + size, 0); // this is plain Ack message
-		size += 4; // sequenceNum
-		htobe32buf (packet + size, lastReceivedSeqn);
-		size += 4; // ack Through
-		uint8_t numNacks = 0;
-		if (lastReceivedSeqn > m_LastReceivedSequenceNumber) 
-		{	
-			// fill NACKs
-			uint8_t * nacks = packet + size + 1;
-			auto nextSeqn = m_LastReceivedSequenceNumber + 1;
-			for (auto it: m_SavedPackets)
-			{
-				auto seqn = it->GetSeqn ();
-				if (numNacks + (seqn - nextSeqn) >= 256)
-				{
-					LogPrint (eLogError, "Number of NACKs exceeds 256. seqn=", seqn, " nextSeqn=", nextSeqn);
-					htobe32buf (packet + 12, nextSeqn); // change ack Through
-					break;
-				}	
-				for (uint32_t i = nextSeqn; i < seqn; i++)
-				{
-					htobe32buf (nacks, i);
-					nacks += 4;
-					numNacks++;
-				}	
-				nextSeqn = seqn + 1;
-			}
-			packet[size] = numNacks; 
-			size++; // NACK count	
-			size += numNacks*4; // NACKs
-		}	
-		else
-		{
-			// No NACKs
-			packet[size] = 0; 
-			size++; // NACK count		
-		}	
-		size++; // resend delay
-		htobuf16 (packet + size, 0); // nof flags set
-		size += 2; // flags
-		htobuf16 (packet + size, 0); // no options
-		size += 2; // options size
-		p.len = size;		
-
-		SendPackets (std::vector<Packet *> { &p });
-		LogPrint ("Quick Ack sent. ", (int)numNacks, " NACKs");
-	}	
-
-	void Stream::Close ()
-	{
-		switch (m_Status)
-		{
-			case eStreamStatusOpen:
-				m_Status = eStreamStatusClosing;
-				Close (); // recursion
-				if (m_Status == eStreamStatusClosing) //still closing
-					LogPrint (eLogInfo, "Trying to send stream data before closing");
-			break;
-			case eStreamStatusReset:
-				SendClose ();
-				Terminate ();
-				m_LocalDestination.DeleteStream (shared_from_this ());	
-			break;
-			case eStreamStatusClosing:
-				if (m_SentPackets.empty () && m_SendBuffer.eof ()) // nothing to send
-				{
-					m_Status = eStreamStatusClosed;
-					SendClose ();
-					Terminate ();
-					m_LocalDestination.DeleteStream (shared_from_this ());	
-				}
-			break;
-			case eStreamStatusClosed:
-				// already closed
-				Terminate ();
-				m_LocalDestination.DeleteStream (shared_from_this ());		
-			break;				
-			default:
-				LogPrint (eLogWarning, "Unexpected stream status ", (int)m_Status);
-		};			
-	}
-
-	void Stream::SendClose ()
-	{
-		Packet * p = new Packet ();
-		uint8_t * packet = p->GetBuffer ();
-		size_t size = 0;
-		htobe32buf (packet + size, m_SendStreamID);
-		size += 4; // sendStreamID
-		htobe32buf (packet + size, m_RecvStreamID);
-		size += 4; // receiveStreamID
-		htobe32buf (packet + size, m_SequenceNumber++);
-		size += 4; // sequenceNum
-		htobe32buf (packet + size, m_LastReceivedSequenceNumber);
-		size += 4; // ack Through
-		packet[size] = 0; 
-		size++; // NACK count
-		size++; // resend delay
-		htobe16buf (packet + size, PACKET_FLAG_CLOSE | PACKET_FLAG_SIGNATURE_INCLUDED);
-		size += 2; // flags
-		size_t signatureLen = m_LocalDestination.GetOwner ().GetIdentity ().GetSignatureLen ();
-		htobe16buf (packet + size, signatureLen); // signature only
-		size += 2; // options size
-		uint8_t * signature = packet + size;
-		memset (packet + size, 0, signatureLen);
-		size += signatureLen; // signature
-		m_LocalDestination.GetOwner ().Sign (packet, size, signature);
-		
-		p->len = size;
-		m_Service.post (std::bind (&Stream::SendPacket, shared_from_this (), p));
-		LogPrint ("FIN sent");
-	}	
-		
-	size_t Stream::ConcatenatePackets (uint8_t * buf, size_t len)
-	{
-		size_t pos = 0;
-		while (pos < len && !m_ReceiveQueue.empty ())
-		{
-			Packet * packet = m_ReceiveQueue.front ();
-			size_t l = std::min (packet->GetLength (), len - pos);
-			memcpy (buf + pos, packet->GetBuffer (), l);
-			pos += l;
-			packet->offset += l;
-			if (!packet->GetLength ())
-			{
-				m_ReceiveQueue.pop ();
-				delete packet;
-			}	
-		}	
-		return pos; 
-	}
-
-	bool Stream::SendPacket (Packet * packet)
-	{
-		if (packet)
-		{	
-			if (m_IsAckSendScheduled)
-			{
-				m_IsAckSendScheduled = false;	
-				m_AckSendTimer.cancel ();
-			}
-			SendPackets (std::vector<Packet *> { packet });
-			if (m_Status == eStreamStatusOpen)
-			{	
-				bool isEmpty = m_SentPackets.empty ();
-				m_SentPackets.insert (packet);
-				if (isEmpty)
-					ScheduleResend ();
-			}	
-			else
-				delete packet;
-			return true;	
-		}	
-		else
-			return false;
-	}	
-		
-	void Stream::SendPackets (const std::vector<Packet *>& packets)
-	{
-		if (!m_RemoteLeaseSet)
-		{
-			UpdateCurrentRemoteLease ();	
-			if (!m_RemoteLeaseSet)
-			{
-				LogPrint (eLogError, "Can't send packets. Missing remote LeaseSet");
-				return;
-			}
-		}
-		if (!m_CurrentOutboundTunnel || !m_CurrentOutboundTunnel->IsEstablished ())
-			m_CurrentOutboundTunnel = m_LocalDestination.GetOwner ().GetTunnelPool ()->GetNextOutboundTunnel ();
-		if (!m_CurrentOutboundTunnel)
-		{
-			LogPrint (eLogError, "No outbound tunnels in the pool");
-			return;
-		}
-
-		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-		if (ts >= m_CurrentRemoteLease.endDate - i2p::tunnel::TUNNEL_EXPIRATION_THRESHOLD*1000)
-			UpdateCurrentRemoteLease ();
-		if (ts < m_CurrentRemoteLease.endDate)
-		{	
-			std::vector<i2p::tunnel::TunnelMessageBlock> msgs;
-			for (auto it: packets)
-			{ 
-				auto msg = m_RoutingSession->WrapSingleMessage (CreateDataMessage (it->GetBuffer (), it->GetLength ()));
-				msgs.push_back (i2p::tunnel::TunnelMessageBlock 
-					{ 
-						i2p::tunnel::eDeliveryTypeTunnel,
-						m_CurrentRemoteLease.tunnelGateway, m_CurrentRemoteLease.tunnelID,
-						msg
-					});	
-				m_NumSentBytes += it->GetLength ();
-			}
-			m_CurrentOutboundTunnel->SendTunnelDataMsg (msgs);
-		}	
-		else
-			LogPrint (eLogWarning, "All leases are expired");
-	}
-
-		
-	void Stream::ScheduleResend ()
-	{
-		m_ResendTimer.cancel ();
-		m_ResendTimer.expires_from_now (boost::posix_time::milliseconds(m_RTO));
-		m_ResendTimer.async_wait (std::bind (&Stream::HandleResendTimer,
-			shared_from_this (), std::placeholders::_1));
-	}
-		
-	void Stream::HandleResendTimer (const boost::system::error_code& ecode)
-	{
-		if (ecode != boost::asio::error::operation_aborted) 
-		{	
-			// check for resend attempts
-			if (m_NumResendAttempts >= MAX_NUM_RESEND_ATTEMPTS)
-			{
-				LogPrint (eLogWarning, "Stream packet was not ACKed after ", MAX_NUM_RESEND_ATTEMPTS,  " attempts. Terminate");
-				m_Status = eStreamStatusReset;
-				Close ();
-				return;
-			}	
-
-			// collect packets to resend
-			auto ts = i2p::util::GetMillisecondsSinceEpoch ();
-			std::vector<Packet *> packets;
-			for (auto it : m_SentPackets)
-			{
-				if (ts >= it->sendTime + m_RTO)
-				{
-					it->sendTime = ts;
-					packets.push_back (it);
-				}					
-			}	
-
-			// select tunnels if necessary and send
-			if (packets.size () > 0)
-			{
-				m_NumResendAttempts++;
-				switch (m_NumResendAttempts)
-				{	
-					case 1: // congesion avoidance
-						m_WindowSize /= 2;
-						if (m_WindowSize < MIN_WINDOW_SIZE) m_WindowSize = MIN_WINDOW_SIZE;
-					break;
-					case 2:
-					case 4:	
-						UpdateCurrentRemoteLease (); // pick another lease
-						m_RTO = INITIAL_RTO; // drop RTO to initial upon tunnels pair change
-						LogPrint (eLogWarning, "Another remote lease has been selected for stream");
-					break;	
-					case 3:
-						// pick another outbound tunnel 
-						m_CurrentOutboundTunnel = m_LocalDestination.GetOwner ().GetTunnelPool ()->GetNextOutboundTunnel (m_CurrentOutboundTunnel); 
-						LogPrint (eLogWarning, "Another outbound tunnel has been selected for stream");
-					break;
-					default: ;	
-				}	
-				SendPackets (packets);
-			}	
-			ScheduleResend ();
-		}	
-	}	
-		
-	void Stream::HandleAckSendTimer (const boost::system::error_code& ecode)
-	{
-		if (m_IsAckSendScheduled)
-		{
-			if (m_LastReceivedSequenceNumber < 0)
-			{
-				LogPrint (eLogWarning, "SYN has not been recived after ", ACK_SEND_TIMEOUT, " milliseconds after follow on. Terminate");
-				m_Status = eStreamStatusReset;
-				Close ();
-				return;
-			}	
-			if (m_Status == eStreamStatusOpen)
-				SendQuickAck ();
-			m_IsAckSendScheduled = false;
-		}	
-	}
-
-	void Stream::UpdateCurrentRemoteLease ()
-	{
-		if (!m_RemoteLeaseSet)
-		{
-			m_RemoteLeaseSet = m_LocalDestination.GetOwner ().FindLeaseSet (m_RemoteIdentity.GetIdentHash ());
-			if (!m_RemoteLeaseSet)		
-				LogPrint ("LeaseSet ", m_RemoteIdentity.GetIdentHash ().ToBase64 (), " not found");
-		}
-		if (m_RemoteLeaseSet)
-		{
-			if (!m_RoutingSession)
-				m_RoutingSession = m_LocalDestination.GetOwner ().GetRoutingSession (m_RemoteLeaseSet, 32);
-			auto leases = m_RemoteLeaseSet->GetNonExpiredLeases (false); // try without threshold first
-			if (leases.empty ())
-			{
-				m_LocalDestination.GetOwner ().RequestDestination (m_RemoteIdentity.GetIdentHash ()); // time to re-request
-				leases = m_RemoteLeaseSet->GetNonExpiredLeases (true); // then with threshold
-			}
-			if (!leases.empty ())
-			{	
-				uint32_t i = i2p::context.GetRandomNumberGenerator ().GenerateWord32 (0, leases.size () - 1);
-				if (m_CurrentRemoteLease.endDate && leases[i].tunnelID == m_CurrentRemoteLease.tunnelID)
-					// make sure we don't select previous 	
-					i = (i + 1) % leases.size (); // if so, pick next
-				m_CurrentRemoteLease = leases[i];		
-			}	
-			else
-			{	
-				m_RemoteLeaseSet = nullptr;
-				m_CurrentRemoteLease.endDate = 0;
-				// re-request expired
-			}	
-		}
-		else
-			m_CurrentRemoteLease.endDate = 0;
-	}	
-
-	I2NPMessage * Stream::CreateDataMessage (const uint8_t * payload, size_t len)
-	{
-		I2NPMessage * msg = NewI2NPShortMessage ();
-		CryptoPP::Gzip compressor;
-		if (len <= i2p::stream::COMPRESSION_THRESHOLD_SIZE)
-			compressor.SetDeflateLevel (CryptoPP::Gzip::MIN_DEFLATE_LEVEL);
-		else
-			compressor.SetDeflateLevel (CryptoPP::Gzip::DEFAULT_DEFLATE_LEVEL);
-		compressor.Put (payload, len);
-		compressor.MessageEnd();
-		int size = compressor.MaxRetrievable ();
-		uint8_t * buf = msg->GetPayload ();
-		htobe32buf (buf, size); // length
-		buf += 4;
-		compressor.Get (buf, size);
-		htobe16buf (buf + 4, m_LocalDestination.GetLocalPort ()); // source port
-		htobe16buf (buf + 6, m_Port); // destination port 
-		buf[9] = i2p::client::PROTOCOL_TYPE_STREAMING; // streaming protocol
-		msg->len += size + 4; 
-		FillI2NPMessageHeader (msg, eI2NPData);
-		
-		return msg;
-	}	
-		
-	void StreamingDestination::Start ()
-	{	
-	}
-		
-	void StreamingDestination::Stop ()
-	{	
-		ResetAcceptor ();
-		{
-			std::unique_lock<std::mutex> l(m_StreamsMutex);
-			m_Streams.clear ();
-		}	
-	}	
-		
-	void StreamingDestination::HandleNextPacket (Packet * packet)
-	{
-		uint32_t sendStreamID = packet->GetSendStreamID ();
-		if (sendStreamID)
-		{	
-			auto it = m_Streams.find (sendStreamID);
-			if (it != m_Streams.end ())
-				it->second->HandleNextPacket (packet);
-			else
-			{	
-				LogPrint ("Unknown stream sendStreamID=", sendStreamID);
-				delete packet;
-			}
-		}	
-		else 
-		{
-			if (packet->IsSYN () && !packet->GetSeqn ()) // new incoming stream
-			{	
-				auto incomingStream = CreateNewIncomingStream ();
-				incomingStream->HandleNextPacket (packet);
-				if (m_Acceptor != nullptr)
-					m_Acceptor (incomingStream);
-				else
-				{
-					LogPrint ("Acceptor for incoming stream is not set");
-					DeleteStream (incomingStream);
-				}	
-			}	
-			else // follow on packet without SYN
-			{
-				uint32_t receiveStreamID = packet->GetReceiveStreamID ();
-				for (auto it: m_Streams)
-					if (it.second->GetSendStreamID () == receiveStreamID)
-					{
-						// found
-						it.second->HandleNextPacket (packet);
-						return;
-					}
-				// TODO: should queue it up
-				LogPrint ("Unknown stream receiveStreamID=", receiveStreamID);
-				delete packet;
-			}	
-		}	
-	}	
-
-	std::shared_ptr<Stream> StreamingDestination::CreateNewOutgoingStream (std::shared_ptr<const i2p::data::LeaseSet> remote, int port)
-	{
-		auto s = std::make_shared<Stream> (m_Owner.GetService (), *this, remote, port);
-		std::unique_lock<std::mutex> l(m_StreamsMutex);
-		m_Streams[s->GetRecvStreamID ()] = s;
-		return s;
-	}	
-
-	std::shared_ptr<Stream> StreamingDestination::CreateNewIncomingStream ()
-	{
-		auto s = std::make_shared<Stream> (m_Owner.GetService (), *this);
-		std::unique_lock<std::mutex> l(m_StreamsMutex);
-		m_Streams[s->GetRecvStreamID ()] = s;
-		return s;
-	}
-
-	void StreamingDestination::DeleteStream (std::shared_ptr<Stream> stream)
-	{
-		if (stream)
-		{	
-			std::unique_lock<std::mutex> l(m_StreamsMutex);
-			auto it = m_Streams.find (stream->GetRecvStreamID ());
-			if (it != m_Streams.end ())
-				m_Streams.erase (it);
-		}	
-	}		
-
-	void StreamingDestination::HandleDataMessagePayload (const uint8_t * buf, size_t len)
-	{
-		// unzip it
-		CryptoPP::Gunzip decompressor;
-		decompressor.Put (buf, len);
-		decompressor.MessageEnd();
-		Packet * uncompressed = new Packet;
-		uncompressed->offset = 0;
-		uncompressed->len = decompressor.MaxRetrievable ();
-		if (uncompressed->len <= MAX_PACKET_SIZE)
-		{
-			decompressor.Get (uncompressed->buf, uncompressed->len);
-			HandleNextPacket (uncompressed); 
-		}
-		else
-		{
-			LogPrint ("Received packet size ", uncompressed->len,  " exceeds max packet size. Skipped");
-			delete uncompressed;
-		}	
-	}
-}		
-}	

TransitTunnel.cpp

@@ -1,111 +0,0 @@
-#include <string.h>
-#include "I2PEndian.h"
-#include "Log.h"
-#include "RouterContext.h"
-#include "I2NPProtocol.h"
-#include "Tunnel.h"
-#include "Transports.h"
-#include "TransitTunnel.h"
-
-namespace i2p
-{
-namespace tunnel
-{	
-	TransitTunnel::TransitTunnel (uint32_t receiveTunnelID, 
-	    const uint8_t * nextIdent, uint32_t nextTunnelID, 
-		const uint8_t * layerKey,const uint8_t * ivKey): 
-			m_TunnelID (receiveTunnelID),  m_NextTunnelID (nextTunnelID), 
-			m_NextIdent (nextIdent)
-	{	
-		m_Encryption.SetKeys (layerKey, ivKey);
-	}	
-
-	void TransitTunnel::EncryptTunnelMsg (I2NPMessage * tunnelMsg)
-	{		
-		m_Encryption.Encrypt (tunnelMsg->GetPayload () + 4); 
-	}	
-
-	TransitTunnelParticipant::~TransitTunnelParticipant ()
-	{
-		for (auto it: m_TunnelDataMsgs)
-			i2p::DeleteI2NPMessage (it);
-	}	
-		
-	void TransitTunnelParticipant::HandleTunnelDataMsg (i2p::I2NPMessage * tunnelMsg)
-	{
-		EncryptTunnelMsg (tunnelMsg);
-		
-		m_NumTransmittedBytes += tunnelMsg->GetLength ();
-		htobe32buf (tunnelMsg->GetPayload (), GetNextTunnelID ());
-		FillI2NPMessageHeader (tunnelMsg, eI2NPTunnelData);
-		m_TunnelDataMsgs.push_back (tunnelMsg);
-	}
-
-	void TransitTunnelParticipant::FlushTunnelDataMsgs ()
-	{
-		if (!m_TunnelDataMsgs.empty ())
-		{	
-			LogPrint (eLogDebug, "TransitTunnel: ",GetTunnelID (),"->", GetNextTunnelID (), " ", m_TunnelDataMsgs.size ());
-			i2p::transport::transports.SendMessages (GetNextIdentHash (), m_TunnelDataMsgs);
-			m_TunnelDataMsgs.clear ();
-		}	
-	}	
-		
-	void TransitTunnel::SendTunnelDataMsg (i2p::I2NPMessage * msg)
-	{	
-		LogPrint (eLogError, "We are not a gateway for transit tunnel ", m_TunnelID);
-		i2p::DeleteI2NPMessage (msg);	
-	}		
-
-	void TransitTunnel::HandleTunnelDataMsg (i2p::I2NPMessage * tunnelMsg)
-	{
-		LogPrint (eLogError, "Incoming tunnel message is not supported  ", m_TunnelID);
-		DeleteI2NPMessage (tunnelMsg);	
-	}	
-		
-	void TransitTunnelGateway::SendTunnelDataMsg (i2p::I2NPMessage * msg)
-	{
-		TunnelMessageBlock block;
-		block.deliveryType = eDeliveryTypeLocal;
-		block.data = msg;
-		std::unique_lock<std::mutex> l(m_SendMutex);
-		m_Gateway.PutTunnelDataMsg (block);
-	}		
-
-	void TransitTunnelGateway::FlushTunnelDataMsgs ()
-	{
-		std::unique_lock<std::mutex> l(m_SendMutex);
-		m_Gateway.SendBuffer ();
-	}	
-		
-	void TransitTunnelEndpoint::HandleTunnelDataMsg (i2p::I2NPMessage * tunnelMsg)
-	{
-		EncryptTunnelMsg (tunnelMsg);
-		
-		LogPrint (eLogDebug, "TransitTunnel endpoint for ", GetTunnelID ());
-		m_Endpoint.HandleDecryptedTunnelDataMsg (tunnelMsg); 
-	}
-		
-	TransitTunnel * CreateTransitTunnel (uint32_t receiveTunnelID,
-		const uint8_t * nextIdent, uint32_t nextTunnelID, 
-	    const uint8_t * layerKey,const uint8_t * ivKey, 
-		bool isGateway, bool isEndpoint)
-	{
-		if (isEndpoint)
-		{	
-			LogPrint (eLogInfo, "TransitTunnel endpoint: ", receiveTunnelID, " created");
-			return new TransitTunnelEndpoint (receiveTunnelID, nextIdent, nextTunnelID, layerKey, ivKey);
-		}	
-		else if (isGateway)
-		{	
-			LogPrint (eLogInfo, "TransitTunnel gateway: ", receiveTunnelID, " created");
-			return new TransitTunnelGateway (receiveTunnelID, nextIdent, nextTunnelID, layerKey, ivKey);
-		}	
-		else	
-		{	
-			LogPrint (eLogInfo, "TransitTunnel: ", receiveTunnelID, "->", nextTunnelID, " created");
-			return new TransitTunnelParticipant (receiveTunnelID, nextIdent, nextTunnelID, layerKey, ivKey);
-		}	
-	}		
-}
-}

TransportSession.h

@@ -1,87 +0,0 @@
-#ifndef TRANSPORT_SESSION_H__
-#define TRANSPORT_SESSION_H__
-
-#include <inttypes.h>
-#include <iostream>
-#include <memory>
-#include <vector>
-#include "Identity.h"
-#include "RouterInfo.h"
-#include "I2NPProtocol.h"
-
-namespace i2p
-{
-namespace transport
-{
-	struct DHKeysPair // transient keys for transport sessions
-	{
-		uint8_t publicKey[256];
-		uint8_t privateKey[256];
-	};	
-
-	class SignedData
-	{
-		public:
-
-			SignedData () {};
-			void Insert (const uint8_t * buf, size_t len) 
-			{ 
-				m_Stream.write ((char *)buf, len); 
-			}			
-
-			template<typename T>
-			void Insert (T t)
-			{
-				m_Stream.write ((char *)&t, sizeof (T)); 
-			}
-
-			bool Verify (const i2p::data::IdentityEx& ident, const uint8_t * signature) const
-			{
-				return ident.Verify ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature); 
-			}
-
-			void Sign (const i2p::data::PrivateKeys& keys, uint8_t * signature) const
-			{
-				keys.Sign ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature); 
-			}	
-
-		private:
-		
-			std::stringstream m_Stream;
-	};		
-
-	class TransportSession
-	{
-		public:
-
-			TransportSession (std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter): 
-				m_RemoteRouter (in_RemoteRouter), m_DHKeysPair (nullptr), 
-				m_NumSentBytes (0), m_NumReceivedBytes (0)
-			{
-				if (m_RemoteRouter)
-					m_RemoteIdentity = m_RemoteRouter->GetRouterIdentity ();
-			}
-
-			virtual ~TransportSession () { delete m_DHKeysPair; };
-			virtual void Done () = 0;
-			
-			std::shared_ptr<const i2p::data::RouterInfo> GetRemoteRouter () { return m_RemoteRouter; };
-			const i2p::data::IdentityEx& GetRemoteIdentity () { return m_RemoteIdentity; };
-
-			size_t GetNumSentBytes () const { return m_NumSentBytes; };
-			size_t GetNumReceivedBytes () const { return m_NumReceivedBytes; };
-			
-			virtual void SendI2NPMessage (I2NPMessage * msg) = 0;
-			virtual void SendI2NPMessages (const std::vector<I2NPMessage *>& msgs) = 0;
-			
-		protected:
-
-			std::shared_ptr<const i2p::data::RouterInfo> m_RemoteRouter;
-			i2p::data::IdentityEx m_RemoteIdentity; 
-			DHKeysPair * m_DHKeysPair; // X - for client and Y - for server
-			size_t m_NumSentBytes, m_NumReceivedBytes;
-	};	
-}
-}
-
-#endif

Transports.cpp

@@ -1,512 +0,0 @@
-#include <cryptopp/dh.h>
-#include "Log.h"
-#include "CryptoConst.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)
-		{
-			CryptoPP::DH dh (i2p::crypto::elgp, i2p::crypto::elgg);
-			for (int i = 0; i < num; i++)
-			{
-				i2p::transport::DHKeysPair * pair = new i2p::transport::DHKeysPair ();
-				dh.GenerateKeyPair(m_Rnd, pair->privateKey, pair->publicKey);
-				std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-				m_Queue.push (pair);
-			}
-		}
-	}
-
-	DHKeysPair * DHKeysPairSupplier::Acquire ()
-	{
-		if (!m_Queue.empty ())
-		{
-			std::unique_lock<std::mutex>  l(m_AcquiredMutex);
-			auto pair = m_Queue.front ();
-			m_Queue.pop ();
-			m_Acquired.notify_one ();
-			return pair;
-		}	
-		else // queue is empty, create new
-		{
-			DHKeysPair * pair = new DHKeysPair ();
-			CryptoPP::DH dh (i2p::crypto::elgp, i2p::crypto::elgg);
-			dh.GenerateKeyPair(m_Rnd, pair->privateKey, pair->publicKey);
-			return pair;
-		}
-	}
-
-	void DHKeysPairSupplier::Return (DHKeysPair * 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 (address.port);
-				m_NTCPServer->Start ();
-			}	
-			
-			if (address.transportStyle == RouterInfo::eTransportSSU && address.host.is_v4 ())
-			{
-				if (!m_SSUServer)
-				{	
-					m_SSUServer = new SSUServer (address.port);
-					LogPrint ("Start listening UDP port ", address.port);
-					m_SSUServer->Start ();	
-					DetectExternalIP ();
-				}
-				else
-					LogPrint ("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 ("Transports: ", 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 ().IsHighBandwidth ()) return false;
-		return std::max (m_InBandwidth, m_OutBandwidth) > LOW_BANDWIDTH_LIMIT;
-	}
-
-	void Transports::SendMessage (const i2p::data::IdentHash& ident, i2p::I2NPMessage * msg)
-	{
-		m_Service.post (std::bind (&Transports::PostMessage, this, ident, msg));                             
-	}	
-
-	void Transports::SendMessages (const i2p::data::IdentHash& ident, const std::vector<i2p::I2NPMessage *>& msgs)
-	{
-		m_Service.post (std::bind (&Transports::PostMessages, this, ident, msgs));
-	}	
-		
-	void Transports::PostMessage (i2p::data::IdentHash ident, i2p::I2NPMessage * msg)
-	{
-		if (ident == i2p::context.GetRouterInfo ().GetIdentHash ())
-		{	
-			// we send it to ourself
-			i2p::HandleI2NPMessage (msg);
-			return;
-		}	
-
-		auto it = m_Peers.find (ident);
-		if (it == m_Peers.end ())
-		{
-			auto r = netdb.FindRouter (ident);
-			it = m_Peers.insert (std::pair<i2p::data::IdentHash, Peer>(ident, { 0, r, nullptr,
-				i2p::util::GetSecondsSinceEpoch () })).first;
-			if (!ConnectToPeer (ident, it->second))
-			{
-				DeleteI2NPMessage (msg);
-				return;
-			}	
-		}	
-		if (it->second.session)
-			it->second.session->SendI2NPMessage (msg);
-		else
-			it->second.delayedMessages.push_back (msg);
-	}	
-
-	void Transports::PostMessages (i2p::data::IdentHash ident, std::vector<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 ())
-		{
-			auto r = netdb.FindRouter (ident);
-			it = m_Peers.insert (std::pair<i2p::data::IdentHash, Peer>(ident, { 0, r, nullptr,
-				i2p::util::GetSecondsSinceEpoch () })).first;
-			if (!ConnectToPeer (ident, it->second))
-			{
-				for (auto it1: msgs)
-					DeleteI2NPMessage (it1);
-				return;
-			}	
-		}	
-		if (it->second.session)
-			it->second.session->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 (eLogInfo, "Resolving ", address->addressString);
-							NTCPResolve (address->addressString, ident);
-							return true;
-						}
-					}
-				}	
-			}
-			else  if (peer.numAttempts == 1)// SSU
-			{
-				peer.numAttempts++;
-				if (m_SSUServer)
-				{	
-					if (m_SSUServer->GetSession (peer.router))
-						return true;
-				}
-			}	
-			LogPrint (eLogError, "No NTCP and SSU addresses available");
-			if (peer.session) peer.session->Done ();
-			m_Peers.erase (ident);
-			return false;
-		}	
-		else // otherwise request RI
-		{
-			LogPrint ("Router 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, const i2p::data::IdentHash& ident)
-	{
-		auto it = m_Peers.find (ident);
-		if (it != m_Peers.end ())
-		{	
-			if (r)
-			{
-				LogPrint ("Router found. Trying to connect");
-				it->second.router = r;
-				ConnectToPeer (ident, it->second);
-			}	
-			else
-			{
-				LogPrint ("Router not found. Failed to send messages");
-				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 (eLogInfo, (*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, "Unable to resolve NTCP address: ", ecode.message ());
-			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 ("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 ())
-					m_SSUServer->GetSession (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->GetSession (router);  	// no peer test
-				}
-			}	
-		}
-		else
-			LogPrint (eLogError, "Can't detect external IP. SSU is not available");
-	}
-			
-	DHKeysPair * Transports::GetNextDHKeysPair ()
-	{
-		return m_DHKeysPairSupplier.Acquire ();
-	}
-
-	void Transports::ReuseDHKeysPair (DHKeysPair * pair)
-	{
-		m_DHKeysPairSupplier.Return (pair);
-	}
-
-	void Transports::PeerConnected (std::shared_ptr<TransportSession> session)
-	{
-		m_Service.post([session, this]()
-		{   
-			auto ident = session->GetRemoteIdentity ().GetIdentHash ();
-			auto it = m_Peers.find (ident);
-			if (it != m_Peers.end ())
-			{
-				if (!it->second.session)
-				{
-					it->second.session = session;
-					session->SendI2NPMessages (it->second.delayedMessages);
-					it->second.delayedMessages.clear ();
-				}
-				else
-				{
-					LogPrint (eLogError, "Session for ", ident.ToBase64 ().substr (0, 4), " already exists");
-					session->Done ();
-				}
-			}
-			else // incoming connection
-				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 ident = session->GetRemoteIdentity ().GetIdentHash ();
-			auto it = m_Peers.find (ident);
-			if (it != m_Peers.end () && (!it->second.session || it->second.session == session))
-			{
-				if (it->second.delayedMessages.size () > 0)
-					ConnectToPeer (ident, it->second);
-				else
-					m_Peers.erase (it);
-			}
-		});	
-	}	
-
-	bool Transports::IsConnected (const i2p::data::IdentHash& ident) const
-	{
-		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.session && ts > it->second.creationTime + SESSION_CREATION_TIMEOUT)
-				{
-					LogPrint (eLogError, "Session to peer ", it->first.ToBase64 (), " has not been created in ", SESSION_CREATION_TIMEOUT, " seconds");
-					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));
-		}	
-	}
-}
-}
-

Transports.h

@@ -1,151 +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 <cryptopp/osrng.h>
-#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 ();
-			DHKeysPair * Acquire ();
-			void Return (DHKeysPair * pair);
-
-		private:
-
-			void Run ();
-			void CreateDHKeysPairs (int num);
-
-		private:
-
-			const int m_QueueSize;
-			std::queue<DHKeysPair *> m_Queue;
-
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			std::condition_variable m_Acquired;
-			std::mutex m_AcquiredMutex;
-			CryptoPP::AutoSeededRandomPool m_Rnd;
-	};
-
-	struct Peer
-	{
-		int numAttempts;
-		std::shared_ptr<const i2p::data::RouterInfo> router;
-		std::shared_ptr<TransportSession> session;
-		uint64_t creationTime;
-		std::vector<i2p::I2NPMessage *> delayedMessages;
-
-		~Peer ()
-		{
-			for (auto it :delayedMessages)
-				i2p::DeleteI2NPMessage (it);			
-		}	
-	};	
-	
-	const size_t SESSION_CREATION_TIMEOUT = 10; // in seconds
-	const uint32_t LOW_BANDWIDTH_LIMIT = 32*1024; // 32KBs
-	class Transports
-	{
-		public:
-
-			Transports ();
-			~Transports ();
-
-			void Start ();
-			void Stop ();
-			
-			boost::asio::io_service& GetService () { return m_Service; };
-			i2p::transport::DHKeysPair * GetNextDHKeysPair ();	
-			void ReuseDHKeysPair (DHKeysPair * pair);
-
-			void SendMessage (const i2p::data::IdentHash& ident, i2p::I2NPMessage * msg);
-			void SendMessages (const i2p::data::IdentHash& ident, const std::vector<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;
-
-		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, const i2p::data::IdentHash& ident);
-			void PostMessage (i2p::data::IdentHash ident, i2p::I2NPMessage * msg);
-			void PostMessages (i2p::data::IdentHash ident, std::vector<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 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;
-			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

Tunnel.cpp

@@ -1,731 +0,0 @@
-#include <string.h>
-#include "I2PEndian.h"
-#include <thread>
-#include <algorithm>
-#include <vector> 
-#include <cryptopp/sha.h>
-#include "RouterContext.h"
-#include "Log.h"
-#include "Timestamp.h"
-#include "I2NPProtocol.h"
-#include "Transports.h"
-#include "NetDb.h"
-#include "Tunnel.h"
-
-namespace i2p
-{	
-namespace tunnel
-{		
-	
-	Tunnel::Tunnel (TunnelConfig * config): 
-		m_Config (config), m_Pool (nullptr), m_State (eTunnelStatePending)
-	{
-	}	
-
-	Tunnel::~Tunnel ()
-	{
-		delete m_Config;
-	}	
-
-	void Tunnel::Build (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> outboundTunnel)
-	{
-		CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator ();
-		auto numHops = m_Config->GetNumHops ();
-		int numRecords = numHops <= STANDARD_NUM_RECORDS ? STANDARD_NUM_RECORDS : numHops; 
-		I2NPMessage * msg = NewI2NPShortMessage ();
-		*msg->GetPayload () = numRecords;
-		msg->len += numRecords*TUNNEL_BUILD_RECORD_SIZE + 1;		
-
-		// shuffle records
-		std::vector<int> recordIndicies;
-		for (int i = 0; i < numRecords; i++) recordIndicies.push_back(i);
-		std::random_shuffle (recordIndicies.begin(), recordIndicies.end());
-
-		// create real records
-		uint8_t * records = msg->GetPayload () + 1; 
-		TunnelHopConfig * hop = m_Config->GetFirstHop ();
-		int i = 0;
-		while (hop)
-		{
-			int idx = recordIndicies[i];
-			hop->CreateBuildRequestRecord (records + idx*TUNNEL_BUILD_RECORD_SIZE, 
-				hop->next ? rnd.GenerateWord32 () : replyMsgID); // we set replyMsgID for last hop only 
-			hop->recordIndex = idx; 
-			i++;
-			hop = hop->next;
-		}	
-		// fill up fake records with random data	
-		for (int i = numHops; i < numRecords; i++)
-		{
-			int idx = recordIndicies[i];
-			rnd.GenerateBlock (records + idx*TUNNEL_BUILD_RECORD_SIZE, TUNNEL_BUILD_RECORD_SIZE); 
-		}	
-
-		// decrypt real records
-		i2p::crypto::CBCDecryption decryption;
-		hop = m_Config->GetLastHop ()->prev;
-		while (hop)
-		{
-			decryption.SetKey (hop->replyKey);
-			// decrypt records after current hop
-			TunnelHopConfig * hop1 = hop->next;
-			while (hop1)
-			{	
-				decryption.SetIV (hop->replyIV);
-				uint8_t * record = records + hop1->recordIndex*TUNNEL_BUILD_RECORD_SIZE;
-				decryption.Decrypt(record, TUNNEL_BUILD_RECORD_SIZE, record);
-				hop1 = hop1->next;
-			}	
-			hop = hop->prev;
-		}	
-		FillI2NPMessageHeader (msg, eI2NPVariableTunnelBuild);
-
-		// send message
-		if (outboundTunnel)
-			outboundTunnel->SendTunnelDataMsg (GetNextIdentHash (), 0, msg);	
-		else
-			i2p::transport::transports.SendMessage (GetNextIdentHash (), msg);
-	}	
-		
-	bool Tunnel::HandleTunnelBuildResponse (uint8_t * msg, size_t len)
-	{
-		LogPrint ("TunnelBuildResponse ", (int)msg[0], " records.");
-		
-		i2p::crypto::CBCDecryption decryption;
-		TunnelHopConfig * hop = m_Config->GetLastHop (); 
-		while (hop)
-		{	
-			decryption.SetKey (hop->replyKey);
-			// decrypt records before and including current hop
-			TunnelHopConfig * hop1 = hop;
-			while (hop1)
-			{
-				auto idx = hop1->recordIndex;
-				if (idx >= 0 && idx < msg[0])
-				{	
-					uint8_t * record = msg + 1 + idx*TUNNEL_BUILD_RECORD_SIZE;
-					decryption.SetIV (hop->replyIV);
-					decryption.Decrypt(record, TUNNEL_BUILD_RECORD_SIZE, record);
-				}	
-				else
-					LogPrint ("Tunnel hop index ", idx, " is out of range");
-				hop1 = hop1->prev;
-			}	
-			hop = hop->prev;
-		}
-
-		bool established = true;
-		hop = m_Config->GetFirstHop ();
-		while (hop)
-		{			
-			const uint8_t * record = msg + 1 + hop->recordIndex*TUNNEL_BUILD_RECORD_SIZE;
-			uint8_t ret = record[BUILD_RESPONSE_RECORD_RET_OFFSET];
-			LogPrint ("Ret code=", (int)ret);
-			hop->router->GetProfile ()->TunnelBuildResponse (ret);
-			if (ret) 
-				// if any of participants declined the tunnel is not established
-				established = false; 
-			hop = hop->next;
-		}
-		if (established) 
-		{
-			// change reply keys to layer keys
-			hop = m_Config->GetFirstHop ();
-			while (hop)
-			{
-				hop->decryption.SetKeys (hop->layerKey, hop->ivKey);
-				hop = hop->next;
-			}	
-		}	
-		if (established) m_State = eTunnelStateEstablished;
-		return established;
-	}	
-
-	void Tunnel::EncryptTunnelMsg (I2NPMessage * tunnelMsg)
-	{
-		uint8_t * payload = tunnelMsg->GetPayload () + 4;
-		TunnelHopConfig * hop = m_Config->GetLastHop (); 
-		while (hop)
-		{	
-			hop->decryption.Decrypt (payload);
-			hop = hop->prev;
-		}
-	}	
-
-	void Tunnel::SendTunnelDataMsg (i2p::I2NPMessage * msg)
-	{
-		LogPrint (eLogInfo, "Can't send I2NP messages without delivery instructions");	
-		DeleteI2NPMessage (msg);
-	}	
-
-	void InboundTunnel::HandleTunnelDataMsg (I2NPMessage * msg)
-	{
-		if (IsFailed ()) SetState (eTunnelStateEstablished); // incoming messages means a tunnel is alive			
-		msg->from = shared_from_this ();
-		EncryptTunnelMsg (msg);
-		m_Endpoint.HandleDecryptedTunnelDataMsg (msg);	
-	}	
-
-	void OutboundTunnel::SendTunnelDataMsg (const uint8_t * gwHash, uint32_t gwTunnel, i2p::I2NPMessage * msg)
-	{
-		TunnelMessageBlock block;
-		if (gwHash)
-		{
-			block.hash = gwHash;
-			if (gwTunnel)
-			{	
-				block.deliveryType = eDeliveryTypeTunnel;
-				block.tunnelID = gwTunnel;
-			}	
-			else
-				block.deliveryType = eDeliveryTypeRouter;
-		}	
-		else	
-			block.deliveryType = eDeliveryTypeLocal;
-		block.data = msg;
-		
-		std::unique_lock<std::mutex> l(m_SendMutex);
-		m_Gateway.SendTunnelDataMsg (block);
-	}
-		
-	void OutboundTunnel::SendTunnelDataMsg (const std::vector<TunnelMessageBlock>& msgs)
-	{
-		std::unique_lock<std::mutex> l(m_SendMutex);
-		for (auto& it : msgs)
-			m_Gateway.PutTunnelDataMsg (it);
-		m_Gateway.SendBuffer ();
-	}	
-	
-	void OutboundTunnel::HandleTunnelDataMsg (i2p::I2NPMessage * tunnelMsg)
-	{
-		LogPrint (eLogError, "Incoming message for outbound tunnel ", GetTunnelID ());
-		DeleteI2NPMessage (tunnelMsg);	
-	}
-
-	Tunnels tunnels;
-	
-	Tunnels::Tunnels (): m_IsRunning (false), m_Thread (nullptr),
-		m_NumSuccesiveTunnelCreations (0), m_NumFailedTunnelCreations (0)
-	{
-	}
-	
-	Tunnels::~Tunnels ()	
-	{
-		for (auto& it : m_TransitTunnels)
-			delete it.second;
-		m_TransitTunnels.clear ();
-	}	
-	
-	std::shared_ptr<InboundTunnel> Tunnels::GetInboundTunnel (uint32_t tunnelID)
-	{
-		auto it = m_InboundTunnels.find(tunnelID);
-		if (it != m_InboundTunnels.end ())
-			return it->second;
-		return nullptr;
-	}	
-	
-	TransitTunnel * Tunnels::GetTransitTunnel (uint32_t tunnelID)
-	{
-		auto it = m_TransitTunnels.find(tunnelID);
-		if (it != m_TransitTunnels.end ())
-			return it->second;
-		return nullptr;
-	}	
-	
-	std::shared_ptr<InboundTunnel> Tunnels::GetPendingInboundTunnel (uint32_t replyMsgID)
-	{
-		return GetPendingTunnel (replyMsgID, m_PendingInboundTunnels);	
-	}
-	
-	std::shared_ptr<OutboundTunnel> Tunnels::GetPendingOutboundTunnel (uint32_t replyMsgID)
-	{
-		return GetPendingTunnel (replyMsgID, m_PendingOutboundTunnels);	
-	}		
-
-	template<class TTunnel>		
-	std::shared_ptr<TTunnel> Tunnels::GetPendingTunnel (uint32_t replyMsgID, const std::map<uint32_t, std::shared_ptr<TTunnel> >& pendingTunnels)
-	{
-		auto it = pendingTunnels.find(replyMsgID);
-		if (it != pendingTunnels.end () && it->second->GetState () == eTunnelStatePending)
-		{	
-			it->second->SetState (eTunnelStateBuildReplyReceived);	
-			return it->second;
-		}
-		return nullptr;
-	}	
-
-	std::shared_ptr<InboundTunnel> Tunnels::GetNextInboundTunnel ()
-	{
-		std::shared_ptr<InboundTunnel> tunnel; 
-		size_t minReceived = 0;
-		for (auto it : m_InboundTunnels)
-		{
-			if (!it.second->IsEstablished ()) continue;
-			if (!tunnel || it.second->GetNumReceivedBytes () < minReceived)
-			{
-				tunnel = it.second;
-				minReceived = it.second->GetNumReceivedBytes ();
-			}
-		}			
-		return tunnel;
-	}
-	
-	std::shared_ptr<OutboundTunnel> Tunnels::GetNextOutboundTunnel ()
-	{
-		CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator ();
-		uint32_t ind = rnd.GenerateWord32 (0, m_OutboundTunnels.size () - 1), i = 0;
-		std::shared_ptr<OutboundTunnel> tunnel;
-		for (auto it: m_OutboundTunnels)
-		{	
-			if (it->IsEstablished ())
-			{
-				tunnel = it;
-				i++;
-			}
-			if (i > ind && tunnel) break;
-		}	
-		return tunnel;
-	}	
-
-	std::shared_ptr<TunnelPool> Tunnels::CreateTunnelPool (i2p::garlic::GarlicDestination * localDestination, int numInboundHops, int numOutboundHops)
-	{
-		auto pool = std::make_shared<TunnelPool> (localDestination, numInboundHops, numOutboundHops);
-		std::unique_lock<std::mutex> l(m_PoolsMutex);
-		m_Pools.push_back (pool);
-		return pool;
-	}	
-
-	void Tunnels::DeleteTunnelPool (std::shared_ptr<TunnelPool> pool)
-	{
-		if (pool)
-		{	
-			StopTunnelPool (pool);
-			{
-				std::unique_lock<std::mutex> l(m_PoolsMutex);
-				m_Pools.remove (pool);
-			}	
-		}	
-	}	
-
-	void Tunnels::StopTunnelPool (std::shared_ptr<TunnelPool> pool)
-	{
-		if (pool)
-		{
-			pool->SetActive (false);
-			pool->DetachTunnels ();
-		}	
-	}	
-		
-	void Tunnels::AddTransitTunnel (TransitTunnel * tunnel)
-	{
-		std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
-		if (!m_TransitTunnels.insert (std::make_pair (tunnel->GetTunnelID (), tunnel)).second)
-		{	
-			LogPrint (eLogError, "Transit tunnel ", tunnel->GetTunnelID (), " already exists");
-			delete tunnel;
-		}
-	}	
-
-	void Tunnels::Start ()
-	{
-		m_IsRunning = true;
-		m_Thread = new std::thread (std::bind (&Tunnels::Run, this));
-	}
-	
-	void Tunnels::Stop ()
-	{
-		m_IsRunning = false;
-		m_Queue.WakeUp ();
-		if (m_Thread)
-		{	
-			m_Thread->join (); 
-			delete m_Thread;
-			m_Thread = 0;
-		}	
-	}	
-
-	void Tunnels::Run ()
-	{
-		std::this_thread::sleep_for (std::chrono::seconds(1)); // wait for other parts are ready
-		
-		uint64_t lastTs = 0;
-		while (m_IsRunning)
-		{
-			try
-			{	
-				I2NPMessage * msg = m_Queue.GetNextWithTimeout (1000); // 1 sec
-				if (msg)
-				{	
-					uint32_t prevTunnelID = 0, tunnelID = 0;
-					TunnelBase * prevTunnel = nullptr; 
-					do
-					{
-						TunnelBase * tunnel = nullptr;
-						uint8_t typeID = msg->GetTypeID ();
-						switch (typeID)
-						{									
-							case eI2NPTunnelData:
-							case eI2NPTunnelGateway:
-							{	
-								tunnelID = bufbe32toh (msg->GetPayload ()); 
-								if (tunnelID == prevTunnelID)
-									tunnel = prevTunnel;
-								else if (prevTunnel)
-									prevTunnel->FlushTunnelDataMsgs (); 
-						
-								if (!tunnel && typeID == eI2NPTunnelData)
-									tunnel = GetInboundTunnel (tunnelID).get ();
-								if (!tunnel)
-									tunnel = GetTransitTunnel (tunnelID);
-								if (tunnel)
-								{
-									if (typeID == eI2NPTunnelData)
-										tunnel->HandleTunnelDataMsg (msg);
-									else // tunnel gateway assumed
-										HandleTunnelGatewayMsg (tunnel, msg);
-								}
-								else	
-								{	
-									LogPrint (eLogWarning, "Tunnel ", tunnelID, " not found");
-									DeleteI2NPMessage (msg);
-								}	
-								break;
-							}	
-							case eI2NPVariableTunnelBuild:		
-							case eI2NPVariableTunnelBuildReply:
-							case eI2NPTunnelBuild:
-							case eI2NPTunnelBuildReply:	
-							{
-								HandleI2NPMessage (msg->GetBuffer (), msg->GetLength ());
-								DeleteI2NPMessage (msg);
-								break;
-							}	
-							default:
-							{
-								LogPrint (eLogError, "Unexpected  messsage type ", (int)typeID);
-								DeleteI2NPMessage (msg);
-							}	
-						}
-							
-						msg = m_Queue.Get ();
-						if (msg)
-						{
-							prevTunnelID = tunnelID;
-							prevTunnel = tunnel;
-						}
-						else if (tunnel)
-							tunnel->FlushTunnelDataMsgs ();
-					}
-					while (msg);
-				}	
-			
-				uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-				if (ts - lastTs >= 15) // manage tunnels every 15 seconds
-				{
-					ManageTunnels ();
-					lastTs = ts;
-				}
-			}
-			catch (std::exception& ex)
-			{
-				LogPrint ("Tunnels: ", ex.what ());
-			}	
-		}	
-	}	
-
-	void Tunnels::HandleTunnelGatewayMsg (TunnelBase * tunnel, I2NPMessage * msg)
-	{
-		if (!tunnel)
-		{
-			LogPrint (eLogError, "Missing tunnel for TunnelGateway");
-			i2p::DeleteI2NPMessage (msg);
-			return;
-		}
-		const uint8_t * payload = msg->GetPayload ();
-		uint16_t len = bufbe16toh(payload + TUNNEL_GATEWAY_HEADER_LENGTH_OFFSET);
-		// we make payload as new I2NP message to send
-		msg->offset += I2NP_HEADER_SIZE + TUNNEL_GATEWAY_HEADER_SIZE;
-		msg->len = msg->offset + len;
-		auto typeID = msg->GetTypeID ();
-		LogPrint (eLogDebug, "TunnelGateway of ", (int)len, " bytes for tunnel ", tunnel->GetTunnelID (), ". Msg type ", (int)typeID);
-			
-		if (typeID == eI2NPDatabaseStore || typeID == eI2NPDatabaseSearchReply)
-		{
-			// transit DatabaseStore my contain new/updated RI 
-			// or DatabaseSearchReply with new routers
-			auto ds = NewI2NPMessage ();
-			*ds = *msg;
-			i2p::data::netdb.PostI2NPMsg (ds);
-		}	
-		tunnel->SendTunnelDataMsg (msg);
-	}
-
-	void Tunnels::ManageTunnels ()
-	{
-		ManagePendingTunnels ();
-		ManageInboundTunnels ();
-		ManageOutboundTunnels ();
-		ManageTransitTunnels ();
-		ManageTunnelPools ();
-	}	
-
-	void Tunnels::ManagePendingTunnels ()
-	{
-		ManagePendingTunnels (m_PendingInboundTunnels);
-		ManagePendingTunnels (m_PendingOutboundTunnels);
-	}
-
-	template<class PendingTunnels>
-	void Tunnels::ManagePendingTunnels (PendingTunnels& pendingTunnels)
-	{
-		// check pending tunnel. delete failed or timeout
-		uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-		for (auto it = pendingTunnels.begin (); it != pendingTunnels.end ();)
-		{	
-			auto tunnel = it->second;
-			switch (tunnel->GetState ())
-			{
-				case eTunnelStatePending: 
-					if (ts > tunnel->GetCreationTime () + TUNNEL_CREATION_TIMEOUT)
-					{
-						LogPrint ("Pending tunnel build request ", it->first, " timeout. Deleted");
-						// update stats
-						auto config = tunnel->GetTunnelConfig ();
-						if (config)
-						{
-							auto hop = config->GetFirstHop ();
-							while (hop)
-							{
-								if (hop->router) 
-									hop->router->GetProfile ()->TunnelNonReplied ();
-								hop = hop->next;
-							}	
-						}	
-						// delete
-						it = pendingTunnels.erase (it);
-						m_NumFailedTunnelCreations++;
-					}
-					else
-						it++;
-				break;
-				case eTunnelStateBuildFailed:
-					LogPrint ("Pending tunnel build request ", it->first, " failed. Deleted");
-					it = pendingTunnels.erase (it);
-					m_NumFailedTunnelCreations++;
-				break;
-				case eTunnelStateBuildReplyReceived:
-					// intermediate state, will be either established of build failed
-					it++;
-				break;	
-				default:
-					// success
-					it = pendingTunnels.erase (it);
-					m_NumSuccesiveTunnelCreations++;
-			}	
-		}	
-	}
-
-	void Tunnels::ManageOutboundTunnels ()
-	{
-		uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-		{
-			for (auto it = m_OutboundTunnels.begin (); it != m_OutboundTunnels.end ();)
-			{
-				auto tunnel = *it;
-				if (ts > tunnel->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
-				{
-					LogPrint ("Tunnel ", tunnel->GetTunnelID (), " expired");
-					{
-						auto pool = tunnel->GetTunnelPool ();
-						if (pool)
-							pool->TunnelExpired (tunnel);
-					}	
-					it = m_OutboundTunnels.erase (it);
-				}	
-				else 
-				{
-					if (tunnel->IsEstablished () && ts + TUNNEL_EXPIRATION_THRESHOLD > tunnel->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
-						tunnel->SetState (eTunnelStateExpiring);
-					it++;
-				}
-			}
-		}	
-	
-		if (m_OutboundTunnels.size () < 5) 
-		{
-			// trying to create one more oubound tunnel
-			auto inboundTunnel = GetNextInboundTunnel ();
-			if (!inboundTunnel) return;
-			LogPrint ("Creating one hop outbound tunnel...");
-			CreateTunnel<OutboundTunnel> (
-			  	new TunnelConfig (std::vector<std::shared_ptr<const i2p::data::RouterInfo> > 
-				    { 
-						i2p::data::netdb.GetRandomRouter ()
-					},		
-		     		inboundTunnel->GetTunnelConfig ()));
-		}
-	}
-	
-	void Tunnels::ManageInboundTunnels ()
-	{
-		uint64_t ts = i2p::util::GetSecondsSinceEpoch ();
-		{
-			for (auto it = m_InboundTunnels.begin (); it != m_InboundTunnels.end ();)
-			{
-				auto tunnel = it->second;
-				if (ts > tunnel->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
-				{
-					LogPrint ("Tunnel ", tunnel->GetTunnelID (), " expired");
-					{
-						auto pool = tunnel->GetTunnelPool ();
-						if (pool)
-							pool->TunnelExpired (tunnel);
-					}	
-					it = m_InboundTunnels.erase (it);
-				}	
-				else 
-				{
-					if (tunnel->IsEstablished () && ts + TUNNEL_EXPIRATION_THRESHOLD > tunnel->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
-						tunnel->SetState (eTunnelStateExpiring);
-					it++;
-				}
-			}
-		}	
-
-		if (m_InboundTunnels.empty ())
-		{
-			LogPrint ("Creating zero hops inbound tunnel...");
-			CreateZeroHopsInboundTunnel ();
-			if (!m_ExploratoryPool)
-				m_ExploratoryPool = CreateTunnelPool (&i2p::context, 2, 2); // 2-hop exploratory
-			return;
-		}
-		
-		if (m_OutboundTunnels.empty () || m_InboundTunnels.size () < 5) 
-		{
-			// trying to create one more inbound tunnel			
-			LogPrint ("Creating one hop inbound tunnel...");
-			CreateTunnel<InboundTunnel> (
-				new TunnelConfig (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >
-				    {              
-						i2p::data::netdb.GetRandomRouter ()
-					}));
-		}
-	}	
-
-	void Tunnels::ManageTransitTunnels ()
-	{
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		for (auto it = m_TransitTunnels.begin (); it != m_TransitTunnels.end ();)
-		{
-			if (ts > it->second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
-			{
-				auto tmp = it->second;
-				LogPrint ("Transit tunnel ", tmp->GetTunnelID (), " expired");
-				{
-					std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
-					it = m_TransitTunnels.erase (it);
-				}	
-				delete tmp;
-			}	
-			else 
-				it++;
-		}
-	}	
-
-	void Tunnels::ManageTunnelPools ()
-	{
-		std::unique_lock<std::mutex> l(m_PoolsMutex);
-		for (auto it: m_Pools)
-		{	
-			auto pool = it;
-			if (pool && pool->IsActive ())
-			{	
-				pool->CreateTunnels ();
-				pool->TestTunnels ();
-			}		
-		}
-	}	
-	
-	void Tunnels::PostTunnelData (I2NPMessage * msg)
-	{
-		if (msg) m_Queue.Put (msg);		
-	}	
-
-	void Tunnels::PostTunnelData (const std::vector<I2NPMessage *>& msgs)
-	{
-		m_Queue.Put (msgs);
-	}	
-		
-	template<class TTunnel>
-	std::shared_ptr<TTunnel> Tunnels::CreateTunnel (TunnelConfig * config, std::shared_ptr<OutboundTunnel> outboundTunnel)
-	{
-		auto newTunnel = std::make_shared<TTunnel> (config);
-		uint32_t replyMsgID = i2p::context.GetRandomNumberGenerator ().GenerateWord32 ();
-		AddPendingTunnel (replyMsgID, newTunnel); 
-		newTunnel->Build (replyMsgID, outboundTunnel);
-		return newTunnel;
-	}	
-
-	void Tunnels::AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<InboundTunnel> tunnel)
-	{
-		m_PendingInboundTunnels[replyMsgID] = tunnel; 
-	}
-
-	void Tunnels::AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> tunnel)
-	{
-		m_PendingOutboundTunnels[replyMsgID] = tunnel; 
-	}
-
-	void Tunnels::AddOutboundTunnel (std::shared_ptr<OutboundTunnel> newTunnel)
-	{
-		m_OutboundTunnels.push_back (newTunnel);
-		auto pool = newTunnel->GetTunnelPool ();
-		if (pool && pool->IsActive ())
-			pool->TunnelCreated (newTunnel);
-		else
-			newTunnel->SetTunnelPool (nullptr);
-	}	
-
-	void Tunnels::AddInboundTunnel (std::shared_ptr<InboundTunnel> newTunnel)
-	{
-		m_InboundTunnels[newTunnel->GetTunnelID ()] = newTunnel;
-		auto pool = newTunnel->GetTunnelPool ();
-		if (!pool)
-		{		
-			// build symmetric outbound tunnel
-			CreateTunnel<OutboundTunnel> (newTunnel->GetTunnelConfig ()->Invert (), GetNextOutboundTunnel ());		
-		}
-		else
-		{
-			if (pool->IsActive ())
-				pool->TunnelCreated (newTunnel);
-			else
-				newTunnel->SetTunnelPool (nullptr);
-		}	
-	}	
-
-	
-	void Tunnels::CreateZeroHopsInboundTunnel ()
-	{
-		CreateTunnel<InboundTunnel> (
-			new TunnelConfig (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >
-			    { 
-					i2p::context.GetSharedRouterInfo ()
-				}));
-	}	
-
-	int Tunnels::GetTransitTunnelsExpirationTimeout ()
-	{
-		int timeout = 0;
-		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
-		for (auto it: m_TransitTunnels)
-		{
-			int t = it.second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT - ts;
-			if (t > timeout) timeout = t;
-		}	
-		return timeout;
-	}	
-}
-}

Tunnel.h

@@ -1,199 +0,0 @@
-#ifndef TUNNEL_H__
-#define TUNNEL_H__
-
-#include <inttypes.h>
-#include <map>
-#include <list>
-#include <vector>
-#include <string>
-#include <thread>
-#include <mutex>
-#include <memory>
-#include "Queue.h"
-#include "TunnelConfig.h"
-#include "TunnelPool.h"
-#include "TransitTunnel.h"
-#include "TunnelEndpoint.h"
-#include "TunnelGateway.h"
-#include "TunnelBase.h"
-#include "I2NPProtocol.h"
-
-namespace i2p
-{
-namespace tunnel
-{	
-	const int TUNNEL_EXPIRATION_TIMEOUT = 660; // 11 minutes	
-	const int TUNNEL_EXPIRATION_THRESHOLD = 60; // 1 minute	
-	const int TUNNEL_CREATION_TIMEOUT = 30; // 30 seconds
-	const int STANDARD_NUM_RECORDS = 5; // in VariableTunnelBuild message
-
-	enum TunnelState
-	{
-		eTunnelStatePending,
-		eTunnelStateBuildReplyReceived,
-		eTunnelStateBuildFailed,
-		eTunnelStateEstablished,
-		eTunnelStateTestFailed,
-		eTunnelStateFailed,
-		eTunnelStateExpiring
-	};	
-	
-	class OutboundTunnel;
-	class InboundTunnel;
-	class Tunnel: public TunnelBase
-	{
-		public:
-
-			Tunnel (TunnelConfig * config);
-			~Tunnel ();
-
-			void Build (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
-			
-			TunnelConfig * GetTunnelConfig () const { return m_Config; }
-			TunnelState GetState () const { return m_State; };
-			void SetState (TunnelState state)  { m_State = state; };
-			bool IsEstablished () const { return m_State == eTunnelStateEstablished; };
-			bool IsFailed () const { return m_State == eTunnelStateFailed; };
-
-			std::shared_ptr<TunnelPool> GetTunnelPool () const { return m_Pool; };
-			void SetTunnelPool (std::shared_ptr<TunnelPool> pool) { m_Pool = pool; };			
-			
-			bool HandleTunnelBuildResponse (uint8_t * msg, size_t len);
-			
-			// implements TunnelBase
-			void SendTunnelDataMsg (i2p::I2NPMessage * msg);
-			void EncryptTunnelMsg (I2NPMessage * tunnelMsg); 
-			uint32_t GetNextTunnelID () const { return m_Config->GetFirstHop ()->tunnelID; };
-			const i2p::data::IdentHash& GetNextIdentHash () const { return m_Config->GetFirstHop ()->router->GetIdentHash (); };
-			
-		private:
-
-			TunnelConfig * m_Config;
-			std::shared_ptr<TunnelPool> m_Pool; // pool, tunnel belongs to, or null
-			TunnelState m_State;
-	};	
-
-	class OutboundTunnel: public Tunnel 
-	{
-		public:
-
-			OutboundTunnel (TunnelConfig * config): Tunnel (config), m_Gateway (this) {};
-
-			void SendTunnelDataMsg (const uint8_t * gwHash, uint32_t gwTunnel, i2p::I2NPMessage * msg);
-			void SendTunnelDataMsg (const std::vector<TunnelMessageBlock>& msgs); // multiple messages
-			std::shared_ptr<const i2p::data::RouterInfo> GetEndpointRouter () const 
-				{ return GetTunnelConfig ()->GetLastHop ()->router; }; 
-			size_t GetNumSentBytes () const { return m_Gateway.GetNumSentBytes (); };
-
-			// implements TunnelBase
-			void HandleTunnelDataMsg (i2p::I2NPMessage * tunnelMsg);
-			uint32_t GetTunnelID () const { return GetNextTunnelID (); };
-			
-		private:
-
-			std::mutex m_SendMutex;
-			TunnelGateway m_Gateway; 
-	};
-	
-	class InboundTunnel: public Tunnel, public std::enable_shared_from_this<InboundTunnel>
-	{
-		public:
-
-			InboundTunnel (TunnelConfig * config): Tunnel (config), m_Endpoint (true) {};
-			void HandleTunnelDataMsg (I2NPMessage * msg);
-			size_t GetNumReceivedBytes () const { return m_Endpoint.GetNumReceivedBytes (); };
-
-			// implements TunnelBase
-			uint32_t GetTunnelID () const { return GetTunnelConfig ()->GetLastHop ()->nextTunnelID; };
-		private:
-
-			TunnelEndpoint m_Endpoint; 
-	};	
-
-	
-	class Tunnels
-	{	
-		public:
-
-			Tunnels ();
-			~Tunnels ();
-			void Start ();
-			void Stop ();		
-			
-			std::shared_ptr<InboundTunnel> GetInboundTunnel (uint32_t tunnelID);
-			std::shared_ptr<InboundTunnel> GetPendingInboundTunnel (uint32_t replyMsgID);	
-			std::shared_ptr<OutboundTunnel> GetPendingOutboundTunnel (uint32_t replyMsgID);			
-			std::shared_ptr<InboundTunnel> GetNextInboundTunnel ();
-			std::shared_ptr<OutboundTunnel> GetNextOutboundTunnel ();
-			std::shared_ptr<TunnelPool> GetExploratoryPool () const { return m_ExploratoryPool; };
-			TransitTunnel * GetTransitTunnel (uint32_t tunnelID);
-			int GetTransitTunnelsExpirationTimeout ();
-			void AddTransitTunnel (TransitTunnel * tunnel);
-			void AddOutboundTunnel (std::shared_ptr<OutboundTunnel> newTunnel);
-			void AddInboundTunnel (std::shared_ptr<InboundTunnel> newTunnel);
-			void PostTunnelData (I2NPMessage * msg);
-			void PostTunnelData (const std::vector<I2NPMessage *>& msgs);
-			template<class TTunnel>
-			std::shared_ptr<TTunnel> CreateTunnel (TunnelConfig * config, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
-			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<InboundTunnel> tunnel);
-			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> tunnel);
-			std::shared_ptr<TunnelPool> CreateTunnelPool (i2p::garlic::GarlicDestination * localDestination, int numInboundHops, int numOuboundHops);
-			void DeleteTunnelPool (std::shared_ptr<TunnelPool> pool);
-			void StopTunnelPool (std::shared_ptr<TunnelPool> pool);
-			
-		private:
-		
-			template<class TTunnel>
-			std::shared_ptr<TTunnel> GetPendingTunnel (uint32_t replyMsgID, const std::map<uint32_t, std::shared_ptr<TTunnel> >& pendingTunnels);			
-
-			void HandleTunnelGatewayMsg (TunnelBase * tunnel, I2NPMessage * msg);
-
-			void Run ();	
-			void ManageTunnels ();
-			void ManageOutboundTunnels ();
-			void ManageInboundTunnels ();
-			void ManageTransitTunnels ();
-			void ManagePendingTunnels ();
-			template<class PendingTunnels>
-			void ManagePendingTunnels (PendingTunnels& pendingTunnels);
-			void ManageTunnelPools ();
-			
-			void CreateZeroHopsInboundTunnel ();
-			
-		private:
-
-			bool m_IsRunning;
-			std::thread * m_Thread;	
-			std::map<uint32_t, std::shared_ptr<InboundTunnel> > m_PendingInboundTunnels; // by replyMsgID
-			std::map<uint32_t, std::shared_ptr<OutboundTunnel> > m_PendingOutboundTunnels; // by replyMsgID
-			std::map<uint32_t, std::shared_ptr<InboundTunnel> > m_InboundTunnels;
-			std::list<std::shared_ptr<OutboundTunnel> > m_OutboundTunnels;
-			std::mutex m_TransitTunnelsMutex;
-			std::map<uint32_t, TransitTunnel *> m_TransitTunnels;
-			std::mutex m_PoolsMutex;
-			std::list<std::shared_ptr<TunnelPool>> m_Pools;
-			std::shared_ptr<TunnelPool> m_ExploratoryPool;
-			i2p::util::Queue<I2NPMessage> m_Queue;
-
-			// some stats
-			int m_NumSuccesiveTunnelCreations, m_NumFailedTunnelCreations;
-
-		public:
-
-			// for HTTP only
-			const decltype(m_OutboundTunnels)& GetOutboundTunnels () const { return m_OutboundTunnels; };
-			const decltype(m_InboundTunnels)& GetInboundTunnels () const { return m_InboundTunnels; };
-			const decltype(m_TransitTunnels)& GetTransitTunnels () const { return m_TransitTunnels; };
-			int GetQueueSize () { return m_Queue.GetSize (); };
-			int GetTunnelCreationSuccessRate () const // in percents
-			{ 
-				int totalNum = m_NumSuccesiveTunnelCreations + m_NumFailedTunnelCreations;
-				return totalNum ? m_NumSuccesiveTunnelCreations*100/totalNum : 0;
-			}		
-	};	
-
-	extern Tunnels tunnels;
-}	
-}
-
-#endif

TunnelEndpoint.cpp

@@ -1,290 +0,0 @@
-#include "I2PEndian.h"
-#include <string.h>
-#include "Log.h"
-#include "NetDb.h"
-#include "I2NPProtocol.h"
-#include "Transports.h"
-#include "RouterContext.h"
-#include "TunnelEndpoint.h"
-
-namespace i2p
-{
-namespace tunnel
-{
-	TunnelEndpoint::~TunnelEndpoint ()
-	{
-		for (auto it: m_IncompleteMessages)
-			i2p::DeleteI2NPMessage (it.second.data);
-		for (auto it: m_OutOfSequenceFragments)
-			i2p::DeleteI2NPMessage (it.second.data);
-	}	
-	
-	void TunnelEndpoint::HandleDecryptedTunnelDataMsg (I2NPMessage * msg)
-	{
-		m_NumReceivedBytes += TUNNEL_DATA_MSG_SIZE;
-		
-		uint8_t * decrypted = msg->GetPayload () + 20; // 4 + 16
-		uint8_t * zero = (uint8_t *)memchr (decrypted + 4, 0, TUNNEL_DATA_ENCRYPTED_SIZE - 4); // witout 4-byte checksum
-		if (zero)
-		{	
-			uint8_t * fragment = zero + 1;
-			// verify checksum
-			memcpy (msg->GetPayload () + TUNNEL_DATA_MSG_SIZE, msg->GetPayload () + 4, 16); // copy iv to the end
-			uint8_t hash[32];
-			CryptoPP::SHA256().CalculateDigest (hash, fragment, TUNNEL_DATA_MSG_SIZE -(fragment - msg->GetPayload ()) + 16); // payload + iv
-			if (memcmp (hash, decrypted, 4))
-			{
-				LogPrint (eLogError, "TunnelMessage: checksum verification failed");
-				i2p::DeleteI2NPMessage (msg);
-				return;
-			}	
-			// process fragments
-			while (fragment < decrypted + TUNNEL_DATA_ENCRYPTED_SIZE)
-			{
-				uint8_t flag = fragment[0];
-				fragment++;
-				
-				bool isFollowOnFragment = flag & 0x80, isLastFragment = true;		
-				uint32_t msgID = 0;
-				int fragmentNum = 0;
-				TunnelMessageBlockEx m;
-				if (!isFollowOnFragment)
-				{	
-					// first fragment
-					
-					m.deliveryType = (TunnelDeliveryType)((flag >> 5) & 0x03);
-					switch (m.deliveryType)
-					{
-						case eDeliveryTypeLocal: // 0
-						break;
-					  	case eDeliveryTypeTunnel: // 1
-							m.tunnelID = bufbe32toh (fragment);
-							fragment += 4; // tunnelID
-							m.hash = i2p::data::IdentHash (fragment);
-							fragment += 32; // hash
-						break;
-						case eDeliveryTypeRouter: // 2
-							m.hash = i2p::data::IdentHash (fragment);	
-							fragment += 32; // to hash
-						break;
-						default:
-							;
-					}	
-
-					bool isFragmented = flag & 0x08;
-					if (isFragmented)
-					{
-						// Message ID
-						msgID = bufbe32toh (fragment); 	
-						fragment += 4;
-						isLastFragment = false;
-					}	
-				}
-				else
-				{
-					// follow on
-					msgID = bufbe32toh (fragment); // MessageID			
-					fragment += 4; 
-					fragmentNum = (flag >> 1) & 0x3F; // 6 bits
-					isLastFragment = flag & 0x01;
-				}	
-				
-				uint16_t size = bufbe16toh (fragment);
-				fragment += 2;
-
-				msg->offset = fragment - msg->buf;
-				msg->len = msg->offset + size;
-				if (fragment + size < decrypted + TUNNEL_DATA_ENCRYPTED_SIZE)
-				{
-					// this is not last message. we have to copy it
-					m.data = NewI2NPShortMessage ();
-					m.data->offset += TUNNEL_GATEWAY_HEADER_SIZE; // reserve room for TunnelGateway header
-					m.data->len += TUNNEL_GATEWAY_HEADER_SIZE;
-					*(m.data) = *msg;
-				}
-				else
-					m.data = msg;
-				
-				if (!isFollowOnFragment && isLastFragment)
-					HandleNextMessage (m);
-				else
-				{
-					if (msgID) // msgID is presented, assume message is fragmented
-					{
-						if (!isFollowOnFragment) // create new incomlete message
-						{
-							m.nextFragmentNum = 1;
-							auto ret = m_IncompleteMessages.insert (std::pair<uint32_t, TunnelMessageBlockEx>(msgID, m));
-							if (ret.second)
-								HandleOutOfSequenceFragment (msgID, ret.first->second);
-							else
-							{
-								LogPrint (eLogError, "Incomplete message ", msgID, "already exists");
-								DeleteI2NPMessage (m.data);
-							}	
-						}
-						else
-						{
-							m.nextFragmentNum = fragmentNum;
-							HandleFollowOnFragment (msgID, isLastFragment, m);
-						}	
-					}
-					else	
-					{	
-						LogPrint (eLogError, "Message is fragmented, but msgID is not presented");
-						DeleteI2NPMessage (m.data);
-					}	
-				}	
-					
-				fragment += size;
-			}	
-		}	
-		else
-		{	
-			LogPrint (eLogError, "TunnelMessage: zero not found");
-			i2p::DeleteI2NPMessage (msg);	
-		}	
-	}	
-
-	void TunnelEndpoint::HandleFollowOnFragment (uint32_t msgID, bool isLastFragment, const TunnelMessageBlockEx& m)
-	{
-		auto fragment = m.data->GetBuffer ();
-		auto size = m.data->GetLength ();
-		auto it = m_IncompleteMessages.find (msgID);
-		if (it != m_IncompleteMessages.end())
-		{
-			auto& msg = it->second;
-			if (m.nextFragmentNum == msg.nextFragmentNum)
-			{
-				if (msg.data->len + size < I2NP_MAX_MESSAGE_SIZE) // check if message is not too long
-				{	
-					if (msg.data->len + size > msg.data->maxLen)
-					{
-						LogPrint (eLogInfo, "Tunnel endpoint I2NP message size ", msg.data->maxLen, " is not enough");
-						I2NPMessage * newMsg = NewI2NPMessage ();
-						*newMsg = *(msg.data);
-						DeleteI2NPMessage (msg.data);
-						msg.data = newMsg;
-					}
-					memcpy (msg.data->buf + msg.data->len, fragment, size); // concatenate fragment
-					msg.data->len += size;
-					if (isLastFragment)
-					{
-						// message complete
-						HandleNextMessage (msg);	
-						m_IncompleteMessages.erase (it); 
-					}	
-					else
-					{	
-						msg.nextFragmentNum++;
-						HandleOutOfSequenceFragment (msgID, msg);
-					}	
-				}
-				else
-				{
-					LogPrint (eLogError, "Fragment ", m.nextFragmentNum, " of message ", msgID, "exceeds max I2NP message size. Message dropped");
-					i2p::DeleteI2NPMessage (msg.data);
-					m_IncompleteMessages.erase (it);
-				}
-				i2p::DeleteI2NPMessage (m.data);
-			}
-			else
-			{	
-				LogPrint (eLogInfo, "Unexpected fragment ", (int)m.nextFragmentNum, " instead ", (int)msg.nextFragmentNum, " of message ", msgID, ". Saved");
-				AddOutOfSequenceFragment (msgID, m.nextFragmentNum, isLastFragment, m.data);
-			}
-		}
-		else
-		{	
-			LogPrint (eLogInfo, "First fragment of message ", msgID, " not found. Saved");
-			AddOutOfSequenceFragment (msgID, m.nextFragmentNum, isLastFragment, m.data);
-		}	
-	}	
-
-	void TunnelEndpoint::AddOutOfSequenceFragment (uint32_t msgID, uint8_t fragmentNum, bool isLastFragment, I2NPMessage * data)
-	{
-		auto it = m_OutOfSequenceFragments.find (msgID);
-		if (it == m_OutOfSequenceFragments.end ())
-			m_OutOfSequenceFragments.insert (std::pair<uint32_t, Fragment> (msgID, {fragmentNum, isLastFragment, data}));	
-		else
-			i2p::DeleteI2NPMessage (data);
-	}	
-
-	void TunnelEndpoint::HandleOutOfSequenceFragment (uint32_t msgID, TunnelMessageBlockEx& msg)
-	{
-		auto it = m_OutOfSequenceFragments.find (msgID);
-		if (it != m_OutOfSequenceFragments.end ())
-		{
-			if (it->second.fragmentNum == msg.nextFragmentNum)
-			{
-				LogPrint (eLogInfo, "Out-of-sequence fragment ", (int)it->second.fragmentNum, " of message ", msgID, " found");
-				auto size = it->second.data->GetLength ();
-				if (msg.data->len + size > msg.data->maxLen)
-				{
-					LogPrint (eLogInfo, "Tunnel endpoint I2NP message size ", msg.data->maxLen, " is not enough");
-					I2NPMessage * newMsg = NewI2NPMessage ();
-					*newMsg = *(msg.data);
-					DeleteI2NPMessage (msg.data);
-					msg.data = newMsg;
-				}
-				memcpy (msg.data->buf + msg.data->len, it->second.data->GetBuffer (), size); // concatenate out-of-sync fragment
-				msg.data->len += size;
-				if (it->second.isLastFragment)
-				{
-					// message complete
-					HandleNextMessage (msg);	
-					m_IncompleteMessages.erase (msgID); 
-				}	
-				else
-					msg.nextFragmentNum++;
-				i2p::DeleteI2NPMessage (it->second.data);
-				m_OutOfSequenceFragments.erase (it);
-			}	
-		}	
-	}	
-	
-	void TunnelEndpoint::HandleNextMessage (const TunnelMessageBlock& msg)
-	{
-		LogPrint (eLogInfo, "TunnelMessage: handle fragment of ", msg.data->GetLength ()," bytes. Msg type ", (int)msg.data->GetTypeID ());
-		switch (msg.deliveryType)
-		{
-			case eDeliveryTypeLocal:
-				i2p::HandleI2NPMessage (msg.data);
-			break;
-			case eDeliveryTypeTunnel:
-				i2p::transport::transports.SendMessage (msg.hash, i2p::CreateTunnelGatewayMsg (msg.tunnelID, msg.data));
-			break;
-			case eDeliveryTypeRouter:
-				if (msg.hash == i2p::context.GetRouterInfo ().GetIdentHash ()) // check if message is sent to us
-					i2p::HandleI2NPMessage (msg.data);
-				else
-				{	
-					// to somebody else
-					if (!m_IsInbound) // outbound transit tunnel
-					{
-						auto typeID = msg.data->GetTypeID ();
-						if (typeID == eI2NPDatabaseStore || typeID == eI2NPDatabaseSearchReply )
-						{
-							// catch RI or reply with new list of routers
-							auto ds = NewI2NPShortMessage ();
-							*ds = *(msg.data);
-							i2p::data::netdb.PostI2NPMsg (ds);
-						}
-						i2p::transport::transports.SendMessage (msg.hash, msg.data);
-					}
-					else // we shouldn't send this message. possible leakage 
-					{
-						LogPrint (eLogError, "Message to another router arrived from an inbound tunnel. Dropped");
-						i2p::DeleteI2NPMessage (msg.data);
-					}
-				}
-			break;
-			default:
-			{	
-				LogPrint (eLogError, "TunnelMessage: Unknown delivery type ", (int)msg.deliveryType);
-				i2p::DeleteI2NPMessage (msg.data);
-			}	
-		};	
-	}	
-}		
-}

TunnelPool.cpp

@@ -1,360 +0,0 @@
-#include "I2PEndian.h"
-#include "CryptoConst.h"
-#include "Tunnel.h"
-#include "NetDb.h"
-#include "Timestamp.h"
-#include "Garlic.h"
-#include "TunnelPool.h"
-
-namespace i2p
-{
-namespace tunnel
-{
-	TunnelPool::TunnelPool (i2p::garlic::GarlicDestination * localDestination, int numInboundHops, int numOutboundHops, int numTunnels):
-		m_LocalDestination (localDestination), m_NumInboundHops (numInboundHops), m_NumOutboundHops (numOutboundHops),
-		m_NumTunnels (numTunnels), m_IsActive (true)
-	{
-	}
-
-	TunnelPool::~TunnelPool ()
-	{
-		DetachTunnels ();
-	}
-
-	void TunnelPool::DetachTunnels ()
-	{
-		{
-			std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);	
-			for (auto it: m_InboundTunnels)
-				it->SetTunnelPool (nullptr);
-			m_InboundTunnels.clear ();
-		}
-		{
-			std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);
-			for (auto it: m_OutboundTunnels)
-				it->SetTunnelPool (nullptr);
-			m_OutboundTunnels.clear ();
-		}
-		m_Tests.clear ();
-	}	
-		
-	void TunnelPool::TunnelCreated (std::shared_ptr<InboundTunnel> createdTunnel)
-	{
-		if (!m_IsActive) return;
-		{
-			std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);
-			m_InboundTunnels.insert (createdTunnel);
-		}
-		if (m_LocalDestination)
-			m_LocalDestination->SetLeaseSetUpdated ();
-	}
-
-	void TunnelPool::TunnelExpired (std::shared_ptr<InboundTunnel> expiredTunnel)
-	{
-		if (expiredTunnel)
-		{	
-			expiredTunnel->SetTunnelPool (nullptr);
-			for (auto it: m_Tests)
-				if (it.second.second == expiredTunnel) it.second.second = nullptr;
-			RecreateInboundTunnel (expiredTunnel);	
-
-			std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);
-			m_InboundTunnels.erase (expiredTunnel);
-		}	
-	}	
-
-	void TunnelPool::TunnelCreated (std::shared_ptr<OutboundTunnel> createdTunnel)
-	{
-		if (!m_IsActive) return;
-		std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);
-		m_OutboundTunnels.insert (createdTunnel);
-	}
-
-	void TunnelPool::TunnelExpired (std::shared_ptr<OutboundTunnel> expiredTunnel)
-	{
-		if (expiredTunnel)
-		{
-			expiredTunnel->SetTunnelPool (nullptr);
-			for (auto it: m_Tests)
-				if (it.second.first == expiredTunnel) it.second.first = nullptr;
-			RecreateOutboundTunnel (expiredTunnel);
-
-			std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);
-			m_OutboundTunnels.erase (expiredTunnel);
-		}
-	}
-		
-	std::vector<std::shared_ptr<InboundTunnel> > TunnelPool::GetInboundTunnels (int num) const
-	{
-		std::vector<std::shared_ptr<InboundTunnel> > v;
-		int i = 0;
-		std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);
-		for (auto it : m_InboundTunnels)
-		{
-			if (i >= num) break;
-			if (it->IsEstablished ())
-			{
-				v.push_back (it);
-				i++;
-			}	
-		}	
-		return v;
-	}
-
-	std::shared_ptr<OutboundTunnel> TunnelPool::GetNextOutboundTunnel (std::shared_ptr<OutboundTunnel> excluded) const
-	{
-		std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);	
-		return GetNextTunnel (m_OutboundTunnels, excluded);
-	}	
-
-	std::shared_ptr<InboundTunnel> TunnelPool::GetNextInboundTunnel (std::shared_ptr<InboundTunnel> excluded) const
-	{
-		std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);	
-		return GetNextTunnel (m_InboundTunnels, excluded);
-	}
-
-	template<class TTunnels>
-	typename TTunnels::value_type TunnelPool::GetNextTunnel (TTunnels& tunnels, typename TTunnels::value_type excluded) const
-	{
-		if (tunnels.empty ()) return nullptr;		
-		CryptoPP::RandomNumberGenerator& rnd = i2p::context.GetRandomNumberGenerator ();
-		uint32_t ind = rnd.GenerateWord32 (0, tunnels.size ()/2), i = 0;
-		typename TTunnels::value_type tunnel = nullptr;
-		for (auto it: tunnels)
-		{	
-			if (it->IsEstablished () && it != excluded)
-			{
-				tunnel = it;
-				i++;
-			}
-			if (i > ind && tunnel) break;
-		}
-		if (!tunnel && excluded && excluded->IsEstablished ()) tunnel = excluded;
-		return tunnel;
-	}
-
-	void TunnelPool::CreateTunnels ()
-	{
-		int num = 0;
-		{
-			std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);
-			for (auto it : m_InboundTunnels)
-				if (it->IsEstablished ()) num++;
-		}
-		for (int i = num; i < m_NumTunnels; i++)
-			CreateInboundTunnel ();	
-		
-		num = 0;
-		{
-			std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);	
-			for (auto it : m_OutboundTunnels)
-				if (it->IsEstablished ()) num++;
-		}
-		for (int i = num; i < m_NumTunnels; i++)
-			CreateOutboundTunnel ();	
-	}
-
-	void TunnelPool::TestTunnels ()
-	{
-		auto& rnd = i2p::context.GetRandomNumberGenerator ();
-		for (auto it: m_Tests)
-		{
-			LogPrint ("Tunnel test ", (int)it.first, " failed"); 
-			// if test failed again with another tunnel we consider it failed
-			if (it.second.first)
-			{	
-				if (it.second.first->GetState () == eTunnelStateTestFailed)
-				{	
-					it.second.first->SetState (eTunnelStateFailed);
-					std::unique_lock<std::mutex> l(m_OutboundTunnelsMutex);
-					m_OutboundTunnels.erase (it.second.first);
-				}
-				else
-					it.second.first->SetState (eTunnelStateTestFailed);
-			}	
-			if (it.second.second)
-			{
-				if (it.second.second->GetState () == eTunnelStateTestFailed)
-				{	
-					it.second.second->SetState (eTunnelStateFailed);
-					{
-						std::unique_lock<std::mutex> l(m_InboundTunnelsMutex);
-						m_InboundTunnels.erase (it.second.second);
-					}
-					if (m_LocalDestination)
-						m_LocalDestination->SetLeaseSetUpdated ();
-				}	
-				else
-					it.second.second->SetState (eTunnelStateTestFailed);
-			}	
-		}
-		m_Tests.clear ();
-		// new tests	
-		auto it1 = m_OutboundTunnels.begin ();
-		auto it2 = m_InboundTunnels.begin ();
-		while (it1 != m_OutboundTunnels.end () && it2 != m_InboundTunnels.end ())
-		{
-			bool failed = false;
-			if ((*it1)->IsFailed ())
-			{	
-				failed = true;
-				it1++;
-			}
-			if ((*it2)->IsFailed ())
-			{	
-				failed = true;
-				it2++;
-			}
-			if (!failed)
-			{
- 				uint32_t msgID = rnd.GenerateWord32 ();
- 				m_Tests[msgID] = std::make_pair (*it1, *it2);
- 				(*it1)->SendTunnelDataMsg ((*it2)->GetNextIdentHash (), (*it2)->GetNextTunnelID (),
-					CreateDeliveryStatusMsg (msgID));
-				it1++; it2++;
-			}	
-		}
-	}
-
-	void TunnelPool::ProcessGarlicMessage (I2NPMessage * msg)
-	{
-		if (m_LocalDestination)
-			m_LocalDestination->ProcessGarlicMessage (msg);
-		else
-		{
-			LogPrint (eLogWarning, "Local destination doesn't exist. Dropped");
-			DeleteI2NPMessage (msg);
-		}	
-	}	
-		
-	void TunnelPool::ProcessDeliveryStatus (I2NPMessage * msg)
-	{
-		const uint8_t * buf = msg->GetPayload ();
-		uint32_t msgID = bufbe32toh (buf);
-		buf += 4;	
-		uint64_t timestamp = bufbe64toh (buf);
-
-		auto it = m_Tests.find (msgID);
-		if (it != m_Tests.end ())
-		{
-			// restore from test failed state if any
-			if (it->second.first->GetState () == eTunnelStateTestFailed)
-				it->second.first->SetState (eTunnelStateEstablished);
-			if (it->second.second->GetState () == eTunnelStateTestFailed)
-				it->second.second->SetState (eTunnelStateEstablished);
-			LogPrint ("Tunnel test ", it->first, " successive. ", i2p::util::GetMillisecondsSinceEpoch () - timestamp, " milliseconds");
-			m_Tests.erase (it);
-			DeleteI2NPMessage (msg);
-		}
-		else
-		{
-			if (m_LocalDestination)
-				m_LocalDestination->ProcessDeliveryStatusMessage (msg);
-			else
-			{	
-				LogPrint (eLogWarning, "Local destination doesn't exist. Dropped");
-				DeleteI2NPMessage (msg);
-			}	
-		}	
-	}
-
-	std::shared_ptr<const i2p::data::RouterInfo> TunnelPool::SelectNextHop (std::shared_ptr<const i2p::data::RouterInfo> prevHop) const
-	{
-		bool isExploratory = (m_LocalDestination == &i2p::context); // TODO: implement it better
-		auto hop = isExploratory ? i2p::data::netdb.GetRandomRouter (prevHop): 
-			i2p::data::netdb.GetHighBandwidthRandomRouter (prevHop);
-		if (!isExploratory && hop && hop->GetProfile ()->IsBad ())
-		{
-			LogPrint (eLogInfo, "Selected peer for tunnel has bad profile. Selecting another"); 
-			hop = i2p::data::netdb.GetHighBandwidthRandomRouter (prevHop);
-		}	
-			
-		if (!hop)
-			hop = i2p::data::netdb.GetRandomRouter ();
-		return hop;	
-	}	
-		
-	void TunnelPool::CreateInboundTunnel ()
-	{
-		auto outboundTunnel = GetNextOutboundTunnel ();
-		if (!outboundTunnel)
-			outboundTunnel = tunnels.GetNextOutboundTunnel ();
-		LogPrint ("Creating destination inbound tunnel...");
-		auto prevHop = i2p::context.GetSharedRouterInfo ();	
-		std::vector<std::shared_ptr<const i2p::data::RouterInfo> > hops;
-		int numHops = m_NumInboundHops;
-		if (outboundTunnel)
-		{	
-			// last hop
-			auto hop = outboundTunnel->GetTunnelConfig ()->GetFirstHop ()->router;
-			if (hop->GetIdentHash () != i2p::context.GetIdentHash ()) // outbound shouldn't be zero-hop tunnel
-			{	
-				prevHop = hop;
-				hops.push_back (prevHop);
-				numHops--;
-			}
-		}
-		for (int i = 0; i < numHops; i++)
-		{
-			auto hop = SelectNextHop (prevHop);
-			prevHop = hop;
-			hops.push_back (hop);
-		}		
-		std::reverse (hops.begin (), hops.end ());	
-		auto tunnel = tunnels.CreateTunnel<InboundTunnel> (new TunnelConfig (hops), outboundTunnel);
-		tunnel->SetTunnelPool (shared_from_this ());
-	}
-
-	void TunnelPool::RecreateInboundTunnel (std::shared_ptr<InboundTunnel> tunnel)
-	{
-		auto outboundTunnel = GetNextOutboundTunnel ();
-		if (!outboundTunnel)
-			outboundTunnel = tunnels.GetNextOutboundTunnel ();
-		LogPrint ("Re-creating destination inbound tunnel...");
-		auto newTunnel = tunnels.CreateTunnel<InboundTunnel> (tunnel->GetTunnelConfig ()->Clone (), outboundTunnel);
-		newTunnel->SetTunnelPool (shared_from_this());
-	}	
-		
-	void TunnelPool::CreateOutboundTunnel ()
-	{
-		auto inboundTunnel = GetNextInboundTunnel ();
-		if (!inboundTunnel)
-			inboundTunnel = tunnels.GetNextInboundTunnel ();
-		if (inboundTunnel)
-		{	
-			LogPrint ("Creating destination outbound tunnel...");
-
-			auto prevHop = i2p::context.GetSharedRouterInfo ();
-			std::vector<std::shared_ptr<const i2p::data::RouterInfo> > hops;
-			for (int i = 0; i < m_NumOutboundHops; i++)
-			{
-				auto hop = SelectNextHop (prevHop);
-				prevHop = hop;
-				hops.push_back (hop);
-			}	
-				
-			auto tunnel = tunnels.CreateTunnel<OutboundTunnel> (
-				new TunnelConfig (hops, inboundTunnel->GetTunnelConfig ()));
-			tunnel->SetTunnelPool (shared_from_this ());
-		}	
-		else
-			LogPrint ("Can't create outbound tunnel. No inbound tunnels found");
-	}	
-		
-	void TunnelPool::RecreateOutboundTunnel (std::shared_ptr<OutboundTunnel> tunnel)
-	{
-		auto inboundTunnel = GetNextInboundTunnel ();
-		if (!inboundTunnel)
-			inboundTunnel = tunnels.GetNextInboundTunnel ();
-		if (inboundTunnel)
-		{	
-			LogPrint ("Re-creating destination outbound tunnel...");
-			auto newTunnel = tunnels.CreateTunnel<OutboundTunnel> (
-				tunnel->GetTunnelConfig ()->Clone (inboundTunnel->GetTunnelConfig ()));
-			newTunnel->SetTunnelPool (shared_from_this ());
-		}	
-		else
-			LogPrint ("Can't re-create outbound tunnel. No inbound tunnels found");
-	}			
-}
-}

TunnelPool.h

@@ -1,85 +0,0 @@
-#ifndef TUNNEL_POOL__
-#define TUNNEL_POOL__
-
-#include <inttypes.h>
-#include <set>
-#include <vector>
-#include <utility>
-#include <mutex>
-#include <memory>
-#include "Identity.h"
-#include "LeaseSet.h"
-#include "RouterInfo.h"
-#include "I2NPProtocol.h"
-#include "TunnelBase.h"
-#include "RouterContext.h"
-#include "Garlic.h"
-
-namespace i2p
-{
-namespace tunnel
-{
-	class Tunnel;
-	class InboundTunnel;
-	class OutboundTunnel;
-
-	class TunnelPool: public std::enable_shared_from_this<TunnelPool> // per local destination
-	{
-		public:
-
-			TunnelPool (i2p::garlic::GarlicDestination * localDestination, int numInboundHops, int numOutboundHops, int numTunnels = 5);
-			~TunnelPool ();
-		
-			i2p::garlic::GarlicDestination * GetLocalDestination () const { return m_LocalDestination; };
-			void SetLocalDestination (i2p::garlic::GarlicDestination * destination) { m_LocalDestination = destination; };
-
-			void CreateTunnels ();
-			void TunnelCreated (std::shared_ptr<InboundTunnel> createdTunnel);
-			void TunnelExpired (std::shared_ptr<InboundTunnel> expiredTunnel);
-			void TunnelCreated (std::shared_ptr<OutboundTunnel> createdTunnel);
-			void TunnelExpired (std::shared_ptr<OutboundTunnel> expiredTunnel);
-			std::vector<std::shared_ptr<InboundTunnel> > GetInboundTunnels (int num) const;
-			std::shared_ptr<OutboundTunnel> GetNextOutboundTunnel (std::shared_ptr<OutboundTunnel> excluded = nullptr) const;
-			std::shared_ptr<InboundTunnel> GetNextInboundTunnel (std::shared_ptr<InboundTunnel> excluded = nullptr) const;		
-
-			void TestTunnels ();
-			void ProcessGarlicMessage (I2NPMessage * msg);
-			void ProcessDeliveryStatus (I2NPMessage * msg);
-
-			bool IsActive () const { return m_IsActive; };
-			void SetActive (bool isActive) { m_IsActive = isActive; };
-			void DetachTunnels ();
-			
-		private:
-
-			void CreateInboundTunnel ();	
-			void CreateOutboundTunnel ();
-			void RecreateInboundTunnel (std::shared_ptr<InboundTunnel> tunnel);
-			void RecreateOutboundTunnel (std::shared_ptr<OutboundTunnel> tunnel);
-			template<class TTunnels>
-			typename TTunnels::value_type GetNextTunnel (TTunnels& tunnels, typename TTunnels::value_type excluded) const;
-			std::shared_ptr<const i2p::data::RouterInfo> SelectNextHop (std::shared_ptr<const i2p::data::RouterInfo> prevHop) const;
-			
-		private:
-
-			i2p::garlic::GarlicDestination * m_LocalDestination;
-			int m_NumInboundHops, m_NumOutboundHops, m_NumTunnels;
-			mutable std::mutex m_InboundTunnelsMutex;
-			std::set<std::shared_ptr<InboundTunnel>, TunnelCreationTimeCmp> m_InboundTunnels; // recent tunnel appears first
-			mutable std::mutex m_OutboundTunnelsMutex;
-			std::set<std::shared_ptr<OutboundTunnel>, TunnelCreationTimeCmp> m_OutboundTunnels;
-			std::map<uint32_t, std::pair<std::shared_ptr<OutboundTunnel>, std::shared_ptr<InboundTunnel> > > m_Tests;
-			bool m_IsActive;
-
-		public:
-
-			// for HTTP only
-			const decltype(m_OutboundTunnels)& GetOutboundTunnels () const { return m_OutboundTunnels; };
-			const decltype(m_InboundTunnels)& GetInboundTunnels () const { return m_InboundTunnels; };
-
-	};	
-}
-}
-
-#endif
-

UPnP.cpp

@@ -1,270 +0,0 @@
-#ifdef USE_UPNP
-#include <string>
-#include <thread>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-#include <boost/thread/thread.hpp>
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-
-#include "Log.h"
-#include "RouterContext.h"
-#include "UPnP.h"
-#include "NetDb.h"
-#include "util.h"
-
-#include <miniupnpc/miniupnpc.h>
-#include <miniupnpc/upnpcommands.h>
-#include <dlfcn.h>
-
-#ifndef UPNPDISCOVER_SUCCESS
-/* miniupnpc 1.5 */
-typedef UPNPDev* (*upnp_upnpDiscoverFunc) (int, const char *, const char *, int);
-typedef int (*upnp_UPNP_AddPortMappingFunc) (const char *, const char *, const char *, const char *, 
-                                             const char *, const char *, const char *, const char *);
-#else
-/* miniupnpc 1.6 */
-typedef UPNPDev* (*upnp_upnpDiscoverFunc) (int, const char *, const char *, int, int, int *);
-typedef int (*upnp_UPNP_AddPortMappingFunc) (const char *, const char *, const char *, const char *, 
-                                             const char *, const char *, const char *, const char *, const char *);
-#endif
-typedef int (*upnp_UPNP_GetValidIGDFunc) (struct UPNPDev *, struct UPNPUrls *, struct IGDdatas *, char *, int);
-typedef int (*upnp_UPNP_GetExternalIPAddressFunc) (const char *, const char *, char *);
-typedef int (*upnp_UPNP_DeletePortMappingFunc) (const char *, const char *, const char *, const char *, const char *);
-typedef void (*upnp_freeUPNPDevlistFunc) (struct UPNPDev *);
-typedef void (*upnp_FreeUPNPUrlsFunc) (struct UPNPUrls *);
-
-namespace i2p
-{
-namespace UPnP
-{
-    UPnP upnpc;
-
-    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()
-    {
-        m_Thread = new std::thread (std::bind (&UPnP::Run, this));
-    }
-    
-    UPnP::~UPnP ()
-    {
-    } 
-
-    void UPnP::Run ()
-    {
-#ifdef MAC_OSX
-        m_Module = dlopen ("libminiupnpc.dylib", RTLD_LAZY);
-#elif _WIN32
-        m_Module = LoadLibrary ("libminiupnpc.dll");
-        if (m_Module == NULL)
-        {
-            LogPrint ("Error loading UPNP library. This often happens if there is version mismatch!");
-            return;
-        }
-        else
-        {
-            m_IsModuleLoaded = true;
-        }
-#else
-        m_Module = dlopen ("libminiupnpc.so", RTLD_LAZY);
-#endif
-#ifndef _WIN32
-        if (!m_Module)
-        {
-            LogPrint ("no UPnP module available (", dlerror (), ")");
-            return;
-        }
-        else
-        {
-            m_IsModuleLoaded = true;
-        }
-#endif
-        for (auto& address : context.GetRouterInfo ().GetAddresses ())
-        {
-            if (!address.host.is_v6 ())
-            {
-                m_Port = std::to_string (util::config::GetArg ("-port", address.port));
-                Discover ();
-                if (address.transportStyle == data::RouterInfo::eTransportSSU )
-                {
-                    TryPortMapping (I2P_UPNP_UDP);
-                }
-                else if (address.transportStyle == data::RouterInfo::eTransportNTCP )
-                {
-                    TryPortMapping (I2P_UPNP_TCP);
-                }
-            }
-        }
-    } 
-        
-    void UPnP::Discover ()
-    {
-        const char *error;
-#ifdef _WIN32
-        upnp_upnpDiscoverFunc upnpDiscoverFunc = (upnp_upnpDiscoverFunc) GetProcAddress (m_Module, "upnpDiscover");
-#else
-        upnp_upnpDiscoverFunc upnpDiscoverFunc = (upnp_upnpDiscoverFunc) dlsym (m_Module, "upnpDiscover");
-        // reinterpret_cast<upnp_upnpDiscoverFunc> (dlsym(...));
-        if ( (error = dlerror ()))
-        {
-            LogPrint ("Error loading UPNP library. This often happens if there is version mismatch!");
-            return;
-        }
-#endif // _WIN32
-#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;
-#ifdef _WIN32
-        upnp_UPNP_GetValidIGDFunc UPNP_GetValidIGDFunc = (upnp_UPNP_GetValidIGDFunc) GetProcAddress (m_Module, "UPNP_GetValidIGD");
-#else
-        upnp_UPNP_GetValidIGDFunc UPNP_GetValidIGDFunc = (upnp_UPNP_GetValidIGDFunc) dlsym (m_Module, "UPNP_GetValidIGD");
-#endif
-        r = (*UPNP_GetValidIGDFunc) (m_Devlist, &m_upnpUrls, &m_upnpData, m_NetworkAddr, sizeof (m_NetworkAddr));
-        if (r == 1)
-        {
-            upnp_UPNP_GetExternalIPAddressFunc UPNP_GetExternalIPAddressFunc = (upnp_UPNP_GetExternalIPAddressFunc) dlsym (m_Module, "UPNP_GetExternalIPAddress");
-            r = UPNP_GetExternalIPAddressFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, m_externalIPAddress);
-            if(r != UPNPCOMMAND_SUCCESS)
-            {
-                LogPrint ("UPnP: UPNP_GetExternalIPAddress () returned ", r);
-                return;
-            }
-            else
-            {
-                if (m_externalIPAddress[0])
-                {
-                    LogPrint ("UPnP: ExternalIPAddress = ", m_externalIPAddress);
-                    i2p::context.UpdateAddress (boost::asio::ip::address::from_string (m_externalIPAddress));
-                    return;
-                }
-                else
-                {
-                    LogPrint ("UPnP: GetExternalIPAddress failed.");
-                    return;
-                }
-            }
-        }
-    }
-
-    void UPnP::TryPortMapping (int type)
-    {
-        std::string strType;
-        switch (type)
-        {
-            case I2P_UPNP_TCP:
-                strType = "TCP";
-                break;
-            case I2P_UPNP_UDP:
-            default:
-                strType = "UDP";
-        }
-        int r;
-        std::string strDesc = "I2Pd";
-        try {
-            for (;;) {
-#ifdef _WIN32
-                upnp_UPNP_AddPortMappingFunc UPNP_AddPortMappingFunc = (upnp_UPNP_AddPortMappingFunc) GetProcAddress (m_Module, "UPNP_AddPortMapping");
-#else
-                upnp_UPNP_AddPortMappingFunc UPNP_AddPortMappingFunc = (upnp_UPNP_AddPortMappingFunc) dlsym (m_Module, "UPNP_AddPortMapping");
-#endif
-#ifndef UPNPDISCOVER_SUCCESS
-                /* miniupnpc 1.5 */
-                r = UPNP_AddPortMappingFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, m_Port.c_str (), m_Port.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, m_Port.c_str (), m_Port.c_str (), m_NetworkAddr, strDesc.c_str (), strType.c_str (), 0, "0");
-#endif
-                if (r!=UPNPCOMMAND_SUCCESS)
-                {
-                    LogPrint ("AddPortMapping (", m_Port.c_str () ,", ", m_Port.c_str () ,", ", m_NetworkAddr, ") failed with code ", r);
-                    return;
-                }
-                else
-                {
-                    LogPrint ("UPnP Port Mapping successful. (", m_NetworkAddr ,":", m_Port.c_str(), " type ", strType.c_str () ," -> ", m_externalIPAddress ,":", m_Port.c_str() ,")");
-                    return;
-                }
-                sleep(20*60);
-            }
-        }
-        catch (boost::thread_interrupted)
-        {
-            CloseMapping(type);
-            Close();
-            throw;
-        }
-    }
-
-    void UPnP::CloseMapping (int type)
-    {
-        std::string strType;
-        switch (type)
-        {
-            case I2P_UPNP_TCP:
-                strType = "TCP";
-                break;
-            case I2P_UPNP_UDP:
-            default:
-                strType = "UDP";
-        }
-        int r = 0;
-#ifdef _WIN32
-        upnp_UPNP_DeletePortMappingFunc UPNP_DeletePortMappingFunc = (upnp_UPNP_DeletePortMappingFunc) GetProcAddress (m_Module, "UPNP_DeletePortMapping");
-#else
-        upnp_UPNP_DeletePortMappingFunc UPNP_DeletePortMappingFunc = (upnp_UPNP_DeletePortMappingFunc) dlsym (m_Module, "UPNP_DeletePortMapping");
-#endif
-        r = UPNP_DeletePortMappingFunc (m_upnpUrls.controlURL, m_upnpData.first.servicetype, m_Port.c_str (), strType.c_str (), 0);
-        LogPrint ("UPNP_DeletePortMapping() returned : ", r, "\n");
-    }
-
-    void UPnP::Close ()
-    {
-#ifdef _WIN32
-        upnp_freeUPNPDevlistFunc freeUPNPDevlistFunc = (upnp_freeUPNPDevlistFunc) GetProcAddress (m_Module, "freeUPNPDevlist");
-#else
-        upnp_freeUPNPDevlistFunc freeUPNPDevlistFunc = (upnp_freeUPNPDevlistFunc) dlsym (m_Module, "freeUPNPDevlist");
-#endif
-        freeUPNPDevlistFunc (m_Devlist);
-        m_Devlist = 0;
-#ifdef _WIN32
-        upnp_FreeUPNPUrlsFunc FreeUPNPUrlsFunc = (upnp_FreeUPNPUrlsFunc) GetProcAddress (m_Module, "FreeUPNPUrlsFunc");
-#else
-        upnp_FreeUPNPUrlsFunc FreeUPNPUrlsFunc = (upnp_FreeUPNPUrlsFunc) dlsym (m_Module, "FreeUPNPUrlsFunc");
-#endif
-        FreeUPNPUrlsFunc (&m_upnpUrls);
-#ifndef _WIN32
-        dlclose (m_Module);
-#else
-        FreeLibrary (m_Module);
-#endif
-    }
-
-}
-}
-
-
-#endif
-

UPnP.h

@@ -1,65 +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 UPnP
-{
-	class UPnP
-	{
-	public:
-
-		UPnP ();
-		~UPnP ();
-        void Close ();
-
-        void Start ();
-        void Stop ();
-
-		void Discover ();
-		void TryPortMapping (int type);
-		void CloseMapping (int type);
-	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;
-        std::string m_Port = std::to_string (util::config::GetArg ("-port", 17070));
-#ifndef _WIN32
-        void *m_Module;
-#else
-        HINSTANCE *m_Module;
-#endif
-	};
-	extern UPnP upnpc;
-}
-}
-
-#endif
-
-#endif

Win32/DaemonWin32.cpp

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

Win32/Itoopie.cmd

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

@@ -14,7 +14,7 @@ ShowInstDetails show
 !define URL "https://i2p.io"
 
 # MUI Symbol Definitions
-!define MUI_ICON "ictoopie.ico"
+!define MUI_ICON "mask.ico"
 #!define MUI_WELCOMEFINISHPAGE_BITMAP "../share/pixmaps/nsis-wizard.bmp"
 !define MUI_HEADERIMAGE
 !define MUI_HEADERIMAGE_RIGHT

Win32/README-Build.txt

@@ -1,84 +0,0 @@
-Building i2pd for Windows
-=========================
-
-Requirements for building:
-
-* Visual Studio 2013 (tested with VS2013 Update 1, Update 3, and Update 4 RC)
-* Boost (tested with 1.56 and 1.57)
-* Crypto++ (tested with 5.6.2)
-
-
-Building Boost (32-bit)
------------------------
-
-Open a Visual Studio x86 command prompt and run the following:
-
-	cd C:\path\to\boost\sources
-	bootstrap
-	b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\Win32 install --with-filesystem --with-program_options --with-regex --with-date_time
-
-
-Building Boost (64-bit)
------------------------
-
-Open a Visual Studio x64 command prompt and run the following:
-
-	cd C:\path\to\boost\sources
-	bootstrap
-	b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\x64 architecture=x86 address-model=64 install --with-filesystem --with-program_options --with-regex --with-date_time
-
-After Boost is compiled, set the environment variable `BOOST` to the directory
-Boost was installed to. If you followed the instructions outlined here, you
-should set it to `C:\Boost`. Additionally, set the BOOSTVER variable to the
-version of Boost that you're using, but instead of a '.' use a '_'. For
-example, I have `BOOSTVER` set to `1_57`.
-
-Building Crypto++
------------------
-
-* Open the crypttest Solution in VS2013
-* Visual Studio will ask to update the Solution/Project. Allow it.
-* Build the `cryptopp` project, both the Debug and Release targets and for both
-  Win32 and x64.
-* Create a folder called `cryptopp` in the crypto++ source directory, then copy
-  the header files to this new directory.
-* Set the `CRYPTOPP` environment variable pointing to the Crypto++ source directory.
-
-
-Building i2pd
--------------
-
-## Prep work ##
-
-I strongly advise setting up your own `INCLUDES` and `LIBS` instead of relying
-on the settings in the i2pd project file. By using your own settings, if the
-i2pd devs change the paths in the project file, your builds will still work.
-
-To do this, create or edit the file
-`%localappdata%\Microsoft\MSBuild\v4.0\Microsoft.Cpp.Win32.user`.
-
-For comparison, my file is reproduced below:
-
-	<?xml version="1.0" encoding="utf-8"?>
-	<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-	  <ImportGroup Label="PropertySheets">
-	  </ImportGroup>
-	  <PropertyGroup Label="UserMacros" />
-	  <PropertyGroup>
-	    <LibraryPath>$(CRYPTOPP)\$(Platform)\Output\$(Configuration);$(BOOST)\lib\$(Platform);$(LibraryPath)</LibraryPath>
-	    <IncludePath>$(CRYPTOPP);$(BOOST)\include\boost-$(BOOSTVER);$(IncludePath)</IncludePath>
-	  </PropertyGroup>
-	  <ItemDefinitionGroup />
-	  <ItemGroup />
-	</Project>
-
-
-If you want to build x64 binaries as well, you'll want to edit or create the
-file `%localappdata%\Microsoft\MSBuild\v4.0\Microsoft.Cpp.x64.user`. If you
-followed the steps outlined earlier you can copy (or link) the win32 file to
-the x64 one.
-
-## Anti-Climatic End ##
-
-After following the above instructions, you'll be able to build Debug Win32,
-Debug x64, Release Win32, and Release x64 i2pd binaries.

Win32/Resource.rc2

@@ -0,0 +1,47 @@
+//
+// 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 "../libi2pd/version.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION I2PD_VERSION_MAJOR,I2PD_VERSION_MINOR,I2PD_VERSION_MICRO,I2PD_VERSION_PATCH
+ PRODUCTVERSION I2P_VERSION_MAJOR,I2P_VERSION_MINOR,I2P_VERSION_MICRO,I2P_VERSION_PATCH
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "Purple I2P"
+            VALUE "FileDescription", "C++ I2P daemon"
+            VALUE "FileVersion", I2PD_VERSION
+            VALUE "InternalName", CODENAME
+            VALUE "LegalCopyright", "Copyright (C) 2013-2015, The PurpleI2P Project"
+            VALUE "OriginalFilename", "i2pd"
+            VALUE "ProductName", "Purple I2P"
+            VALUE "ProductVersion", I2P_VERSION
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END

Win32/Win32App.cpp

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

Win32/Win32App.h

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

Win32/Win32Service.cpp

@@ -7,8 +7,8 @@
 #include <strsafe.h>
 #include <windows.h>
 
-#include "../Daemon.h"
-#include "../Log.h"
+#include "Daemon.h"
+#include "Log.h"
 
 I2PService *I2PService::s_service = NULL;
 
@@ -76,7 +76,7 @@ I2PService::I2PService(PSTR pszServiceName,
 	BOOL fCanShutdown,
 	BOOL fCanPauseContinue)
 {
-	m_name = (pszServiceName == NULL) ? "" : pszServiceName;
+	m_name = (pszServiceName == NULL) ? (PSTR)"" : pszServiceName;
 
 	m_statusHandle = NULL;
 
@@ -100,7 +100,7 @@ I2PService::I2PService(PSTR pszServiceName,
 
 	m_fStopping = FALSE;
 
-	// Create a manual-reset event that is not signaled at first to indicate 
+	// Create a manual-reset event that is not signaled at first to indicate
 	// the stopped signal of the service.
 	m_hStoppedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 	if (m_hStoppedEvent == NULL)
@@ -132,13 +132,13 @@ void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint("Win32Service Start", dwError);
+		LogPrint(eLogError, "Win32Service Start", dwError);
 
 		SetServiceStatus(SERVICE_STOPPED, dwError);
 	}
 	catch (...)
 	{
-		LogPrint("Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
+		LogPrint(eLogError, "Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
 
 		SetServiceStatus(SERVICE_STOPPED);
 	}
@@ -147,7 +147,7 @@ void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
 
 void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
 {
-	LogPrint("Win32Service in OnStart",
+	LogPrint(eLogInfo, "Win32Service in OnStart",
 		EVENTLOG_INFORMATION_TYPE);
 
 	Daemon.start();
@@ -186,13 +186,13 @@ void I2PService::Stop()
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint("Win32Service Stop", dwError);
+		LogPrint(eLogInfo, "Win32Service Stop", dwError);
 
 		SetServiceStatus(dwOriginalState);
 	}
 	catch (...)
 	{
-		LogPrint("Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
+		LogPrint(eLogError, "Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
 
 		SetServiceStatus(dwOriginalState);
 	}
@@ -202,7 +202,7 @@ void I2PService::Stop()
 void I2PService::OnStop()
 {
 	// Log a service stop message to the Application log.
-	LogPrint("Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
+	LogPrint(eLogInfo, "Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
 
 	Daemon.stop();
 
@@ -228,13 +228,13 @@ void I2PService::Pause()
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint("Win32Service Pause", dwError);
+		LogPrint(eLogError, "Win32Service Pause", dwError);
 
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (...)
 	{
-		LogPrint("Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
+		LogPrint(eLogError, "Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
 
 		SetServiceStatus(SERVICE_RUNNING);
 	}
@@ -258,13 +258,13 @@ void I2PService::Continue()
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint("Win32Service Continue", dwError);
+		LogPrint(eLogError, "Win32Service Continue", dwError);
 
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 	catch (...)
 	{
-		LogPrint("Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
+		LogPrint(eLogError, "Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
 
 		SetServiceStatus(SERVICE_PAUSED);
 	}
@@ -286,11 +286,11 @@ void I2PService::Shutdown()
 	}
 	catch (DWORD dwError)
 	{
-		LogPrint("Win32Service Shutdown", dwError);
+		LogPrint(eLogError, "Win32Service Shutdown", dwError);
 	}
 	catch (...)
 	{
-		LogPrint("Win32Service failed to shut down.", EVENTLOG_ERROR_TYPE);
+		LogPrint(eLogError, "Win32Service failed to shut down.", EVENTLOG_ERROR_TYPE);
 	}
 }
 

Win32/Win32Service.h

@@ -2,7 +2,6 @@
 #define WIN_32_SERVICE_H__
 
 #include <thread>
-#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
 

Win32/i2pd.vcxproj

@@ -37,11 +37,13 @@
     <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" />
@@ -80,7 +82,8 @@
     <ClInclude Include="..\LeaseSet.h" />
     <ClInclude Include="..\LittleBigEndian.h" />
     <ClInclude Include="..\Log.h" />
-    <ClInclude Include="..\NetDb.h" />
+	<ClInclude Include="..\NetDbRequests.h" />
+    <ClInclude Include="..\NetDb.hpp" />
     <ClInclude Include="..\NTCPSession.h" />
     <ClInclude Include="..\Queue.h" />
 	<ClInclude Include="..\Profiling.h" />

Win32/i2pd.vcxproj.filters

@@ -158,7 +158,7 @@
     <ClInclude Include="..\Log.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\NetDb.h">
+    <ClInclude Include="..\NetDb.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="..\NTCPSession.h">

Win32/installer.iss

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

Win32/winres.h

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

aes.cpp

@@ -1,355 +0,0 @@
-#include <stdlib.h>
-#include "TunnelBase.h"
-#include "aes.h"
-
-namespace i2p
-{
-namespace crypto
-{
-
-#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 (uint8_t * payload)
-	{
-#ifdef AESNI
-		__asm__
-		(
-            // encrypt IV 
-			"movups	(%[payload]), %%xmm0 \n"
-			EncryptAES256(sched_iv)
-			"movaps %%xmm0, %%xmm1 \n"
-			// double IV encryption
-			EncryptAES256(sched_iv)
-			"movups %%xmm0, (%[payload]) \n"
-			// encrypt data, IV is xmm1
-			"1: \n"
-			"add $16, %[payload] \n"
-		 	"movups	(%[payload]), %%xmm0 \n"
-		 	"pxor %%xmm1, %%xmm0 \n"
-		 	EncryptAES256(sched_l)
-		 	"movaps	%%xmm0, %%xmm1 \n"	
-		 	"movups	%%xmm0, (%[payload]) \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-			: 
-			: [sched_iv]"r"(m_IVEncryption.GetKeySchedule ()), [sched_l]"r"(m_LayerEncryption.GetKeySchedule ()), 
-			  [payload]"r"(payload), [num]"r"(63) // 63 blocks = 1008 bytes
-			: "%xmm0", "%xmm1", "cc", "memory"
-		);
-#else
-		m_IVEncryption.Encrypt ((ChipherBlock *)payload, (ChipherBlock *)payload); // iv
-		m_LayerEncryption.SetIV (payload);
-		m_LayerEncryption.Encrypt (payload + 16, i2p::tunnel::TUNNEL_DATA_ENCRYPTED_SIZE, payload + 16); // data
-		m_IVEncryption.Encrypt ((ChipherBlock *)payload, (ChipherBlock *)payload); // double iv
-#endif
-	}
-
-	void TunnelDecryption::Decrypt (uint8_t * payload)
-	{
-#ifdef AESNI
-		__asm__
-		(
-            // decrypt IV 
-			"movups	(%[payload]), %%xmm0 \n"
-			DecryptAES256(sched_iv)
-			"movaps %%xmm0, %%xmm1 \n"
-			// double IV encryption
-			DecryptAES256(sched_iv)
-			"movups %%xmm0, (%[payload]) \n"
-			// decrypt data, IV is xmm1
-			"1: \n"
-			"add $16, %[payload] \n"
-			"movups	(%[payload]), %%xmm0 \n"
-			"movaps %%xmm0, %%xmm2 \n"
-		 	DecryptAES256(sched_l)
-			"pxor %%xmm1, %%xmm0 \n"
-		 	"movups	%%xmm0, (%[payload]) \n"
-			"movaps %%xmm2, %%xmm1 \n"
-		 	"dec %[num] \n"
-		 	"jnz 1b \n"	 	
-			: 
-			: [sched_iv]"r"(m_IVDecryption.GetKeySchedule ()), [sched_l]"r"(m_LayerDecryption.GetKeySchedule ()), 
-			  [payload]"r"(payload), [num]"r"(63) // 63 blocks = 1008 bytes
-			: "%xmm0", "%xmm1", "%xmm2", "cc", "memory"
-		);
-#else
-		m_IVDecryption.Decrypt ((ChipherBlock *)payload, (ChipherBlock *)payload); // iv
-		m_LayerDecryption.SetIV (payload);	
-		m_LayerDecryption.Decrypt (payload + 16, i2p::tunnel::TUNNEL_DATA_ENCRYPTED_SIZE, payload + 16); // data
-		m_IVDecryption.Decrypt ((ChipherBlock *)payload, (ChipherBlock *)payload); // double iv
-#endif
-	}
-}
-}
-

aes.h

@@ -1,225 +0,0 @@
-#ifndef AES_H__
-#define AES_H__
-
-#include <inttypes.h>
-#include <cryptopp/modes.h>
-#include <cryptopp/aes.h>
-#include "Identity.h"
-
-namespace i2p
-{
-namespace crypto
-{	
-	struct ChipherBlock	
-	{
-		uint8_t buf[16];
-
-		void operator^=(const ChipherBlock& other) // XOR
-		{
-#if defined(__x86_64__) // for Intel x64 
-			__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 crypto++
-
-	class ECBEncryption
-	{
-		public:
-		
-			void SetKey (const AESKey& key) 
-			{ 
-				m_Encryption.SetKey (key, 32); 
-			}
-			void Encrypt (const ChipherBlock * in, ChipherBlock * out)
-			{
-				m_Encryption.ProcessData (out->buf, in->buf, 16);
-			}	
-
-		private:
-
-			CryptoPP::ECB_Mode<CryptoPP::AES>::Encryption m_Encryption;
-	};	
-
-	class ECBDecryption
-	{
-		public:
-		
-			void SetKey (const AESKey& key) 
-			{ 
-				m_Decryption.SetKey (key, 32); 
-			}
-			void Decrypt (const ChipherBlock * in, ChipherBlock * out)
-			{
-				m_Decryption.ProcessData (out->buf, in->buf, 16);
-			}	
-
-		private:
-
-			CryptoPP::ECB_Mode<CryptoPP::AES>::Decryption m_Decryption;
-	};		
-
-
-#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 (uint8_t * payload); // 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 (uint8_t * payload); // 1024 bytes (16 IV + 1008 data)	
-
-		private:
-
-			ECBDecryption m_IVDecryption;
-#ifdef AESNI
-			ECBDecryption m_LayerDecryption;
-#else
-			CBCDecryption m_LayerDecryption;
-#endif
-	};
-}
-}
-
-#endif
-

android/.gitignore

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

android/AndroidManifest.xml

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

android/build.xml

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

android/jni/Android.mk

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

android/jni/Application.mk

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

android/jni/DaemonAndroid.cpp

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

android/jni/DaemonAndroid.h

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

android/jni/i2pd_android.cpp

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

android/jni/org_purplei2p_i2pd_I2PD_JNI.h

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

android/proguard-project.txt

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

android/project.properties

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

android/res/menu/options_main.xml

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

android/res/values/strings.xml

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

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

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