Merge pull request #805 from PurpleI2P/openssl

2.12.0

.gitignore

@@ -8,6 +8,7 @@ netDb
 /i2pd
 /libi2pd.a
 /libi2pdclient.a
+i2pd.exe
 
 
 # Autotools

AddressBook.cpp

@@ -703,13 +703,14 @@ namespace client
 		int         dest_port = url.port ? url.port : 80;
 		/* create http request & send it */
 		i2p::http::HTTPReq req;
-		req.add_header("Host", dest_host);
+		req.AddHeader("Host", dest_host);
-		req.add_header("User-Agent", "Wget/1.11.4");
+		req.AddHeader("User-Agent", "Wget/1.11.4");
-		req.add_header("Connection", "close");
+		req.AddHeader("X-Accept-Encoding", "x-i2p-gzip;q=1.0, identity;q=0.5, deflate;q=0, gzip;q=0, *;q=0\r\n");
+		req.AddHeader("Connection", "close");
 		if (!m_Etag.empty())
-			req.add_header("If-None-Match", m_Etag);
+			req.AddHeader("If-None-Match", m_Etag);
 		if (!m_LastModified.empty())
-			req.add_header("If-Modified-Since", m_LastModified);
+			req.AddHeader("If-Modified-Since", m_LastModified);
 		/* convert url to relative */
 		url.schema = "";
 		url.host   = "";
@@ -721,7 +722,9 @@ namespace client
 		std::string response;
 		uint8_t recv_buf[4096];
 		bool end = false;
-		while (!end) {
+		int numAttempts = 5;
+		while (!end) 
+		{
 			stream->AsyncReceive (boost::asio::buffer (recv_buf, 4096),
 				[&](const boost::system::error_code& ecode, std::size_t bytes_transferred)
 				{
@@ -734,60 +737,69 @@ namespace client
 				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, "Addressbook: subscriptions request timeout expired");
+				numAttempts++;
+				if (numAttempts > 5) end = true;
+			}	
 		}
 		// process remaining buffer
-		while (size_t len = stream->ReadSome (recv_buf, sizeof(recv_buf))) {
+		while (size_t len = stream->ReadSome (recv_buf, sizeof(recv_buf))) 
 			response.append ((char *)recv_buf, len);
-		}
 		/* parse response */
 		i2p::http::HTTPRes res;
 		int res_head_len = res.parse(response);
-		if (res_head_len < 0) {
+		if (res_head_len < 0) 
+		{
 			LogPrint(eLogError, "Addressbook: can't parse http response from ", dest_host);
 			return false;
 		}
-		if (res_head_len == 0) {
+		if (res_head_len == 0) 
+		{
 			LogPrint(eLogError, "Addressbook: incomplete http response from ", dest_host, ", interrupted by timeout");
 			return false;
 		}
 		/* assert: res_head_len > 0 */
 		response.erase(0, res_head_len);
-		if (res.code == 304) {
+		if (res.code == 304) 
+		{
 			LogPrint (eLogInfo, "Addressbook: no updates from ", dest_host, ", code 304");
 			return false;
 		}
-		if (res.code != 200) {
+		if (res.code != 200) 
+		{
 			LogPrint (eLogWarning, "Adressbook: can't get updates from ", dest_host, ", response code ", res.code);
 			return false;
 		}
 		int len = res.content_length();
-		if (response.empty()) {
+		if (response.empty()) 
+		{
 			LogPrint(eLogError, "Addressbook: empty response from ", dest_host, ", expected ", len, " bytes");
 			return false;
 		}
-		if (len > 0 && len != (int) response.length()) {
+		if (!res.is_gzipped () && len > 0 && len != (int) response.length()) 
-			LogPrint(eLogError, "Addressbook: response size mismatch, expected: ", response.length(), ", got: ", len, "bytes");
+		{
+			LogPrint(eLogError, "Addressbook: response size mismatch, expected: ", len, ", got: ", response.length(), "bytes");
 			return false;
 		}
 		/* assert: res.code == 200 */
 		auto it = res.headers.find("ETag");
-		if (it != res.headers.end()) {
+		if (it != res.headers.end()) m_Etag = it->second;
-			m_Etag = it->second;
-		}
 		it = res.headers.find("If-Modified-Since");
-		if (it != res.headers.end()) {
+		if (it != res.headers.end()) m_LastModified = it->second;
-			m_LastModified = it->second;
+		if (res.is_chunked()) 
-		}
+		{
-		if (res.is_chunked()) {
 			std::stringstream in(response), out;
 			i2p::http::MergeChunkedResponse (in, out);
 			response = out.str();
-		} else if (res.is_gzipped()) {
+		} 
+		else if (res.is_gzipped()) 
+		{
 			std::stringstream out;
 			i2p::data::GzipInflator inflator;
 			inflator.Inflate ((const uint8_t *) response.data(), response.length(), out);
-			if (out.fail()) {
+			if (out.fail()) 
+			{
 				LogPrint(eLogError, "Addressbook: can't gunzip http response");
 				return false;
 			}

ChangeLog

@@ -1,6 +1,22 @@
 # for this file format description,
 # see https://github.com/olivierlacan/keep-a-changelog
 
+## [2.12.0] - 2017-02-14
+### Added
+- Additional HTTP and SOCKS proxy tunnels
+- Reseed from ZIP achieve
+- 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

ClientContext.cpp

@@ -50,11 +50,12 @@ namespace client
 			std::string httpProxyKeys; i2p::config::GetOption("httpproxy.keys",    httpProxyKeys);
 			std::string httpProxyAddr; i2p::config::GetOption("httpproxy.address", httpProxyAddr);
 			uint16_t    httpProxyPort; i2p::config::GetOption("httpproxy.port",    httpProxyPort);
+			i2p::data::SigningKeyType sigType; i2p::config::GetOption("httpproxy.signaturetype",  sigType);
 			LogPrint(eLogInfo, "Clients: starting HTTP Proxy at ", httpProxyAddr, ":", httpProxyPort);
 			if (httpProxyKeys.length () > 0)
 			{
 				i2p::data::PrivateKeys keys;
-				if(LoadPrivateKeys (keys, httpProxyKeys, i2p::data::SIGNING_KEY_TYPE_DSA_SHA1))
+				if(LoadPrivateKeys (keys, httpProxyKeys, sigType))
 				{
 					std::map<std::string, std::string> params;
 					ReadI2CPOptionsFromConfig ("httpproxy.", params);
@@ -80,11 +81,12 @@ namespace client
 			uint16_t    socksProxyPort; i2p::config::GetOption("socksproxy.port",    socksProxyPort);
 			std::string socksOutProxyAddr; i2p::config::GetOption("socksproxy.outproxy",     socksOutProxyAddr);
 			uint16_t    socksOutProxyPort; i2p::config::GetOption("socksproxy.outproxyport", socksOutProxyPort);
+			i2p::data::SigningKeyType sigType; i2p::config::GetOption("socksproxy.signaturetype",  sigType);
 			LogPrint(eLogInfo, "Clients: starting SOCKS Proxy at ", socksProxyAddr, ":", socksProxyPort);
 			if (socksProxyKeys.length () > 0)
 			{
 				i2p::data::PrivateKeys keys;
-				if (LoadPrivateKeys (keys, socksProxyKeys, i2p::data::SIGNING_KEY_TYPE_DSA_SHA1))
+				if (LoadPrivateKeys (keys, socksProxyKeys, sigType))
 				{
 					std::map<std::string, std::string> params;
 					ReadI2CPOptionsFromConfig ("socksproxy.", params);

Config.cpp

@@ -16,6 +16,7 @@
 #include <boost/program_options/parsers.hpp>
 #include <boost/program_options/variables_map.hpp>
 
+#include "Identity.h"
 #include "Config.h"
 #include "version.h"
 
@@ -85,6 +86,7 @@ namespace config {
       ("httpproxy.address",   value<std::string>()->default_value("127.0.0.1"),           "HTTP Proxy listen address")
       ("httpproxy.port",      value<uint16_t>()->default_value(4444),                     "HTTP Proxy listen port")
       ("httpproxy.keys",      value<std::string>()->default_value(""),  "File to persist HTTP Proxy keys")
+	  ("httpproxy.signaturetype",      value<i2p::data::SigningKeyType>()->default_value(i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519), "Signature type for new keys. 7 (EdDSA) by default")	
 	  ("httpproxy.inbound.length",      value<std::string>()->default_value("3"),  "HTTP proxy inbound tunnel length")	
 	  ("httpproxy.outbound.length",     value<std::string>()->default_value("3"),  "HTTP proxy outbound tunnel length")
 	  ("httpproxy.inbound.quantity",    value<std::string>()->default_value("5"),  "HTTP proxy inbound tunnels quantity")	
@@ -100,6 +102,7 @@ namespace config {
       ("socksproxy.address",  value<std::string>()->default_value("127.0.0.1"),           "SOCKS Proxy listen address")
       ("socksproxy.port",     value<uint16_t>()->default_value(4447),                     "SOCKS Proxy listen port")
       ("socksproxy.keys",     value<std::string>()->default_value(""), "File to persist SOCKS Proxy keys")
+	  ("socksproxy.signaturetype",      value<i2p::data::SigningKeyType>()->default_value(i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519), "Signature type for new keys. 7 (EdDSA) by default")	
       ("socksproxy.inbound.length",      value<std::string>()->default_value("3"),  "SOCKS proxy inbound tunnel length")	
 	  ("socksproxy.outbound.length",     value<std::string>()->default_value("3"),  "SOCKS proxy outbound tunnel length")
 	  ("socksproxy.inbound.quantity",    value<std::string>()->default_value("5"),  "SOCKS proxy inbound tunnels quantity")	
@@ -165,8 +168,10 @@ namespace config {
 	options_description reseed("Reseed options");	
 	reseed.add_options()
 	  ("reseed.verify", value<bool>()->default_value(false), "Verify .su3 signature")
+	  ("reseed.threshold", value<uint16_t>()->default_value(25), "Minimum number of known routers before requesting reseed")
 		("reseed.floodfill", value<std::string>()->default_value(""), "Path to router info of floodfill to reseed from")
 	  ("reseed.file", value<std::string>()->default_value(""),  "Path to local .su3 file or HTTPS URL to reseed from")
+	  ("reseed.zipfile", value<std::string>()->default_value(""),  "Path to local .zip file to reseed from")
 	  ("reseed.urls", value<std::string>()->default_value(
 		"https://reseed.i2p-projekt.de/,"
 		"https://i2p.mooo.com/netDb/,"
@@ -178,8 +183,9 @@ namespace config {
 		"https://download.xxlspeed.com/,"
 		"https://reseed-ru.lngserv.ru/,"
 	    "https://reseed.atomike.ninja/,"
-	    "https://reseed.memcpy.io/",
+	    "https://reseed.memcpy.io/,"
-	    "https://reseed.onion.im/"                                                  
+	    "https://reseed.onion.im/,"
+	    "https://itoopie.atomike.ninja/"
 		),  "Reseed URLs, separated by comma")
 	  ;	
 

Destination.cpp

@@ -14,8 +14,8 @@ namespace client
 {
 	LeaseSetDestination::LeaseSetDestination (bool isPublic, const std::map<std::string, std::string> * params):
 		m_IsRunning (false), m_Thread (nullptr), m_IsPublic (isPublic), 
-		m_PublishReplyToken (0), m_PublishConfirmationTimer (m_Service), 
+		m_PublishReplyToken (0), m_LastSubmissionTime (0), m_PublishConfirmationTimer (m_Service), 
-		m_PublishVerificationTimer (m_Service), m_CleanupTimer (m_Service)
+		m_PublishVerificationTimer (m_Service), m_PublishDelayTimer (m_Service), m_CleanupTimer (m_Service)
 	{
 		int inLen   = DEFAULT_INBOUND_TUNNEL_LENGTH;
 		int inQty   = DEFAULT_INBOUND_TUNNELS_QUANTITY;
@@ -426,6 +426,16 @@ namespace client
 			LogPrint (eLogDebug, "Destination: Publishing LeaseSet is pending");
 			return;
 		}
+		auto ts = i2p::util::GetSecondsSinceEpoch ();
+		if (ts < m_LastSubmissionTime + PUBLISH_MIN_INTERVAL)
+		{
+			LogPrint (eLogDebug, "Destination: Publishing LeaseSet is too fast. Wait for ", PUBLISH_MIN_INTERVAL, " seconds");
+			m_PublishDelayTimer.cancel ();
+			m_PublishDelayTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_MIN_INTERVAL));
+			m_PublishDelayTimer.async_wait (std::bind (&LeaseSetDestination::HandlePublishDelayTimer,
+				shared_from_this (), std::placeholders::_1));	
+			return;
+		}	
 		auto outbound = m_Pool->GetNextOutboundTunnel ();
 		if (!outbound)
 		{
@@ -453,6 +463,7 @@ namespace client
 		m_PublishConfirmationTimer.async_wait (std::bind (&LeaseSetDestination::HandlePublishConfirmationTimer,
 			shared_from_this (), std::placeholders::_1));	
 		outbound->SendTunnelDataMsg (floodfill->GetIdentHash (), 0, msg);	
+		m_LastSubmissionTime = ts;
 	}
 
 	void LeaseSetDestination::HandlePublishConfirmationTimer (const boost::system::error_code& ecode)
@@ -477,13 +488,18 @@ namespace client
 				// "this" added due to bug in gcc 4.7-4.8
 				[s,this](std::shared_ptr<i2p::data::LeaseSet> leaseSet)
 				{
-					if (leaseSet && s->m_LeaseSet)
+					if (leaseSet)		
 					{
-						// we got latest LeasetSet
+						if (s->m_LeaseSet && *s->m_LeaseSet == *leaseSet)
-						LogPrint (eLogDebug, "Destination: published LeaseSet verified for ", GetIdentHash().ToBase32());
+						{
-						s->m_PublishVerificationTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_REGULAR_VERIFICATION_INTERNAL));
+							// we got latest LeasetSet
-						s->m_PublishVerificationTimer.async_wait (std::bind (&LeaseSetDestination::HandlePublishVerificationTimer, s, std::placeholders::_1));	
+							LogPrint (eLogDebug, "Destination: published LeaseSet verified for ", GetIdentHash().ToBase32());
-						return;
+							s->m_PublishVerificationTimer.expires_from_now (boost::posix_time::seconds(PUBLISH_REGULAR_VERIFICATION_INTERNAL));
+							s->m_PublishVerificationTimer.async_wait (std::bind (&LeaseSetDestination::HandlePublishVerificationTimer, s, std::placeholders::_1));	
+							return;
+						}	
+						else
+							LogPrint (eLogDebug, "Destination: LeaseSet is different than just published for ", GetIdentHash().ToBase32());
 					}	
 					else
 						LogPrint (eLogWarning, "Destination: couldn't find published LeaseSet for ", GetIdentHash().ToBase32());
@@ -493,6 +509,12 @@ namespace client
 		}
 	}
 
+	void LeaseSetDestination::HandlePublishDelayTimer (const boost::system::error_code& ecode)
+	{
+		if (ecode != boost::asio::error::operation_aborted)
+			Publish ();
+	}	
+		
 	bool LeaseSetDestination::RequestDestination (const i2p::data::IdentHash& dest, RequestComplete requestComplete)
 	{
 		if (!m_Pool || !IsReady ()) 

Destination.h

@@ -30,6 +30,7 @@ namespace client
 	const uint8_t PROTOCOL_TYPE_RAW = 18;	
 	const int PUBLISH_CONFIRMATION_TIMEOUT = 5; // in seconds
 	const int PUBLISH_VERIFICATION_TIMEOUT = 10; // in seconds after successfull publish
+	const int PUBLISH_MIN_INTERVAL = 20; // in seconds 
 	const int PUBLISH_REGULAR_VERIFICATION_INTERNAL = 100; // in seconds periodically	
 	const int LEASESET_REQUEST_TIMEOUT = 5; // in seconds
 	const int MAX_LEASESET_REQUEST_TIMEOUT = 40; // in seconds
@@ -122,6 +123,7 @@ namespace client
 			void Publish ();
 			void HandlePublishConfirmationTimer (const boost::system::error_code& ecode);
 			void HandlePublishVerificationTimer (const boost::system::error_code& ecode);
+			void HandlePublishDelayTimer (const boost::system::error_code& ecode);
 			void HandleDatabaseStoreMessage (const uint8_t * buf, size_t len);
 			void HandleDatabaseSearchReplyMessage (const uint8_t * buf, size_t len);
 			void HandleDeliveryStatusMessage (std::shared_ptr<I2NPMessage> msg);		
@@ -146,9 +148,11 @@ namespace client
 			std::shared_ptr<i2p::data::LocalLeaseSet> m_LeaseSet;
 			bool m_IsPublic;
 			uint32_t m_PublishReplyToken;
+			uint64_t m_LastSubmissionTime; // in seconds
 			std::set<i2p::data::IdentHash> m_ExcludedFloodfills; // for publishing
 	
-			boost::asio::deadline_timer m_PublishConfirmationTimer, m_PublishVerificationTimer, m_CleanupTimer;
+			boost::asio::deadline_timer m_PublishConfirmationTimer, m_PublishVerificationTimer, 
+				m_PublishDelayTimer, m_CleanupTimer;
 
 		public:
 			

HTTP.cpp

@@ -1,14 +1,15 @@
 /*
-* Copyright (c) 2013-2016, The PurpleI2P Project
+* Copyright (c) 2013-2017, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
 * See full license text in LICENSE file at top of project tree
 */
 
+#include <algorithm>
+#include <utility>
 #include "util.h"
 #include "HTTP.h"
-#include <algorithm>
 #include <ctime>
 
 namespace i2p {
@@ -43,18 +44,16 @@ namespace http {
     }
   }
 
-  bool parse_header_line(const std::string & line, std::map<std::string, std::string> & headers) {
+  static std::pair<std::string, std::string> parse_header_line(const std::string& line) 
+  {
     std::size_t pos = 0;
     std::size_t len = 2; /* strlen(": ") */
     std::size_t max = line.length();
     if ((pos = line.find(": ", pos)) == std::string::npos)
-      return false;
+      return std::make_pair("", "");
     while ((pos + len) < max && isspace(line.at(pos + len)))
       len++;
-    std::string name  = line.substr(0, pos);
+    return std::make_pair(line.substr(0, pos), line.substr(pos + len));
-    std::string value = line.substr(pos + len);
-    headers[name] = value;
-    return true;
   }
 
   void gen_rfc1123_date(std::string & out) {
@@ -247,10 +246,15 @@ namespace http {
         uri     = tokens[1];
         version = tokens[2];
         expect = HEADER_LINE;
-      } else {
+      } 
+	  else 
+	  {
         std::string line = str.substr(pos, eol - pos);
-        if (!parse_header_line(line, headers))
+        auto p = parse_header_line(line);
-          return -1;
+		if (p.first.length () > 0)
+			headers.push_back (p);
+		else  
+            return -1;
       }
       pos = eol + strlen(CRLF);
       if (pos >= eoh)
@@ -259,12 +263,12 @@ namespace http {
     return eoh + strlen(HTTP_EOH);
   }
 
-  void HTTPReq::write(std::ostream & o) {
+  void HTTPReq::write(std::ostream & o) 
-		o << method << " " << uri << " " << version << CRLF;
+  {
-    for (auto & h : headers) {
+	  o << method << " " << uri << " " << version << CRLF;
-      o << h.first << ": " << h.second << CRLF;
+	  for (auto & h : headers) 
-    }
+  		o << h.first << ": " << h.second << CRLF;
-    o << CRLF;
+	  o << CRLF;
   }
 
 	std::string HTTPReq::to_string()
@@ -274,7 +278,42 @@ namespace http {
 		return ss.str();
 	}
 
-  bool HTTPRes::is_chunked() {
+	void HTTPReq::AddHeader (const std::string& name, const std::string& value)
+	{	
+		headers.push_back (std::make_pair(name, value));
+	}
+
+	void HTTPReq::UpdateHeader (const std::string& name, const std::string& value)
+	{
+		 for (auto& it : headers)
+			if (it.first == name)
+			{
+				it.second = value;
+				break;
+			}	
+	}	
+	
+	void HTTPReq::RemoveHeader (const std::string& name)
+	{
+		for (auto it = headers.begin (); it != headers.end ();)
+		{
+			if (!it->first.compare(0, name.length (), name))	
+				it = headers.erase (it);
+			else
+				it++;
+		}	
+	}	
+
+	std::string HTTPReq::GetHeader (const std::string& name) const 
+	{
+		 for (auto& it : headers)
+			if (it.first == name)
+				return it.second;	
+		return "";
+	}	
+	
+  bool HTTPRes::is_chunked() const
+ {
     auto it = headers.find("Transfer-Encoding");
     if (it == headers.end())
       return false;
@@ -283,16 +322,20 @@ namespace http {
     return false;
   }
 
-  bool HTTPRes::is_gzipped() {
+  bool HTTPRes::is_gzipped(bool includingI2PGzip) const
+  {
     auto it = headers.find("Content-Encoding");
     if (it == headers.end())
       return false; /* no header */
     if (it->second.find("gzip") != std::string::npos)
       return true; /* gotcha! */
+	if (includingI2PGzip &&  it->second.find("x-i2p-gzip") != std::string::npos)
+	  return true;	  
     return false;
   }
-
+	
-  long int HTTPMsg::content_length() {
+  long int HTTPMsg::content_length() const
+  {
     unsigned long int length = 0;
     auto it = headers.find("Content-Length");
     if (it == headers.end())
@@ -335,7 +378,10 @@ namespace http {
         expect = HEADER_LINE;
       } else {
         std::string line = str.substr(pos, eol - pos);
-        if (!parse_header_line(line, headers))
+        auto p = parse_header_line(line);
+		if (p.first.length () > 0)
+			headers.insert (p);  
+		else	  
           return -1;
       }
       pos = eol + strlen(CRLF);

HTTP.h

@@ -11,6 +11,7 @@
 
 #include <cstring>
 #include <map>
+#include <list>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -54,7 +55,8 @@ namespace http {
     std::string to_string ();
   };
 
-  struct HTTPMsg {
+  struct HTTPMsg 
+  {
     std::map<std::string, std::string> headers;
 
     void add_header(const char *name, std::string & value, bool replace = false);
@@ -62,10 +64,12 @@ namespace http {
     void del_header(const char *name);
 
     /** @brief Returns declared message length or -1 if unknown */
-    long int content_length();
+    long int content_length() const;
   };
 
-  struct HTTPReq : HTTPMsg {
+  struct HTTPReq 
+  {
+	std::list<std::pair<std::string, std::string> > headers;  
     std::string version;
     std::string method;
     std::string uri;
@@ -82,9 +86,12 @@ namespace http {
 
     /** @brief Serialize HTTP request to string */
     std::string to_string();
-		
+	void write(std::ostream & o);
-		void write(std::ostream & o);
 
+	void AddHeader (const std::string& name, const std::string& value);
+	void UpdateHeader (const std::string& name, const std::string& value);  
+	void RemoveHeader (const std::string& name);
+	std::string GetHeader (const std::string& name) const;  
   };
 
   struct HTTPRes : HTTPMsg {
@@ -122,10 +129,10 @@ namespace http {
 		void write(std::ostream & o);
 		
     /** @brief Checks that response declared as chunked data */
-    bool is_chunked();
+    bool is_chunked() const ;
 
     /** @brief Checks that response contains compressed data */
-    bool is_gzipped();
+    bool is_gzipped(bool includingI2PGzip = true) const;
   };
 
   /**

HTTPProxy.cpp

@@ -200,26 +200,16 @@ namespace proxy {
 	void HTTPReqHandler::SanitizeHTTPRequest(i2p::http::HTTPReq & req)
 	{
 		/* drop common headers */
-		req.del_header("Referer");
+		req.RemoveHeader ("Referer");
-		req.del_header("Via");
+		req.RemoveHeader("Via");
-		req.del_header("Forwarded");
+		req.RemoveHeader("Forwarded");
 		/* drop proxy-disclosing headers */
-		std::vector<std::string> toErase;
+		req.RemoveHeader("X-Forwarded");
-		for (const auto& it : req.headers) {
+		req.RemoveHeader("Proxy-");		
-			if (it.first.compare(0, 12, "X-Forwarded-") == 0) {
-				toErase.push_back(it.first);
-			} else if (it.first.compare(0, 6, "Proxy-") == 0) {
-				toErase.push_back(it.first);
-			} else {
-				/* allow */
-			}
-		}
-		for (const auto& header : toErase) {
-			req.headers.erase(header);
-		}
 		/* replace headers */
-		req.add_header("Connection", "close", true); /* keep-alive conns not supported yet */
+		req.UpdateHeader("User-Agent", "MYOB/6.66 (AN/ON)");
-		req.add_header("User-Agent", "MYOB/6.66 (AN/ON)", true); /* privacy */
+		/* add headers */
+		req.AddHeader("Connection", "close"); /* keep-alive conns not supported yet */
 	}
 
 	/**
@@ -263,29 +253,36 @@ namespace proxy {
 		std::string dest_host = m_RequestURL.host;
 		uint16_t    dest_port = m_RequestURL.port;
 		/* always set port, even if missing in request */
-		if (!dest_port) {
+		if (!dest_port)
 			dest_port = (m_RequestURL.schema == "https") ? 443 : 80;
-		}
 		/* detect dest_host, set proper 'Host' header in upstream request */
-		auto h = m_ClientRequest.headers.find("Host");
+		if (dest_host != "") 
-		if (dest_host != "") {
+		{
 			/* absolute url, replace 'Host' header */
 			std::string h = dest_host;
 			if (dest_port != 0 && dest_port != 80)
 				h += ":" + std::to_string(dest_port);
-			m_ClientRequest.add_header("Host", h, true);
+			m_ClientRequest.UpdateHeader("Host", h);
-		} else if (h != m_ClientRequest.headers.end()) {
+		} 
-			/* relative url and 'Host' header provided. transparent proxy mode? */
+		else
-			i2p::http::URL u;
+		{	
-			std::string t = "http://" + h->second;
+			auto h = m_ClientRequest.GetHeader ("Host");
-			u.parse(t);
+			if (h.length () > 0) 
-			dest_host = u.host;
+			{
-			dest_port = u.port;
+				/* relative url and 'Host' header provided. transparent proxy mode? */
-		} else {
+				i2p::http::URL u;
-			/* relative url and missing 'Host' header */
+				std::string t = "http://" + h;
-			GenericProxyError("Invalid request", "Can't detect destination host from request");
+				u.parse(t);
-			return true;
+				dest_host = u.host;
-		}
+				dest_port = u.port;
+			} 
+			else 
+			{
+				/* relative url and missing 'Host' header */
+				GenericProxyError("Invalid request", "Can't detect destination host from request");
+				return true;
+			}
+		}	
 
 		/* check dest_host really exists and inside I2P network */
 		i2p::data::IdentHash identHash;
@@ -501,7 +498,7 @@ namespace proxy {
 		if (Kill())
 			return;
 		LogPrint (eLogDebug, "HTTPProxy: Created new I2PTunnel stream, sSID=", stream->GetSendStreamID(), ", rSID=", stream->GetRecvStreamID());
-		auto connection = std::make_shared<i2p::client::I2PTunnelConnection>(GetOwner(), m_sock, stream);
+		auto connection = std::make_shared<i2p::client::I2PClientTunnelConnectionHTTP>(GetOwner(), m_sock, stream);
 		GetOwner()->AddHandler (connection);
 		connection->I2PConnect (reinterpret_cast<const uint8_t*>(m_send_buf.data()), m_send_buf.length());
 		Done (shared_from_this());

HTTPServer.cpp

@@ -714,9 +714,11 @@ namespace http {
 				return true;
 		}
 		/* method #2: 'Authorization' header sent */
-		if (req.headers.count("Authorization") > 0) {
+		auto provided = req.GetHeader ("Authorization");
+		 if (provided.length () > 0) 
+		 {
 			bool result = false;
-			std::string provided = req.headers.find("Authorization")->second;
+			
 			std::string expected = user + ":" + pass;
 			size_t b64_sz = i2p::data::Base64EncodingBufferSize(expected.length()) + 1;
 			char * b64_creds = new char[b64_sz];
@@ -875,6 +877,7 @@ namespace http {
 
 	void HTTPConnection::SendReply (HTTPRes& reply, std::string& content)
 	{
+		reply.add_header("X-Frame-Options", "SAMEORIGIN");
 		reply.add_header("Content-Type", "text/html");
 		reply.body = content;
 

I2NPProtocol.cpp

@@ -27,6 +27,13 @@ namespace i2p
 		return std::make_shared<I2NPMessageBuffer<I2NP_MAX_SHORT_MESSAGE_SIZE> >();
 	}
 
+	std::shared_ptr<I2NPMessage> NewI2NPTunnelMessage ()
+	{
+		auto msg = new I2NPMessageBuffer<i2p::tunnel::TUNNEL_DATA_MSG_SIZE + I2NP_HEADER_SIZE + 34>(); // reserved for alignment and NTCP 16 + 6 + 12
+		msg->Align (12);
+		return std::shared_ptr<I2NPMessage>(msg);
+	}	
+	
 	std::shared_ptr<I2NPMessage> NewI2NPMessage (size_t len)
 	{
 		return (len < I2NP_MAX_SHORT_MESSAGE_SIZE/2) ? NewI2NPShortMessage () : NewI2NPMessage ();
@@ -464,7 +471,7 @@ namespace i2p
 
 	std::shared_ptr<I2NPMessage> CreateTunnelDataMsg (const uint8_t * buf)
 	{
-		auto msg = NewI2NPShortMessage ();
+		auto msg = NewI2NPTunnelMessage ();
 		msg->Concat (buf, i2p::tunnel::TUNNEL_DATA_MSG_SIZE);	
 		msg->FillI2NPMessageHeader (eI2NPTunnelData);
 		return msg;
@@ -472,7 +479,7 @@ namespace i2p
 
 	std::shared_ptr<I2NPMessage> CreateTunnelDataMsg (uint32_t tunnelID, const uint8_t * payload)	
 	{
-		auto msg = NewI2NPShortMessage ();
+		auto msg = NewI2NPTunnelMessage ();
 		htobe32buf (msg->GetPayload (), tunnelID);
 		msg->len += 4; // tunnelID
 		msg->Concat (payload, i2p::tunnel::TUNNEL_DATA_MSG_SIZE - 4);
@@ -482,7 +489,7 @@ namespace i2p
 
 	std::shared_ptr<I2NPMessage> CreateEmptyTunnelDataMsg ()
 	{
-		auto msg = NewI2NPShortMessage ();
+		auto msg = NewI2NPTunnelMessage ();
 		msg->len += i2p::tunnel::TUNNEL_DATA_MSG_SIZE; 
 		return msg;
 	}	

I2PTunnel.cpp

@@ -187,9 +187,9 @@ namespace client
 	{
 		if (ecode)
 		{
-			LogPrint (eLogError, "I2PTunnel: stream read error: ", ecode.message ());
 			if (ecode != boost::asio::error::operation_aborted)
 			{
+				LogPrint (eLogError, "I2PTunnel: stream read error: ", ecode.message ());
 				if (bytes_transferred > 0)
 					Write (m_StreamBuffer, bytes_transferred); // postpone termination
 				else if (ecode == boost::asio::error::timed_out && m_Stream && m_Stream->IsOpen ())
@@ -236,14 +236,63 @@ namespace client
 		}
 	}
 
-	I2PTunnelConnectionHTTP::I2PTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+	void I2PClientTunnelConnectionHTTP::Write (const uint8_t * buf, size_t len)
+	{
+		if (m_HeaderSent)
+			I2PTunnelConnection::Write (buf, len);
+		else
+		{
+			m_InHeader.clear ();
+			m_InHeader.write ((const char *)buf, len);
+			std::string line;
+			bool endOfHeader = false;
+			while (!endOfHeader)
+			{
+				std::getline(m_InHeader, line);
+				if (!m_InHeader.fail ())
+				{
+					if (line == "\r") endOfHeader = true;
+					else
+					{	
+						if (!m_ConnectionSent && !line.compare(0, 10, "Connection"))
+						{	
+							m_OutHeader << "Connection: close\r\n";
+							m_ConnectionSent = true;
+						}	
+						else if (!m_ProxyConnectionSent && !line.compare(0, 16, "Proxy-Connection"))
+						{	
+							m_OutHeader << "Proxy-Connection: close\r\n";
+							m_ProxyConnectionSent = true;
+						}	
+						else
+							m_OutHeader << line << "\n";
+					}	
+				}
+				else
+					break;
+			}
+
+			if (endOfHeader)
+			{
+				if (!m_ConnectionSent) m_OutHeader << "Connection: close\r\n";
+				 if (!m_ProxyConnectionSent) m_OutHeader << "Proxy-Connection: close\r\n";
+				m_OutHeader << "\r\n"; // end of header
+				m_OutHeader << m_InHeader.str ().substr (m_InHeader.tellg ()); // data right after header
+				m_InHeader.str ("");
+				m_HeaderSent = true;
+				I2PTunnelConnection::Write ((uint8_t *)m_OutHeader.str ().c_str (), m_OutHeader.str ().length ());
+			}
+		}
+	}	
+		
+	I2PServerTunnelConnectionHTTP::I2PServerTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
 		std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
 		const boost::asio::ip::tcp::endpoint& target, const std::string& host):
 		I2PTunnelConnection (owner, stream, socket, target), m_Host (host), m_HeaderSent (false), m_From (stream->GetRemoteIdentity ())
 	{
 	}
 
-	void I2PTunnelConnectionHTTP::Write (const uint8_t * buf, size_t len)
+	void I2PServerTunnelConnectionHTTP::Write (const uint8_t * buf, size_t len)
 	{
 		if (m_HeaderSent)
 			I2PTunnelConnection::Write (buf, len);
@@ -282,6 +331,7 @@ namespace client
 			{
 				m_OutHeader << "\r\n"; // end of header
 				m_OutHeader << m_InHeader.str ().substr (m_InHeader.tellg ()); // data right after header
+				m_InHeader.str ("");
 				m_HeaderSent = true;
 				I2PTunnelConnection::Write ((uint8_t *)m_OutHeader.str ().c_str (), m_OutHeader.str ().length ());
 			}
@@ -532,7 +582,7 @@ namespace client
 
 	std::shared_ptr<I2PTunnelConnection> I2PServerTunnelHTTP::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
 	{
-		return std::make_shared<I2PTunnelConnectionHTTP> (this, stream, 
+		return std::make_shared<I2PServerTunnelConnectionHTTP> (this, stream, 
 			std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint (), m_Host);
 	}
 

I2PTunnel.h

@@ -64,11 +64,30 @@ namespace client
 			bool m_IsQuiet; // don't send destination
 	};
 
-	class I2PTunnelConnectionHTTP: public I2PTunnelConnection
+	class I2PClientTunnelConnectionHTTP: public I2PTunnelConnection
+	{
+		public:
+
+			I2PClientTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+				std::shared_ptr<i2p::stream::Stream> stream):
+				I2PTunnelConnection (owner, socket, stream), m_HeaderSent (false),
+				m_ConnectionSent (false), m_ProxyConnectionSent (false) {};
+
+		protected:
+
+			void Write (const uint8_t * buf, size_t len);	
+			
+		private:	
+
+			std::stringstream m_InHeader, m_OutHeader;
+			bool m_HeaderSent, m_ConnectionSent, m_ProxyConnectionSent;
+	};	
+	
+	class I2PServerTunnelConnectionHTTP: public I2PTunnelConnection
 	{
 		public:
 			
-			I2PTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+			I2PServerTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
 				std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
 				const boost::asio::ip::tcp::endpoint& target, const std::string& host); 
 

NTCPSession.cpp

@@ -346,12 +346,15 @@ namespace transport
 			m_Decryption.Decrypt (m_ReceiveBuffer, bytes_transferred, m_ReceiveBuffer);
 			uint8_t * buf = m_ReceiveBuffer;
 			uint16_t size = bufbe16toh (buf);
-			SetRemoteIdentity (std::make_shared<i2p::data::IdentityEx> (buf + 2, size));
+			auto identity = std::make_shared<i2p::data::IdentityEx> (buf + 2, size);
-			if (m_Server.FindNTCPSession (m_RemoteIdentity->GetIdentHash ()))
+			if (m_Server.FindNTCPSession (identity->GetIdentHash ()))
 			{
 				LogPrint (eLogInfo, "NTCP: session already exists");
 				Terminate ();
 			}	
+			auto existing = i2p::data::netdb.FindRouter (identity->GetIdentHash ()); // check if exists already
+			SetRemoteIdentity (existing ? existing->GetRouterIdentity () : identity);
+		
 			size_t expectedSize = size + 2/*size*/ + 4/*timestamp*/ + m_RemoteIdentity->GetSignatureLen ();
 			size_t paddingLen = expectedSize & 0x0F;
 			if (paddingLen) paddingLen = (16 - paddingLen);	

NetDb.cpp

@@ -41,7 +41,9 @@ namespace data
 		InitProfilesStorage ();
 		m_Families.LoadCertificates ();
 		Load ();
-		if (m_RouterInfos.size () < 25) // reseed if # of router less than 50
+
+                uint16_t threshold; i2p::config::GetOption("reseed.threshold", threshold);
+		if (m_RouterInfos.size () < threshold) // reseed if # of router less than threshold
 			Reseed ();
 
 		m_IsRunning = true;
@@ -308,7 +310,6 @@ namespace data
 			m_Reseeder = new Reseeder ();
 			m_Reseeder->LoadCertificates (); // we need certificates for SU3 verification
 		}
-		int reseedRetries = 0;
 
 		// try reseeding from floodfill first if specified
 		std::string riPath;
@@ -328,11 +329,8 @@ namespace data
 				return;
 			}
 		}
-		
+
-		while (reseedRetries < 10 && !m_Reseeder->ReseedNowSU3 ())
+                m_Reseeder->Bootstrap ();
-			reseedRetries++;
-		if (reseedRetries >= 10)
-			LogPrint (eLogWarning, "NetDb: failed to reseed after 10 attempts");
 	}
 
 	void NetDb::ReseedFromFloodfill(const RouterInfo & ri, int numRouters, int numFloodfills)

Reseed.cpp

@@ -32,30 +32,74 @@ namespace data
 	{
 	}
 
-	int Reseeder::ReseedNowSU3 ()
+        /** @brief tries to bootstrap into I2P network (from local files and servers, with respect of options)
+         */
+        void Reseeder::Bootstrap ()
+        {
+            std::string su3FileName; i2p::config::GetOption("reseed.file", su3FileName);
+            std::string zipFileName; i2p::config::GetOption("reseed.zipfile", zipFileName);
+
+            if (su3FileName.length() > 0) // bootstrap from SU3 file or URL
+            {
+                int num;
+                if (su3FileName.length() > 8 && su3FileName.substr(0, 8) == "https://")
+                {
+                    num = ReseedFromSU3Url (su3FileName); // from https URL
+                }
+                else
+                {
+                    num = ProcessSU3File (su3FileName.c_str ());
+                }
+                if (num == 0)
+                    LogPrint (eLogWarning, "Reseed: failed to reseed from ", su3FileName);
+            }
+            else if (zipFileName.length() > 0) // bootstrap from ZIP file
+            {
+                int num = ProcessZIPFile (zipFileName.c_str ());
+                if (num == 0)
+                    LogPrint (eLogWarning, "Reseed: failed to reseed from ", zipFileName);
+            }
+            else // bootstrap from reseed servers
+            {
+                int num = ReseedFromServers ();
+                if (num == 0)
+                    LogPrint (eLogWarning, "Reseed: failed to reseed from servers");
+            }
+        }
+
+        /** @brief bootstrap from random server, retry 10 times
+         *  @return number of entries added to netDb
+         */
+	int Reseeder::ReseedFromServers ()
 	{
 		std::string reseedURLs; i2p::config::GetOption("reseed.urls", reseedURLs);
-		std::vector<std::string> httpsReseedHostList;
+                std::vector<std::string> httpsReseedHostList;
-		boost::split(httpsReseedHostList, reseedURLs, boost::is_any_of(","), boost::token_compress_on);
+                boost::split(httpsReseedHostList, reseedURLs, boost::is_any_of(","), boost::token_compress_on);
 
-		std::string filename; i2p::config::GetOption("reseed.file", filename);
+                if (reseedURLs.length () == 0)
-		if (filename.length() > 0) // reseed file is specified
+                {
-		{
+                    LogPrint (eLogWarning, "Reseed: No reseed servers specified");
-                    if (filename.length() > 8 && filename.substr(0, 8) == "https://")
+                    return 0;
-                    {
+                }
-                        return ReseedFromSU3 (filename); // reseed from https URL 
+
-                    } else {
+                int reseedRetries = 0;
-			auto num = ProcessSU3File (filename.c_str ());
+                while (reseedRetries < 10)
-			if (num > 0) return num; // success
+                {
-			LogPrint (eLogWarning, "Can't reseed from ", filename, " . Trying from hosts"); 
+                    auto ind = rand () % httpsReseedHostList.size ();
-                    }
+                    std::string reseedUrl = httpsReseedHostList[ind] + "i2pseeds.su3";
-		}	
+                    auto num = ReseedFromSU3Url (reseedUrl);
-		auto ind = rand () % httpsReseedHostList.size ();
+                    if (num > 0) return num; // success
-		std::string reseedUrl = httpsReseedHostList[ind] + "i2pseeds.su3";
+                    reseedRetries++;
-		return ReseedFromSU3 (reseedUrl);
+                }
+                LogPrint (eLogWarning, "Reseed: failed to reseed from servers after 10 attempts");
+                return 0;
 	}
 
-	int Reseeder::ReseedFromSU3 (const std::string& url)
+        /** @brief bootstrap from HTTPS URL with SU3 file
+         *  @param url
+         *  @return number of entries added to netDb
+         */
+	int Reseeder::ReseedFromSU3Url (const std::string& url)
 	{
 		LogPrint (eLogInfo, "Reseed: Downloading SU3 from ", url);
 		std::string su3 = HttpsRequest (url);
@@ -473,8 +517,8 @@ namespace data
 					LogPrint (eLogDebug, "Reseed: Connected to ", url.host, ":", url.port);
 					i2p::http::HTTPReq req;
 					req.uri = url.to_string();
-					req.add_header("User-Agent", "Wget/1.11.4");
+					req.AddHeader("User-Agent", "Wget/1.11.4");
-					req.add_header("Connection", "close");
+					req.AddHeader("Connection", "close");
 					s.write_some (boost::asio::buffer (req.to_string()));
 					// read response
 					std::stringstream rs;

Reseed.h

@@ -21,7 +21,11 @@ namespace data
 		
 			Reseeder();
 			~Reseeder();
-			int ReseedNowSU3 ();
+                        void Bootstrap ();
+			int ReseedFromServers ();
+			int ReseedFromSU3Url (const std::string& url);
+			int ProcessSU3File (const char * filename);
+			int ProcessZIPFile (const char * filename);
 
 			void LoadCertificates ();
 			
@@ -29,9 +33,6 @@ namespace data
 
 			void LoadCertificate (const std::string& filename);
 						
-			int ReseedFromSU3 (const std::string& url);
-			int ProcessSU3File (const char * filename);	
-			int ProcessZIPFile (const char * filename);
 			int ProcessSU3Stream (std::istream& s);	
 			int ProcessZIPStream (std::istream& s, uint64_t contentLength);	
 			

SSU.h

@@ -30,7 +30,7 @@ namespace transport
 
 	struct SSUPacket
 	{
-		i2p::crypto::AESAlignedBuffer<1500> buf;
+		i2p::crypto::AESAlignedBuffer<SSU_MTU_V6 + 18> buf; // max MTU + iv + size
 		boost::asio::ip::udp::endpoint from;
 		size_t len;
 	};	

SSUData.cpp

@@ -462,6 +462,7 @@ namespace transport
 				else
 					++it;
 			}
+			if (m_SentMessages.empty ()) return; // nothing to resend
 			if (numResent < MAX_OUTGOING_WINDOW_SIZE)
 				ScheduleResend ();
 			else

SSUData.h

@@ -21,13 +21,13 @@ namespace transport
 	#ifdef MESHNET
 	const size_t SSU_MTU_V6 = 1286;
 	#else
-	const size_t SSU_MTU_V6 = 1472;
+	const size_t SSU_MTU_V6 = 1488;
 	#endif
 	const size_t IPV4_HEADER_SIZE = 20;
 	const size_t IPV6_HEADER_SIZE = 40;	
 	const size_t UDP_HEADER_SIZE = 8;
 	const size_t SSU_V4_MAX_PACKET_SIZE = SSU_MTU_V4 - IPV4_HEADER_SIZE - UDP_HEADER_SIZE; // 1456
-	const size_t SSU_V6_MAX_PACKET_SIZE = SSU_MTU_V6 - IPV6_HEADER_SIZE - UDP_HEADER_SIZE; // 1424
+	const size_t SSU_V6_MAX_PACKET_SIZE = SSU_MTU_V6 - IPV6_HEADER_SIZE - UDP_HEADER_SIZE; // 1440
 	const int RESEND_INTERVAL = 3; // in seconds
 	const int MAX_NUM_RESENDS = 5;
 	const int DECAY_INTERVAL = 20; // in seconds

SSUSession.cpp

@@ -4,6 +4,7 @@
 #include "Timestamp.h"
 #include "RouterContext.h"
 #include "Transports.h"
+#include "NetDb.h"
 #include "SSU.h"
 #include "SSUSession.h"
 
@@ -317,7 +318,9 @@ namespace transport
 		payload++; // identity fragment info
 		uint16_t identitySize = bufbe16toh (payload);	
 		payload += 2; // size of identity fragment
-		SetRemoteIdentity (std::make_shared<i2p::data::IdentityEx> (payload, identitySize));
+		auto identity = std::make_shared<i2p::data::IdentityEx> (payload, identitySize);
+		auto existing = i2p::data::netdb.FindRouter (identity->GetIdentHash ()); // check if exists already
+		SetRemoteIdentity (existing ? existing->GetRouterIdentity () : identity);
 		m_Data.UpdatePacketSize (m_RemoteIdentity->GetIdentHash ());
 		payload += identitySize; // identity	
 		auto ts = i2p::util::GetSecondsSinceEpoch ();

Timestamp.cpp

@@ -5,6 +5,12 @@
 #include "I2PEndian.h"
 #include "Timestamp.h"
 
+#ifdef WIN32
+	#ifndef _WIN64
+		#define _USE_32BIT_TIME_T
+	#endif
+#endif
+
 namespace i2p
 {
 namespace util
@@ -33,17 +39,17 @@ namespace util
 					socket.send_to (boost::asio::buffer (buf, 48), ep);
 					int i = 0;
 					while (!socket.available() && i < 10) // 10 seconds max
-					{	
+					{
 						std::this_thread::sleep_for (std::chrono::seconds(1)); 
 						i++;
-					}	
+					}
 					if (socket.available ())
 						len = socket.receive_from (boost::asio::buffer (buf, 48), ep);
 				}
 				catch (std::exception& e)
 				{
 					LogPrint (eLogError, "NTP error: ", e.what ());
-				}	
+				}
 				if (len >= 8)
 				{
 					auto ourTs = GetSecondsSinceEpoch ();
@@ -51,10 +57,10 @@ namespace util
 					if (ts > 2208988800U) ts -= 2208988800U; // 1/1/1970 from 1/1/1900
 					g_TimeOffset = ts - ourTs;
 					LogPrint (eLogInfo,  address, " time offset from system time is ", g_TimeOffset, " seconds");
-				}	
+				}
 			}
 		}
-	}	
+	}
 }
 }
 

TunnelGateway.cpp

@@ -10,8 +10,8 @@ namespace i2p
 {
 namespace tunnel
 {
-	TunnelGatewayBuffer::TunnelGatewayBuffer (uint32_t tunnelID): m_TunnelID (tunnelID), 
+	TunnelGatewayBuffer::TunnelGatewayBuffer ():  
-				m_CurrentTunnelDataMsg (nullptr), m_RemainingSize (0) 
+		m_CurrentTunnelDataMsg (nullptr), m_RemainingSize (0) 
 	{
 		RAND_bytes (m_NonZeroRandomBuffer, TUNNEL_DATA_MAX_PAYLOAD_SIZE);
 		for (size_t i = 0; i < TUNNEL_DATA_MAX_PAYLOAD_SIZE; i++)
@@ -165,7 +165,6 @@ namespace tunnel
 		
 		m_CurrentTunnelDataMsg->offset = m_CurrentTunnelDataMsg->len - TUNNEL_DATA_MSG_SIZE - I2NP_HEADER_SIZE;
 		uint8_t * buf = m_CurrentTunnelDataMsg->GetPayload ();
-		htobe32buf (buf, m_TunnelID);
 		RAND_bytes (buf + 4, 16); // original IV	
 		memcpy (payload + size, buf + 4, 16); // copy IV for checksum 
 		uint8_t hash[32];
@@ -203,15 +202,19 @@ namespace tunnel
 	void TunnelGateway::SendBuffer ()
 	{
 		m_Buffer.CompleteCurrentTunnelDataMessage ();
-		const auto & tunnelMsgs = m_Buffer.GetTunnelDataMsgs ();
+		std::vector<std::shared_ptr<I2NPMessage> > newTunnelMsgs;
-		for (auto& tunnelMsg : tunnelMsgs)
+		const auto& tunnelDataMsgs = m_Buffer.GetTunnelDataMsgs ();
+		for (auto& tunnelMsg : tunnelDataMsgs)
 		{	
-			m_Tunnel->EncryptTunnelMsg (tunnelMsg, tunnelMsg); 
+			auto newMsg = CreateEmptyTunnelDataMsg ();
-			tunnelMsg->FillI2NPMessageHeader (eI2NPTunnelData); 
+			m_Tunnel->EncryptTunnelMsg (tunnelMsg, newMsg); 
+			htobe32buf (newMsg->GetPayload (), m_Tunnel->GetNextTunnelID ());
+			newMsg->FillI2NPMessageHeader (eI2NPTunnelData); 
+			newTunnelMsgs.push_back (newMsg);
 			m_NumSentBytes += TUNNEL_DATA_MSG_SIZE;
 		}	
-		i2p::transport::transports.SendMessages (m_Tunnel->GetNextIdentHash (), tunnelMsgs);
 		m_Buffer.ClearTunnelDataMsgs ();
+		i2p::transport::transports.SendMessages (m_Tunnel->GetNextIdentHash (), newTunnelMsgs);
 	}	
 }		
 }	

TunnelGateway.h

@@ -14,10 +14,10 @@ namespace tunnel
 	class TunnelGatewayBuffer
 	{
 		public:
-			TunnelGatewayBuffer (uint32_t tunnelID);
+			TunnelGatewayBuffer ();
 			~TunnelGatewayBuffer ();
 			void PutI2NPMsg (const TunnelMessageBlock& block);	
-			const std::vector<std::shared_ptr<I2NPMessage> >& GetTunnelDataMsgs () const { return m_TunnelDataMsgs; };
+			const std::vector<std::shared_ptr<const I2NPMessage> >& GetTunnelDataMsgs () const { return m_TunnelDataMsgs; };
 			void ClearTunnelDataMsgs ();
 			void CompleteCurrentTunnelDataMessage ();
 
@@ -27,8 +27,7 @@ namespace tunnel
 			
 		private:
 
-			uint32_t m_TunnelID;
+			std::vector<std::shared_ptr<const I2NPMessage> > m_TunnelDataMsgs;
-			std::vector<std::shared_ptr<I2NPMessage> > m_TunnelDataMsgs;
 			std::shared_ptr<I2NPMessage> m_CurrentTunnelDataMsg;
 			size_t m_RemainingSize;
 			uint8_t m_NonZeroRandomBuffer[TUNNEL_DATA_MAX_PAYLOAD_SIZE];
@@ -39,7 +38,7 @@ namespace tunnel
 		public:
 
 			TunnelGateway (TunnelBase * tunnel):
-				m_Tunnel (tunnel), m_Buffer (tunnel->GetNextTunnelID ()), m_NumSentBytes (0) {};
+				m_Tunnel (tunnel), m_NumSentBytes (0) {};
 			void SendTunnelDataMsg (const TunnelMessageBlock& block);	
 			void PutTunnelDataMsg (const TunnelMessageBlock& block);
 			void SendBuffer ();			

Win32/Win32App.cpp

@@ -1,8 +1,12 @@
 #include <string.h>
 #include <windows.h>
 #include <shellapi.h>
+#include "../ClientContext.h"
 #include "../Config.h"
+#include "../NetDb.h"
 #include "../RouterContext.h"
+#include "../Transports.h"
+#include "../Tunnel.h"
 #include "../version.h"
 #include "resource.h"
 #include "Win32App.h"
@@ -22,230 +26,332 @@
 #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)
+	static void ShowPopupMenu (HWND hWnd, POINT *curpos, int wDefaultItem)
-    {
+	{
-        HMENU hPopup = CreatePopupMenu();
+		HMENU hPopup = CreatePopupMenu();
-        InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_CONSOLE, "Open &console");
+		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_APP, "Show app");
-        InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_ABOUT, "&About...");
+		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_SEPARATOR, NULL, NULL);
-        InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_GRACEFUL_SHUTDOWN, "&Graceful shutdown");
+		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_GRACEFUL_SHUTDOWN, "&Graceful shutdown");
-        InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_EXIT, "E&xit");
+		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_EXIT, "E&xit");
-        SetMenuDefaultItem (hPopup, ID_CONSOLE, FALSE);
+		SetMenuDefaultItem (hPopup, ID_CONSOLE, FALSE);
-        SendMessage (hWnd, WM_INITMENUPOPUP, (WPARAM)hPopup, 0);
+		SendMessage (hWnd, WM_INITMENUPOPUP, (WPARAM)hPopup, 0);
 
-        POINT p;
+		POINT p;
-        if (!curpos)
+		if (!curpos)
-        {
+		{
-            GetCursorPos (&p);
+			GetCursorPos (&p);
-            curpos = &p;
+			curpos = &p;
-        }
+		}
 
-        WORD cmd = TrackPopupMenu (hPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY, curpos->x, curpos->y, 0, hWnd, NULL);
+		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);
+		SendMessage (hWnd, WM_COMMAND, cmd, 0);
 
-        DestroyMenu(hPopup);
+		DestroyMenu(hPopup);
-    }
+	}
 
-    static void AddTrayIcon (HWND hWnd)
+	static void AddTrayIcon (HWND hWnd)
-    {
+	{
-        NOTIFYICONDATA nid;
+		NOTIFYICONDATA nid;
-        memset(&nid, 0, sizeof(nid));
+		memset(&nid, 0, sizeof(nid));
-        nid.cbSize = sizeof(nid);
+		nid.cbSize = sizeof(nid);
-        nid.hWnd = hWnd;
+		nid.hWnd = hWnd;
-        nid.uID = ID_TRAY_ICON;
+		nid.uID = ID_TRAY_ICON;
-        nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
+		nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
-        nid.uCallbackMessage = WM_TRAYICON;
+		nid.uCallbackMessage = WM_TRAYICON;
-        nid.hIcon = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE (MAINICON));
+		nid.hIcon = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE (MAINICON));
-        strcpy (nid.szTip, "i2pd");
+		strcpy (nid.szTip, "i2pd");
-        strcpy (nid.szInfo, "i2pd is running");
+		strcpy (nid.szInfo, "i2pd is running");
-        Shell_NotifyIcon(NIM_ADD, &nid );
+		Shell_NotifyIcon(NIM_ADD, &nid );
-    }
+	}
 
-    static void RemoveTrayIcon (HWND hWnd)
+	static void RemoveTrayIcon (HWND hWnd)
-    {
+	{
-        NOTIFYICONDATA nid;
+		NOTIFYICONDATA nid;
-        nid.hWnd = hWnd;
+		nid.hWnd = hWnd;
-        nid.uID = ID_TRAY_ICON;
+		nid.uID = ID_TRAY_ICON;
-        Shell_NotifyIcon (NIM_DELETE, &nid);
+		Shell_NotifyIcon (NIM_DELETE, &nid);
-    }
+	}
 
-    static LRESULT CALLBACK WndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+	static void ShowUptime (std::stringstream& s, int seconds) 
-    {
+	{
-        switch (uMsg)
+		int num;
-        {
-            case WM_CREATE:
-            {
-                AddTrayIcon (hWnd);
-                break;
-            }
-            case WM_CLOSE:
-            {
-                RemoveTrayIcon (hWnd);
-                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);
-                        return 0;
-                    }
-                }
-                break;
-            }
-            case WM_SYSCOMMAND:
-            {
-                switch (wParam)
-                {
-                    case SC_MINIMIZE:
-                    {
-                        ShowWindow(hWnd, SW_HIDE);
-                        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);
-                            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;
-                }
-                break;
-            }
-        }
-        return DefWindowProc( hWnd, uMsg, wParam, lParam);
-    }
 
-    bool StartWin32App ()
+		if ((num = seconds / 86400) > 0) {
-    {
+			s << num << " days, ";
-        if (FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd")))
+			seconds -= num * 86400;
-        {
+		}
-            MessageBox(NULL, TEXT("I2Pd is running already"), TEXT("Warning"), MB_OK);
+		if ((num = seconds / 3600) > 0) {
-            return false;
+			s << num << " hours, ";
-        }
+			seconds -= num * 3600;
-        // register main window
+		}
-        auto hInst = GetModuleHandle(NULL);
+		if ((num = seconds / 60) > 0) {
-        WNDCLASSEX wclx;
+			s << num << " min, ";
-        memset (&wclx, 0, sizeof(wclx));
+			seconds -= num * 60;
-        wclx.cbSize = sizeof(wclx);
+		}
-        wclx.style = 0;
+		s << seconds << " seconds\n";
-        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.lpszMenuName = NULL;
-        wclx.lpszClassName = I2PD_WIN32_CLASSNAME;
-        RegisterClassEx (&wclx);
-        // create new window
-        if (!CreateWindow(I2PD_WIN32_CLASSNAME, TEXT("i2pd"), WS_OVERLAPPEDWINDOW, 100, 100, 549, 738, 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 ()
+	static void ShowTransfered (std::stringstream& s, int transfer)
-    {
+	{
-        MSG msg;
+		auto bytes = transfer & 0x03ff;
-        while (GetMessage (&msg, NULL, 0, 0 ))
+		transfer >>= 10;
-        {
+		auto kbytes = transfer & 0x03ff;
-            TranslateMessage (&msg);
+		transfer >>= 10;
-            DispatchMessage (&msg);
+		auto mbytes = transfer & 0x03ff;
-        }
+		transfer >>= 10;
-        return msg.wParam;
+		auto gbytes = transfer & 0x03ff;
-    }
 
-    void StopWin32App ()
+		if (gbytes)
-    {
+			s << gbytes << " GB, ";
-         UnregisterClass (I2PD_WIN32_CLASSNAME, GetModuleHandle(NULL));
+		if (mbytes)
-    }
+			s << mbytes << " MB, ";
+		if (kbytes)
+			s << kbytes << " KB, ";
+		s << bytes << " Bytes\n";
+	}
 
-    bool GracefulShutdown ()
+	static void PrintMainWindowText (std::stringstream& s)
-    {
+	{
-        HWND hWnd = FindWindow (I2PD_WIN32_CLASSNAME, TEXT("i2pd"));
+		s << "Status: ";
-        if (hWnd)
+		switch (i2p::context.GetStatus())
-            PostMessage (hWnd, WM_COMMAND, MAKEWPARAM(ID_GRACEFUL_SHUTDOWN, 0), 0);
+		{
-        return hWnd;
+			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 << "Recvieved: "; 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/installer.iss

@@ -1,5 +1,5 @@
 #define I2Pd_AppName "i2pd"
-#define I2Pd_ver "2.11.0"
+#define I2Pd_ver "2.12.0"
 #define I2Pd_Publisher "PurpleI2P"
 
 [Setup]

android/AndroidManifest.xml

@@ -2,7 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="org.purplei2p.i2pd"
       android:versionCode="1"
-      android:versionName="2.11.0">
+      android:versionName="2.12.0">
     <uses-sdk android:minSdkVersion="9" android:targetSdkVersion="24"/>
 	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.INTERNET"/>

contrib/apparmor/usr.sbin.i2pd

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

debian/changelog

@@ -1,3 +1,9 @@
+i2pd (2.12.0-1) unstable; urgency=low
+
+  * updated to version 2.12.0/0.9.28
+
+ -- orignal <orignal@i2pmail.org>  Tue, 14 Feb 2016 17:59:30 +0000
+
 i2pd (2.11.0-1) unstable; urgency=low
 
   * updated to version 2.11.0/0.9.28

debian/control

@@ -1,7 +1,7 @@
 Source: i2pd
 Section: net
 Priority: extra
-Maintainer: hagen <hagen@i2pmail.org>
+Maintainer: R4SAS <r4sas@i2pmail.org>
 Build-Depends: debhelper (>= 9.0.0), dpkg-dev (>= 1.16.1~),
  gcc (>= 4.7) | clang (>= 3.3),
  libboost-system-dev (>= 1.46),

debian/copyright

@@ -3,9 +3,9 @@ Upstream-Name: i2pd
 Source: https://github.com/PurpleI2P
 
 Files: *
-Copyright: 2013-2016 PurpleI2P
+Copyright: 2013-2017 PurpleI2P
 License: BSD-3-clause
- Copyright (c) 2013-2016, The PurpleI2P Project
+ Copyright (c) 2013-2017, The PurpleI2P Project
  .
  All rights reserved.
  .
@@ -34,7 +34,8 @@ License: BSD-3-clause
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 Files: debian/*
-Copyright: 2014-2016 hagen <hagen@i2pmail.org>
+Copyright: 2016-2017 R4SAS <r4sas@i2pmail.org>
+           2014-2016 hagen <hagen@i2pmail.org>
            2013-2015 Kill Your TV <killyourtv@i2pmail.org>
 License: GPL-2.0+
  This package is free software; you can redistribute it and/or modify

debian/i2pd.default

@@ -8,4 +8,4 @@ I2PD_ENABLED="yes"
 DAEMON_OPTS=""
 
 # If you have problems with hunging i2pd, you can try enable this 
-#ulimit -n 4096
+ulimit -n 4096

docs/configuration.md

@@ -46,6 +46,7 @@ All options below still possible in cmdline, but better write it in config file:
 * --httpproxy.address=  - The address to listen on (HTTP Proxy)  
 * --httpproxy.port=     - The port to listen on (HTTP Proxy) 4444 by default  
 * --httpproxy.keys=     - optional keys file for HTTP proxy local destination  
+* --httpproxy.signaturetype=    - signature type for new keys if keys file is set. 7 by default  
 * --httpproxy.inbound.length= 	- Inbound tunnels length if keys is set. 3 by default  
 * --httpproxy.inbound.quantity= - Inbound tunnels quantity if keys is set. 5 by default  
 * --httpproxy.outbound.length=	- Outbound tunnels length if keys is set. 3 by default  
@@ -55,6 +56,7 @@ All options below still possible in cmdline, but better write it in config file:
 * --socksproxy.address= - The address to listen on (SOCKS Proxy)  
 * --socksproxy.port=    - The port to listen on (SOCKS Proxy). 4447 by default  
 * --socksproxy.keys=    - optional keys file for SOCKS proxy local destination  
+* --socksproxy.signaturetype=   - signature type for new keys if keys file is set. 7 by default
 * --socksproxy.inbound.length= 	- Inbound tunnels length if keys is set. 3 by default  
 * --socksproxy.inbound.quantity= - Inbound tunnels quantity if keys is set. 5 by default  
 * --socksproxy.outbound.length=	- Outbound tunnels length if keys is set. 3 by default  

qt/i2pd_qt/android/AndroidManifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0"?>
-<manifest package="org.purplei2p.i2pd" xmlns:android="http://schemas.android.com/apk/res/android" android:versionName="2.11.0" android:versionCode="2" android:installLocation="auto">
+<manifest package="org.purplei2p.i2pd" xmlns:android="http://schemas.android.com/apk/res/android" android:versionName="2.12.0" android:versionCode="2" android:installLocation="auto">
     <uses-sdk android:minSdkVersion="11" android:targetSdkVersion="23"/>
         <supports-screens android:largeScreens="true" android:normalScreens="true" android:anyDensity="true" android:smallScreens="true"/>
     <!-- <application android:hardwareAccelerated="true" -->

version.h

@@ -7,7 +7,7 @@
 #define MAKE_VERSION(a,b,c) STRINGIZE(a) "." STRINGIZE(b) "." STRINGIZE(c)
 
 #define I2PD_VERSION_MAJOR 2
-#define I2PD_VERSION_MINOR 11
+#define I2PD_VERSION_MINOR 12
 #define I2PD_VERSION_MICRO 0
 #define I2PD_VERSION_PATCH 0
 #define I2PD_VERSION MAKE_VERSION(I2PD_VERSION_MAJOR, I2PD_VERSION_MINOR, I2PD_VERSION_MICRO)