Merge pull request #455 from PurpleI2P/openssl

recent changes

AddressBook.cpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <condition_variable>
 #include <boost/lexical_cast.hpp>
+#include <openssl/rand.h>
 #include "Base.h"
 #include "util.h"
 #include "Identity.h"
@@ -218,10 +219,17 @@ namespace client
 		m_Storage->Init();
 		LoadHosts (); /* try storage, then hosts.txt, then download */
 		StartSubscriptions ();
+		StartLookups ();
+	}
+
+	void AddressBook::StartResolvers ()
+	{
+		LoadLocal ();
 	}	
 	
 	void AddressBook::Stop ()
 	{
+		StopLookups ();
 		StopSubscriptions ();
 		if (m_SubscriptionsUpdateTimer)
 		{	
@@ -275,9 +283,12 @@ namespace client
 					return true;
 				}
 				else
+				{	
+					LookupAddress (address); // TODO:
 					return false;
 				}	
 			}
+		}	
 		// if not .b32 we assume full base64 address
 		i2p::data::IdentityEx dest;
 		if (!dest.FromBase64 (address))
@@ -330,7 +341,6 @@ namespace client
 			LoadHostsFromStream (f);
 			m_IsLoaded = true;
 		}
-		LoadLocal ();
 	}
 
 	void AddressBook::LoadHostsFromStream (std::istream& f)
@@ -518,6 +528,94 @@ namespace client
 		}
 	}
 
+	void AddressBook::StartLookups ()
+	{
+		auto dest = i2p::client::context.GetSharedLocalDestination ();
+		if (dest)
+		{
+			auto datagram = dest->GetDatagramDestination ();
+			if (!datagram)
+				datagram = dest->CreateDatagramDestination ();
+			datagram->SetReceiver (std::bind (&AddressBook::HandleLookupResponse, this, 
+				std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5), 
+				ADDRESS_RESPONSE_DATAGRAM_PORT);
+		}	
+	}
+	
+	void AddressBook::StopLookups ()
+	{
+		auto dest = i2p::client::context.GetSharedLocalDestination ();
+		if (dest)
+		{
+			auto datagram = dest->GetDatagramDestination ();
+			if (datagram)
+			    datagram->ResetReceiver (ADDRESS_RESPONSE_DATAGRAM_PORT);
+		}	
+	}
+
+	void AddressBook::LookupAddress (const std::string& address)
+	{
+		const i2p::data::IdentHash * ident = nullptr;
+		auto dot = address.find ('.');
+		if (dot != std::string::npos)
+			ident = FindAddress (address.substr (dot + 1));
+		if (!ident)
+		{
+			LogPrint (eLogError, "AddressBook: Can't find domain for ", address);
+			return;
+		}	
+		
+		auto dest = i2p::client::context.GetSharedLocalDestination ();
+		if (dest)
+		{
+			auto datagram = dest->GetDatagramDestination ();
+			if (datagram)
+			{
+				uint32_t nonce;
+				RAND_bytes ((uint8_t *)&nonce, 4);
+				{
+					std::unique_lock<std::mutex> l(m_LookupsMutex);
+					m_Lookups[nonce] = address; 
+				}	
+				LogPrint (eLogDebug, "AddressBook: Lookup of ", address, " to ", ident->ToBase32 (), " nonce=", nonce);
+				size_t len = address.length () + 9;
+				uint8_t * buf = new uint8_t[len];
+				memset (buf, 0, 4);
+				htobe32buf (buf + 4, nonce);
+				buf[8] = address.length ();
+				memcpy (buf + 9, address.c_str (), address.length ());
+				datagram->SendDatagramTo (buf, len, *ident, ADDRESS_RESPONSE_DATAGRAM_PORT, ADDRESS_RESOLVER_DATAGRAM_PORT);
+				delete[] buf;
+			}	
+		}		
+	}	
+	
+	void AddressBook::HandleLookupResponse (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
+	{
+		if (len < 44)
+		{
+			LogPrint (eLogError, "AddressBook: Lookup response is too short ", len);
+			return;
+		}
+		uint32_t nonce = bufbe32toh (buf + 4);
+		LogPrint (eLogDebug, "AddressBook: Lookup response received from ", from.GetIdentHash ().ToBase32 (), " nonce=", nonce);
+		std::string address;
+		{
+			std::unique_lock<std::mutex> l(m_LookupsMutex);
+			auto it = m_Lookups.find (nonce);
+			if (it != m_Lookups.end ())
+			{	
+				address = it->second;
+				m_Lookups.erase (it);
+			}	
+		}	
+		if (address.length () > 0)
+		{
+			// TODO: verify from
+			m_Addresses[address] = buf + 8;
+		}	
+	}
+	
 	AddressBookSubscription::AddressBookSubscription (AddressBook& book, const std::string& link):
 		m_Book (book), m_Link (link)
 	{
@@ -701,11 +799,21 @@ namespace client
 		}
 	}
 
+	AddressResolver::~AddressResolver ()
+	{
+		if (m_LocalDestination)
+		{
+			auto datagram = m_LocalDestination->GetDatagramDestination ();
+			if (datagram)
+			    datagram->ResetReceiver (ADDRESS_RESOLVER_DATAGRAM_PORT);
+		}	
+	}	
+		
 	void AddressResolver::HandleRequest (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
 	{
 		if (len < 9 || len < buf[8] + 9U)
 		{
-			LogPrint (eLogError, "Address request is too short ", len);
+			LogPrint (eLogError, "AddressBook: Address request is too short ", len);
 			return;
 		}
 		// read requested address
@@ -713,8 +821,9 @@ namespace client
 		char address[255];
 		memcpy (address, buf + 9, l);
 		address[l] = 0;		
+		LogPrint (eLogDebug, "AddressBook: Address request ", address);
 		// send response
-		uint8_t response[40];
+		uint8_t response[44];
 		memset (response, 0, 4); // reserved
 		memcpy (response + 4, buf + 4, 4); // nonce 	
 		auto it = m_LocalAddresses.find (address); // address lookup
@@ -722,7 +831,8 @@ namespace client
 			memcpy (response + 8, it->second, 32); // ident 
 		else
 			memset (response + 8, 0, 32); // not found 
-		m_LocalDestination->GetDatagramDestination ()->SendDatagramTo (response, 40, from.GetIdentHash (), toPort, fromPort);
+		memset (response + 40, 0, 4); // set expiration time to zero
+		m_LocalDestination->GetDatagramDestination ()->SendDatagramTo (response, 44, from.GetIdentHash (), toPort, fromPort);
 	}
 
 	void AddressResolver::AddAddress (const std::string& name, const i2p::data::IdentHash& ident)

AddressBook.h

@@ -18,13 +18,16 @@ namespace i2p
 {
 namespace client
 {
-	const char DEFAULT_SUBSCRIPTION_ADDRESS[] = "http://udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p/hosts.txt";
+	const char DEFAULT_SUBSCRIPTION_ADDRESS[] = "http://joajgazyztfssty4w2on5oaqksz6tqoxbduy553y34mf4byv6gpq.b32.i2p/export/alive-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
 
+	const uint16_t ADDRESS_RESOLVER_DATAGRAM_PORT = 53;	
+	const uint16_t ADDRESS_RESPONSE_DATAGRAM_PORT = 54;
+	
 	inline std::string GetB32Address(const i2p::data::IdentHash& ident) { return ident.ToBase32().append(".b32.i2p"); }
 
 	class AddressBookStorage // interface for storage
@@ -54,10 +57,12 @@ namespace client
 			AddressBook ();
 			~AddressBook ();
 			void Start ();
+			void StartResolvers ();
 			void Stop ();
 			bool GetIdentHash (const std::string& address, i2p::data::IdentHash& ident);
 			std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const std::string& address);
 			const i2p::data::IdentHash * FindAddress (const std::string& address);
+			void LookupAddress (const std::string& address);
 			void InsertAddress (const std::string& address, const std::string& base64); // for jump service
 			void InsertAddress (std::shared_ptr<const i2p::data::IdentityEx> address);
 
@@ -80,11 +85,17 @@ namespace client
 
 			void HandleSubscriptionsUpdateTimer (const boost::system::error_code& ecode);
 
+			void StartLookups ();
+			void StopLookups ();
+			void HandleLookupResponse (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
+			
 		private:	
 
 			std::mutex m_AddressBookMutex;
 			std::map<std::string, i2p::data::IdentHash>  m_Addresses;
 			std::map<i2p::data::IdentHash, std::shared_ptr<AddressResolver> > m_Resolvers; // local destination->resolver
+			std::mutex m_LookupsMutex;
+			std::map<uint32_t, std::string> m_Lookups; // nonce -> address
 			AddressBookStorage * m_Storage;
 			volatile bool m_IsLoaded, m_IsDownloading;
 			std::vector<AddressBookSubscription *> m_Subscriptions;
@@ -111,12 +122,12 @@ namespace client
 			// m_Etag must be surrounded by ""
 	};
 
-	const uint16_t ADDRESS_RESOLVER_DATAGRAM_PORT = 53;	
 	class AddressResolver
 	{
 		public:
 
 			AddressResolver (std::shared_ptr<ClientDestination> destination);
+			~AddressResolver ();
 			void AddAddress (const std::string& name, const i2p::data::IdentHash& ident);
 
 		private:

ClientContext.cpp

@@ -96,6 +96,8 @@ namespace client
 			m_BOBCommandChannel = new BOBCommandChannel (bobAddr, bobPort);
 			m_BOBCommandChannel->Start ();
 		} 
+
+		m_AddressBook.StartResolvers ();	
 	}
 		
 	void ClientContext::Stop ()
@@ -259,8 +261,15 @@ namespace client
 	{
 		boost::property_tree::ptree pt;
 		std::string tunConf; i2p::config::GetOption("tunconf", tunConf);
-		if (tunConf == "")
+		if (tunConf == "") {
+			// TODO: cleanup this in 2.8.0
 			tunConf = i2p::fs::DataDirPath ("tunnels.cfg");
+			if (i2p::fs::Exists(tunConf)) {
+				LogPrint(eLogWarning, "FS: please rename tunnels.cfg -> tunnels.conf here: ", tunConf);
+			} else {
+				tunConf = i2p::fs::DataDirPath ("tunnels.conf");
+			}
+		}
 		LogPrint(eLogDebug, "FS: tunnels config file: ", tunConf);
 		try 
 		{

Config.cpp

@@ -107,10 +107,10 @@ namespace config {
     options_description general("General options");
     general.add_options()
       ("help",     "Show this message")
-      ("conf",      value<std::string>()->default_value(""),     "Path to main i2pd config file (default: try ~/.i2pd/i2p.conf or /var/lib/i2pd/i2p.conf)")
+      ("conf",      value<std::string>()->default_value(""),     "Path to main i2pd config file (default: try ~/.i2pd/i2pd.conf or /var/lib/i2pd/i2pd.conf)")
-      ("tunconf",   value<std::string>()->default_value(""),     "Path to config with tunnels list and options (default: try ~/.i2pd/tunnels.cfg or /var/lib/i2pd/tunnels.cfg)")
+      ("tunconf",   value<std::string>()->default_value(""),     "Path to config with tunnels list and options (default: try ~/.i2pd/tunnels.conf or /var/lib/i2pd/tunnels.conf)")
       ("pidfile",   value<std::string>()->default_value(""),     "Path to pidfile (default: ~/i2pd/i2pd.pid or /var/lib/i2pd/i2pd.pid)")
-      ("log",       value<std::string>()->default_value(""),     "Logs destination: stdout, file (stdout if not set, file - otherwise, for compatibility)")
+      ("log",       value<std::string>()->default_value(""),     "Logs destination: stdout, file, syslog (stdout if not set)")
       ("logfile",   value<std::string>()->default_value(""),     "Path to logfile (stdout if not set, autodetect if daemon)")
       ("loglevel",  value<std::string>()->default_value("info"), "Set the minimal level of log messages (debug, info, warn, error)")
 	  ("family",    value<std::string>()->default_value(""),     "Specify a family, router belongs to")

Daemon.cpp

@@ -69,27 +69,57 @@ namespace i2p
 			i2p::fs::Init();
 
 			datadir = i2p::fs::GetDataDir();
+			// TODO: drop old name detection in v2.8.0
 			if (config == "")
 			{
 				config = i2p::fs::DataDirPath("i2p.conf");
-				// use i2p.conf only if exists
+				if (i2p::fs::Exists (config)) {
-				if (!i2p::fs::Exists (config)) config = ""; /* reset */
+					LogPrint(eLogWarning, "Daemon: please rename i2p.conf to i2pd.conf here: ", config);
+				} else {
+					config = i2p::fs::DataDirPath("i2pd.conf");
+					if (!i2p::fs::Exists (config)) {
+						// use i2pd.conf only if exists
+						config = ""; /* reset */
+					}
+				}
 			}
 
 			i2p::config::ParseConfig(config);
 			i2p::config::Finalize();
 
-			i2p::crypto::InitCrypto ();
-			i2p::context.Init ();
-
 			i2p::config::GetOption("daemon", isDaemon);
 
-			// TODO: move log init here
+			std::string logs     = ""; i2p::config::GetOption("log",      logs);
+			std::string logfile  = ""; i2p::config::GetOption("logfile",  logfile);
+			std::string loglevel = ""; i2p::config::GetOption("loglevel", loglevel);
+
+			/* setup logging */
+			if (isDaemon && (logs == "" || logs == "stdout"))
+				logs = "file";
+
+			i2p::log::Logger().SetLogLevel(loglevel);
+			if (logs == "file") {
+				if (logfile == "")
+					logfile = i2p::fs::DataDirPath("i2pd.log");
+				LogPrint(eLogInfo, "Log: will send messages to ", logfile);
+				i2p::log::Logger().SendTo (logfile);
+#ifndef _WIN32
+			} else if (logs == "syslog") {
+				LogPrint(eLogInfo, "Log: will send messages to syslog");
+				i2p::log::Logger().SendTo("i2pd", LOG_DAEMON);
+#endif
+			} else {
+				// use stdout -- default
+			}
+			i2p::log::Logger().Ready();
 
 			LogPrint(eLogInfo,  "i2pd v", VERSION, " starting");
 			LogPrint(eLogDebug, "FS: main config file: ", config);
 			LogPrint(eLogDebug, "FS: data directory: ", datadir);
 
+			i2p::crypto::InitCrypto ();
+			i2p::context.Init ();
+
 			uint16_t port; i2p::config::GetOption("port", port);
 			if (!i2p::config::IsDefault("port"))
 			{	
@@ -152,23 +182,6 @@ namespace i2p
 			
 		bool Daemon_Singleton::start()
 		{
-			std::string logs     = ""; i2p::config::GetOption("log",      logs);
-			std::string logfile  = ""; i2p::config::GetOption("logfile",  logfile);
-			std::string loglevel = ""; i2p::config::GetOption("loglevel", loglevel);
-
-			if (isDaemon && (logs == "" || logs == "stdout"))
-				logs = "file";
-
-			if (logs == "file") {
-				if (logfile == "")
-					logfile = i2p::fs::DataDirPath("i2pd.log");
-				StartLog (logfile);
-			} else {
-				// use stdout
-				StartLog ("");
-			}
-			SetLogLevel(loglevel);
-			
 			bool http; i2p::config::GetOption("http.enabled", http);
 			if (http) {
 				std::string httpAddr; i2p::config::GetOption("http.address", httpAddr);
@@ -233,7 +246,6 @@ namespace i2p
 				d.m_I2PControlService = nullptr;
 			}	
 			i2p::crypto::TerminateCrypto ();
-			StopLog ();
 
 			return true;
 		}

DaemonLinux.cpp

@@ -19,7 +19,7 @@ void handle_signal(int sig)
 	{
 	case SIGHUP:
 		LogPrint(eLogInfo, "Daemon: Got SIGHUP, reopening log...");
-		ReopenLogFile ();
+		i2p::log::Logger().Reopen ();
 	break;
 	case SIGABRT:
 	case SIGTERM:
@@ -64,12 +64,9 @@ namespace i2p
 				}
 
 				// close stdin/stdout/stderr descriptors
-				::close (0);
+				freopen("/dev/null", "r", stdin);
-				::open ("/dev/null", O_RDWR);
+				freopen("/dev/null", "w", stdout);
-				::close (1);
+				freopen("/dev/null", "w", stderr);
-				::open ("/dev/null", O_RDWR);	
-				::close (2);
-				::open ("/dev/null", O_RDWR);
 			}
 
 			// Pidfile

DaemonWin32.cpp

@@ -75,7 +75,7 @@ namespace i2p
             i2p::config::SetOption("log", std::string ("file"));
 #endif
 			bool ret = Daemon_Singleton::start();
-			if (ret && IsLogToFile ())
+			if (ret && i2p::log::Logger().GetLogType() == eLogFile)
 			{
 				// TODO: find out where this garbage to console comes from
 				SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);

HTTPProxy.cpp

@@ -39,6 +39,7 @@ namespace proxy
 			void HTTPRequestFailed(/*std::string message*/);
 			void RedirectToJumpService();
 			void ExtractRequest();
+			bool IsI2PAddress();
 			bool ValidateHTTPRequest();
 			void HandleJumpServices();
 			bool CreateHTTPRequest(uint8_t *http_buff, std::size_t len);
@@ -176,6 +177,16 @@ namespace proxy
 		m_path.erase(addressHelperPos);
 	}
 
+	bool HTTPProxyHandler::IsI2PAddress()
+	{
+		auto pos = m_address.rfind (".i2p");
+		if (pos != std::string::npos && (pos+4) == m_address.length ())
+		{
+			return true;
+		}
+		return false;
+	}
+
 	bool HTTPProxyHandler::CreateHTTPRequest(uint8_t *http_buff, std::size_t len) 
 	{
 		ExtractRequest(); //TODO: parse earlier
@@ -183,10 +194,14 @@ namespace proxy
 		HandleJumpServices();
 
 		i2p::data::IdentHash identHash;
+		if (IsI2PAddress ())
+		{
 			if (!i2p::client::context.GetAddressBook ().GetIdentHash (m_address, identHash)){
 				RedirectToJumpService();
 				return false;
 			}
+		}
+		
 
 		m_request = m_method;
 		m_request.push_back(' ');

HTTPServer.cpp

@@ -421,10 +421,25 @@ namespace util
 		} 
 		s << "<br>\r\n";
 		s << "<b>Tunnel creation success rate:</b> " << i2p::tunnel::tunnels.GetTunnelCreationSuccessRate () << "%<br>\r\n";
-		s << "<b>Received:</b> " << i2p::transport::transports.GetTotalReceivedBytes ()/1000 << "K";
+		s << "<b>Received:</b> ";
-		s << " (" << i2p::transport::transports.GetInBandwidth () <<" Bps)<br>\r\n";
+		s << std::fixed << std::setprecision(2);
-		s << "<b>Sent:</b> " << i2p::transport::transports.GetTotalSentBytes ()/1000 << "K";
+		auto numKBytesReceived = (double) i2p::transport::transports.GetTotalReceivedBytes () / 1024;
-		s << " (" << i2p::transport::transports.GetOutBandwidth () <<" Bps)<br>\r\n";
+		if (numKBytesReceived < 1024)
+			s << numKBytesReceived << " KiB";
+		else if (numKBytesReceived < 1024 * 1024)
+			s << numKBytesReceived / 1024 << " MiB";
+		else
+			s << numKBytesReceived / 1024 / 1024 << " GiB";
+		s << " (" << (double) i2p::transport::transports.GetInBandwidth () / 1024 << " KiB/s)<br>\r\n";
+		s << "<b>Sent:</b> ";
+		auto numKBytesSent = (double) i2p::transport::transports.GetTotalSentBytes () / 1024;
+		if (numKBytesSent < 1024)
+			s << numKBytesSent << " KiB";
+		else if (numKBytesSent < 1024 * 1024)
+			s << numKBytesSent / 1024 << " MiB";
+		else
+			s << numKBytesSent / 1024 / 1024 << " GiB";
+		s << " (" << (double) i2p::transport::transports.GetOutBandwidth () / 1024 << " KiB/s)<br>\r\n";
 		s << "<b>Data path:</b> " << i2p::fs::GetDataDir() << "<br>\r\n<br>\r\n";
 		s << "<b>Our external address:</b>" << "<br>\r\n" ;
 		for (auto address : i2p::context.GetRouterInfo().GetAddresses())
@@ -510,8 +525,8 @@ namespace util
 		s << "<input type=\"hidden\" name=\"jumpservices\">";
 		s << "<input type=\"text\" value=\"" << address << "\" name=\"address\"> </form><br>\r\n";
 		s << "<b>Jump services for " << address << "</b>";
-		s << "<ul><li><a href=\"http://inr.i2p/search/?q=" << address << "\">inr.i2p jump service</a> <br>\r\n";
+		s << "<ul><li><a href=\"http://joajgazyztfssty4w2on5oaqksz6tqoxbduy553y34mf4byv6gpq.b32.i2p/search/?q=" << address << "\">inr.i2p jump service</a> <br>\r\n";
-		s << "<li><a href=\"http://stats.i2p/cgi-bin/jump.cgi?a=" << address << "\">stats.i2p jump service</a></ul>";
+		s << "<li><a href=\"http://7tbay5p4kzeekxvyvbf6v7eauazemsnnl2aoyqhg5jzpr5eke7tq.b32.i2p/cgi-bin/jump.cgi?a=" << address << "\">stats.i2p jump service</a></ul>";
     }
 
 	void HTTPConnection::ShowLocalDestinations (std::stringstream& s)

Log.cpp

@@ -1,86 +1,167 @@
-#include <boost/date_time/posix_time/posix_time.hpp>
+/*
+* Copyright (c) 2013-2016, The PurpleI2P Project
+*
+* This file is part of Purple i2pd project and licensed under BSD3
+*
+* See full license text in LICENSE file at top of project tree
+*/
+
 #include "Log.h"
 
-Log * g_Log = nullptr;
+namespace i2p {
-
+namespace log {
+	Log logger;
+	/**
+	 * @enum Maps our loglevel to their symbolic name
+	 */
 	static const char * g_LogLevelStr[eNumLogLevels] =
 	{
 		"error", // eLogError
-	"warn",  // eLogWarning
+		"warn",  // eLogWarn
 		"info",  // eLogInfo
 		"debug"	 // eLogDebug
 	};
 
-void LogMsg::Process()
+#ifndef _WIN32
-{
+	/**
-	auto stream = log ? log->GetLogStream () : nullptr;
+	 * @brief  Maps our log levels to syslog one
-	auto& output = stream ? *stream : std::cout;	
+	 * @return syslog priority LOG_*, as defined in syslog.h
-	if (log)	
+	 */
-		output << log->GetTimestamp ();
+	static inline int GetSyslogPrio (enum LogLevel l) {
-	else
+		int priority = LOG_DEBUG;
-		output << boost::posix_time::second_clock::local_time().time_of_day ();
+		switch (l) {
-	output << "/" << g_LogLevelStr[level] << " - ";
+			case eLogError   : priority = LOG_ERR;     break;
-	output << s.str();
+			case eLogWarning : priority = LOG_WARNING; break;
+			case eLogInfo    : priority = LOG_INFO;    break;
+			case eLogDebug   : priority = LOG_DEBUG;   break;
+			default          : priority = LOG_DEBUG;   break;
+		}
+		return priority;
 	}
-
-const std::string& Log::GetTimestamp ()
-{
-#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__)	
-	auto ts = std::chrono::monotonic_clock::now ();	
-#else	
-	auto ts = std::chrono::steady_clock::now ();	
 #endif
-	if (ts > m_LastTimestampUpdate + std::chrono::milliseconds (500)) // 0.5 second
+
+	Log::Log():
+	m_Destination(eLogStdout), m_MinLevel(eLogInfo),
+	m_LogStream (nullptr), m_Logfile(""), m_IsReady(false)
 	{
-		m_LastTimestampUpdate = ts;
-		m_Timestamp = boost::posix_time::to_simple_string (boost::posix_time::second_clock::local_time().time_of_day ());
-	}		
-	return m_Timestamp;
 	}
 
-void Log::Flush ()
+	Log::~Log ()
 	{
-	if (m_LogStream)
+		switch (m_Destination) {
+#ifndef _WIN32
+			case eLogSyslog :
+				closelog();
+				break;
+#endif
+			case eLogFile:
+			case eLogStream:
 				m_LogStream->flush();
+				break;
+			default:
+				/* do nothing */
+				break;
+		}
+		Process();
 	}
 
-void Log::SetLogFile (const std::string& fullFilePath, bool truncate)
+	void Log::SetLogLevel (const std::string& level) {
-{
-	m_FullFilePath = fullFilePath;	
-	auto mode = std::ofstream::out | std::ofstream::binary;
-	mode |= truncate ? std::ofstream::trunc : std::ofstream::app;
-	auto logFile = std::make_shared<std::ofstream> (fullFilePath, mode);
-	if (logFile->is_open ())
-	{
-		SetLogStream (logFile);
-		LogPrint(eLogInfo, "Log: will send messages to ",  fullFilePath);
-	}	
-}
-
-void Log::ReopenLogFile ()
-{
-	if (m_FullFilePath.length () > 0)
-	{
-		SetLogFile (m_FullFilePath, false); // don't truncate
-		LogPrint(eLogInfo, "Log: file ", m_FullFilePath,  " reopen");
-	}
-}
-
-
-void Log::SetLogLevel (const std::string& level)
-{
 		if      (level == "error") { m_MinLevel = eLogError; }
 		else if (level == "warn")  { m_MinLevel = eLogWarning; }
 		else if (level == "info")  { m_MinLevel = eLogInfo;  }
 		else if (level == "debug") { m_MinLevel = eLogDebug; }
 		else {
-		LogPrint(eLogError, "Log: Unknown loglevel: ", level);
+			LogPrint(eLogError, "Log: unknown loglevel: ", level);
 			return;
 		}
-  LogPrint(eLogInfo, "Log: min msg level set to ", level);
+		LogPrint(eLogInfo, "Log: min messages level set to ", level);
 	}
 	
-void Log::SetLogStream (std::shared_ptr<std::ostream> logStream)
+	const char * Log::TimeAsString(std::time_t t) {
-{
+		if (t != m_LastTimestamp) {
-	m_LogStream = logStream;
+			strftime(m_LastDateTime, sizeof(m_LastDateTime), "%H:%M:%S", localtime(&t));
+			m_LastTimestamp = t;
 		}
+		return m_LastDateTime;
+	}
+
+	/**
+	 * @note This function better to be run in separate thread due to disk i/o.
+	 * Unfortunately, with current startup process with late fork() this
+	 * will give us nothing but pain. Maybe later. See in NetDb as example.
+	 */
+	void Log::Process() {
+		std::unique_lock<std::mutex> l(m_OutputLock);
+		std::hash<std::thread::id> hasher;
+		unsigned short short_tid;
+		while (1) {
+			auto msg = m_Queue.GetNextWithTimeout (1);
+			if (!msg)
+				break;
+			short_tid = (short) (hasher(msg->tid) % 1000);
+			switch (m_Destination) {
+#ifndef _WIN32
+				case eLogSyslog:
+					syslog(GetSyslogPrio(msg->level), "[%03u] %s", short_tid, msg->text.c_str());
+					break;
+#endif
+				case eLogFile:
+				case eLogStream:
+					*m_LogStream << TimeAsString(msg->timestamp)
+						<< "@" << short_tid
+						<< "/" << g_LogLevelStr[msg->level]
+						<< " - " << msg->text << std::endl;
+					break;
+				case eLogStdout:
+				default:
+					std::cout    << TimeAsString(msg->timestamp)
+						<< "@" << short_tid
+						<< "/" << g_LogLevelStr[msg->level]
+						<< " - " << msg->text << std::endl;
+					break;
+			} // switch
+		} // while
+	}
+
+	void Log::Append(std::shared_ptr<i2p::log::LogMsg> & msg) {
+		m_Queue.Put(msg);
+		if (!m_IsReady)
+			return;
+		Process();
+	}
+
+	void Log::SendTo (const std::string& path) {
+		auto flags = std::ofstream::out | std::ofstream::app;
+		auto os = std::make_shared<std::ofstream> (path, flags);
+		if (os->is_open ()) {
+			m_Logfile = path;
+			m_Destination = eLogFile;
+			m_LogStream = os;
+			return;
+		}
+		LogPrint(eLogError, "Log: can't open file ", path);
+	}
+
+	void Log::SendTo (std::shared_ptr<std::ostream> os) {
+		m_Destination = eLogStream;
+		m_LogStream = os;
+	}
+
+#ifndef _WIN32
+	void Log::SendTo(const char *name, int facility) {
+		m_Destination = eLogSyslog;
+		m_LogStream = nullptr;
+		openlog(name, LOG_CONS | LOG_PID, facility);
+	}
+#endif
+
+	void Log::Reopen() {
+		if (m_Destination == eLogFile)
+			SendTo(m_Logfile);
+	}
+
+	Log & Logger() {
+		return logger;
+	}
+} // log
+} // i2p

Log.h

@@ -1,15 +1,27 @@
+/*
+* Copyright (c) 2013-2016, The PurpleI2P Project
+*
+* This file is part of Purple i2pd project and licensed under BSD3
+*
+* See full license text in LICENSE file at top of project tree
+*/
+
 #ifndef LOG_H__
 #define LOG_H__
 
+#include <ctime>
 #include <string>
 #include <iostream>
-#include <sstream>
 #include <fstream>
-#include <functional>
+#include <sstream>
 #include <chrono>
 #include <memory>
 #include "Queue.h"
 
+#ifndef _WIN32
+#include <syslog.h>
+#endif
+
 enum LogLevel
 {
 	eLogError = 0,
@@ -19,109 +31,130 @@ enum LogLevel
 	eNumLogLevels
 };
 
-class Log;
+enum LogType {
-struct LogMsg
+	eLogStdout = 0,
-{
+	eLogStream,
-	std::stringstream s;
+	eLogFile,
-	Log * log;	
+#ifndef _WIN32
-	LogLevel level;
+	eLogSyslog,
-
-	LogMsg (Log * l = nullptr, LogLevel lv = eLogInfo): log (l), level (lv) {};
-	
-	void Process();
-};
-
-class Log: public i2p::util::MsgQueue<LogMsg>
-{
-	public:
-
-		Log () { SetOnEmpty (std::bind (&Log::Flush, this)); };
-		~Log () {};
-
-		void SetLogFile (const std::string& fullFilePath, bool truncate = true);
-		void ReopenLogFile ();
-		void SetLogLevel (const std::string& level);
-		void SetLogStream (std::shared_ptr<std::ostream> logStream);
-		std::shared_ptr<std::ostream> GetLogStream () const { return m_LogStream; };	
-		const std::string& GetTimestamp ();
-		LogLevel GetLogLevel () { return m_MinLevel; };
-		const std::string& GetFullFilePath () const { return m_FullFilePath; };
-
-	private:
-
-		void Flush ();
-
-	private:
-		
-		std::string m_FullFilePath; // empty if stream
-		std::shared_ptr<std::ostream> m_LogStream;
-		enum LogLevel m_MinLevel;
-		std::string m_Timestamp;
-#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__) // gcc 4.6
-		std::chrono::monotonic_clock::time_point m_LastTimestampUpdate;
-#else		
-		std::chrono::steady_clock::time_point m_LastTimestampUpdate;	
 #endif
 };
 
-extern Log * g_Log;
+namespace i2p {
+namespace log {
+	struct LogMsg; /* forward declaration */
 
-inline void StartLog (const std::string& fullFilePath)
+	class Log
 	{
-	if (!g_Log)
+		private:
-	{	
-		auto log = new Log ();
-		if (fullFilePath.length () > 0)
-			log->SetLogFile (fullFilePath);
-		g_Log = log;
-	}	
-}
 
-inline void StartLog (std::shared_ptr<std::ostream> s)
+			enum LogType  m_Destination;
-{
+			enum LogLevel m_MinLevel;
-	if (!g_Log)
+			std::shared_ptr<std::ostream> m_LogStream;
-	{	
+			std::string m_Logfile;
-		auto log = new Log ();
+			std::time_t m_LastTimestamp;
-		if (s)
+			char m_LastDateTime[64];
-			log->SetLogStream (s);
+			i2p::util::Queue<std::shared_ptr<LogMsg> > m_Queue;
-		g_Log = log;
+			volatile bool m_IsReady;
-	}	
+			mutable std::mutex m_OutputLock;
-}
 
-inline void StopLog ()
+		private:
-{
-	if (g_Log)
-	{
-		auto log = g_Log;
-		g_Log = nullptr;
-		log->Stop ();
-		delete log;
-	}		
-}
 
-inline void SetLogLevel (const std::string& level)
+			/** prevent making copies */
-{
+			Log (const Log &);
-	if (g_Log)	
+			const Log& operator=(const Log&);
-		g_Log->SetLogLevel(level);
-}
 
-inline void ReopenLogFile ()
+			/**
-{
+			 * @brief process stored messages in queue
-	if (g_Log)	
+			 */
-		g_Log->ReopenLogFile ();
+			void Process ();
-}
 
-inline bool IsLogToFile ()
+			/**
-{
+			 * @brief Makes formatted string from unix timestamp
-	return g_Log ? !g_Log->GetFullFilePath ().empty () : false;
+			 * @param ts  Second since epoch
-}	
+			 *
+			 * This function internally caches the result for last provided value
+			 */
+			const char * TimeAsString(std::time_t ts);
 
+		public:
+
+			Log ();
+			~Log ();
+
+			LogType  GetLogType  () { return m_Destination; };
+			LogLevel GetLogLevel () { return m_MinLevel; };
+
+			/**
+			 * @brief  Sets minimal alloed level for log messages
+			 * @param  level  String with wanted minimal msg level
+			 */
+			void     SetLogLevel (const std::string& level);
+
+			/**
+			 * @brief Sets log destination to logfile
+			 * @param path  Path to logfile
+			 */
+			void SendTo (const std::string &path);
+
+			/**
+			 * @brief Sets log destination to given output stream
+			 * @param os  Output stream
+			 */
+			void SendTo (std::shared_ptr<std::ostream> s);
+
+	#ifndef _WIN32
+			/**
+			 * @brief Sets log destination to syslog
+			 * @param name     Wanted program name
+			 * @param facility Wanted log category
+			 */
+			void SendTo (const char *name, int facility);
+	#endif
+
+			/**
+			 * @brief  Format log message and write to output stream/syslog
+			 * @param  msg  Pointer to processed message
+			 */
+			void Append(std::shared_ptr<i2p::log::LogMsg> &);
+
+			/** @brief  Allow log output */
+			void Ready() { m_IsReady = true; }
+
+			/** @brief  Flushes the output log stream */
+			void Flush();
+
+			/** @brief  Reopen log file */
+			void Reopen();
+	};
+
+	/**
+	 * @struct Log message container
+	 *
+	 * We creating it somewhere with LogPrint(),
+	 * then put in MsgQueue for later processing.
+	 */
+	struct LogMsg {
+		std::time_t timestamp;
+		std::string text; /**< message text as single string */
+		LogLevel level;   /**< message level */
+		std::thread::id tid; /**< id of thread that generated message */
+
+		LogMsg (LogLevel lvl, std::time_t ts, const std::string & txt): timestamp(ts), text(txt), level(lvl) {};
+	};
+
+	Log & Logger();
+} // log
+} // i2p
+
+/** internal usage only -- folding args array to single string */
 template<typename TValue>
 void LogPrint (std::stringstream& s, TValue arg)
 {
 	s << arg;
 }
 
+/** internal usage only -- folding args array to single string */
 template<typename TValue, typename... TArgs>
 void LogPrint (std::stringstream& s, TValue arg, TArgs... args)
 {
@@ -129,20 +162,25 @@ void LogPrint (std::stringstream& s, TValue arg, TArgs... args)
 	LogPrint (s, args...);
 }
 
+/**
+ * @brief Create log message and send it to queue
+ * @param level Message level (eLogError, eLogInfo, ...)
+ * @param args Array of message parts
+ */
 template<typename... TArgs>
 void LogPrint (LogLevel level, TArgs... args)
 {
-	if (g_Log && level > g_Log->GetLogLevel ())
+	i2p::log::Log &log = i2p::log::Logger();
+	if (level > log.GetLogLevel ())
 		return;
-	LogMsg * msg = new LogMsg (g_Log, level);
+
-	LogPrint (msg->s, args...);
+	// fold message to single string
-	msg->s << std::endl;
+	std::stringstream ss("");
-	if (g_Log) {
+	LogPrint (ss, args ...);
-		g_Log->Put (msg);
+
-	} else {
+	auto msg = std::make_shared<i2p::log::LogMsg>(level, std::time(nullptr), ss.str());
-		msg->Process ();
+	msg->tid = std::this_thread::get_id();
-		delete msg;
+	log.Append(msg);
-	}
 }
 
-#endif
+#endif // LOG_H__

Makefile

@@ -77,7 +77,7 @@ clean:
 strip: $(I2PD) $(SHLIB_CLIENT) $(SHLIB)
 	strip $^
 
-LATEST_TAG=$(shell git describe --tags --abbrev=0 master)
+LATEST_TAG=$(shell git describe --tags --abbrev=0 openssl)
 dist:
 	git archive --format=tar.gz -9 --worktree-attributes \
 	    --prefix=i2pd_$(LATEST_TAG)/ $(LATEST_TAG) -o i2pd_$(LATEST_TAG).tar.gz

Makefile.mingw

@@ -41,4 +41,3 @@ endif
 
 obj/%.o : %.rc
 	$(WINDRES) -i $< -o $@
-

Queue.h

@@ -117,52 +117,6 @@ namespace util
 			std::mutex m_QueueMutex;
 			std::condition_variable m_NonEmpty;
 	};	
-
-	template<class Msg>
-	class MsgQueue: public Queue<Msg *>
-	{
-		public:
-
-			typedef std::function<void()> OnEmpty;
-
-			MsgQueue (): m_IsRunning (true), m_Thread (std::bind (&MsgQueue<Msg>::Run, this))  {};
-			~MsgQueue () { Stop (); };
-			void Stop()
-			{
-				if (m_IsRunning)
-				{
-					m_IsRunning = false;
-					Queue<Msg *>::WakeUp ();					
-					m_Thread.join();
-				}
-			}
-
-			void SetOnEmpty (OnEmpty const & e) { m_OnEmpty = e; };
-
-		private:
-
-			void Run ()
-			{
-				while (m_IsRunning)
-				{
-					while (auto msg = Queue<Msg *>::Get ())
-					{
-						msg->Process ();
-						delete msg;
-					}
-					if (m_OnEmpty != nullptr)
-						m_OnEmpty ();
-					if (m_IsRunning)
-						Queue<Msg *>::Wait ();
-				}	
-			}	
-			
-		private:
-			
-			volatile bool m_IsRunning;
-			OnEmpty m_OnEmpty;
-			std::thread m_Thread;	
-	};	
 }		
 }	
 

Streaming.cpp

@@ -162,7 +162,8 @@ namespace stream
 
 	void Stream::SavePacket (Packet * packet)
 	{
-		m_SavedPackets.insert (packet);
+		if (!m_SavedPackets.insert (packet).second)
+			delete packet;
 	}	
 
 	void Stream::ProcessPacket (Packet * packet)

api.cpp

@@ -40,9 +40,10 @@ namespace api
 	void StartI2P (std::shared_ptr<std::ostream> logStream)
 	{
 		if (logStream)
-			StartLog (logStream);
+			i2p::log::Logger().SendTo (logStream);
 		else
-			StartLog (i2p::fs::DataDirPath (i2p::fs::GetAppName () + ".log"));
+			i2p::log::Logger().SendTo (i2p::fs::DataDirPath (i2p::fs::GetAppName () + ".log"));
+		i2p::log::Logger().Ready();
 		LogPrint(eLogInfo, "API: starting NetDB");
 		i2p::data::netdb.Start();
 		LogPrint(eLogInfo, "API: starting Transports");
@@ -60,7 +61,6 @@ namespace api
 		i2p::transport::transports.Stop();
 		LogPrint(eLogInfo, "API: stopping NetDB");
 		i2p::data::netdb.Stop();
-		StopLog ();
 	}
 
 	void RunPeerTest ()

contrib/certificates/family/mca2-i2p.crt

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBwTCCAWigAwIBAgIJAOZBC10+/38EMAkGByqGSM49BAEwZzELMAkGA1UEBhMC
+QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
+dHMgUHR5IEx0ZDEgMB4GA1UEAwwXbWNhMi1pMnAuZmFtaWx5LmkycC5uZXQwHhcN
+MTYwMzI4MjIwMjMxWhcNMjYwMzI2MjIwMjMxWjBnMQswCQYDVQQGEwJBVTETMBEG
+A1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkg
+THRkMSAwHgYDVQQDDBdtY2EyLWkycC5mYW1pbHkuaTJwLm5ldDBZMBMGByqGSM49
+AgEGCCqGSM49AwEHA0IABNNyfzJr/rMSUeWliVBbJHRF2+qMypOlHEZ9m1nNATVX
+64OhuyuVCmbF9R3oDkcZZJQQK1ovXd/EsbAIWDI8K/gwCQYHKoZIzj0EAQNIADBF
+AiEApmv2tvMwzlvPjHJG1/5aXOSjYWw2s4ETeGt4abWPQkACIBbF3RuCHuzg+KN8
+N0n9hAJztAqhRCdG3hilxF4fbVLp
+-----END CERTIFICATE-----

debian/control

@@ -3,7 +3,7 @@ Section: net
 Priority: extra
 Maintainer: hagen <hagen@i2pmail.org>
 Build-Depends: debhelper (>= 9.0.0), dpkg-dev (>= 1.16.1~),
- gcc (>= 4.6) | clang (>= 3.3),
+ gcc (>= 4.7) | clang (>= 3.3),
  libboost-regex-dev,
  libboost-system-dev (>= 1.46),
  libboost-date-time-dev,

debian/i2pd.1

@@ -68,7 +68,7 @@ Port of BOB command channel. Usually \fI2827\fR. BOB will not be enabled if this
 Port of I2P control service. Usually \fI7650\fR. I2PControl will not be enabled if this is not set. (default: unset)
 .TP
 \fB\-\-conf=\fR
-Config file (default: \fI~/.i2pd/i2p.conf\fR or \fI/var/lib/i2pd/i2p.conf\fR)
+Config file (default: \fI~/.i2pd/i2pd.conf\fR or \fI/var/lib/i2pd/i2pd.conf\fR)
 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.
 

debian/i2pd.links

@@ -1,4 +1,4 @@
-etc/i2pd/i2pd.conf    var/lib/i2pd/i2p.conf
+etc/i2pd/i2pd.conf    var/lib/i2pd/i2pd.conf
-etc/i2pd/tunnels.conf var/lib/i2pd/tunnels.cfg
+etc/i2pd/tunnels.conf var/lib/i2pd/tunnels.conf
 etc/i2pd/subscriptions.txt var/lib/i2pd/subscriptions.txt
 usr/share/i2pd/certificates var/lib/i2pd/certificates

docs/build_requirements.md

@@ -4,7 +4,7 @@ Build requirements
 Linux/FreeBSD/OSX
 -----------------
 
-GCC 4.8 or newer, Boost 1.49 or newer, openssl, zlib. Clang can be used instead of GCC.
+GCC 4.7 or newer, Boost 1.49 or newer, openssl, zlib. Clang can be used instead of GCC.
 
 Windows
 -------

docs/configuration.md

@@ -4,10 +4,13 @@ i2pd configuration
 Command line options
 --------------------
 
-* --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.
-* --tunconf=            - Tunnels config file (default: ~/.i2pd/tunnels.cfg or /var/lib/i2pd/tunnels.cfg)
+If you are upgrading your very old router (< 2.3.0) see also [this](config_opts_after_2.3.0.md) page.
+
+* --help                - Show builtin help message (default value of option will be shown in braces)
+* --conf=               - Config file (default: ~/.i2pd/i2pd.conf or /var/lib/i2pd/i2pd.conf)
+                          This parameter will be silently ignored if the specified config file does not exist.
+* --tunconf=            - Tunnels config file (default: ~/.i2pd/tunnels.conf or /var/lib/i2pd/tunnels.conf)
 * --pidfile=            - Where to write pidfile (dont write by default)
 * --log=                - Logs destination: stdout, file (stdout if not set, file - otherwise, for compatibility)
 * --logfile=            - Path to logfile (default - autodetect)
@@ -24,6 +27,8 @@ Command line options
 * --family=             - Name of a family, router belongs to
 * --svcctl=             - Windows service management (--svcctl="install" or --svcctl="remove")
 
+All options below still possible in cmdline, but better write it in config file:
+
 * --http.address=       - The address to listen on (HTTP server)
 * --http.port=          - The port to listen on (HTTP server)
 
@@ -60,7 +65,7 @@ All command-line parameters are allowed as keys, but note for those which contai
 
 For example:
 
-i2p.conf:
+i2pd.conf:
 
     # comment
     log = true
@@ -69,11 +74,13 @@ i2p.conf:
     [httpproxy]
     port = 4444
     # ^^ this will be --httproxy.port= in cmdline
-    # another one
+    # another comment
     [sam]
     enabled = true
 
-tunnels.cfg (filename of this config is subject of change):
+See also commented config with examples of all options in ``docs/i2pd.conf``.
+
+tunnels.conf:
 
     # outgoing tunnel sample, to remote service
     # mandatory parameters:
@@ -107,6 +114,7 @@ tunnels.cfg (filename of this config is subject of change):
     host = 127.0.0.1
     port = 80
     keys = site-keys.dat
+    #
     [IRC-SERVER]
     type = server
     host = 127.0.0.1

docs/family.md

@@ -6,27 +6,31 @@ There are two possibilities: create new family or joing to existing.
 
 New family
 -----------
+
 You must create family self-signed certificate and key.  
 The only key type supposted is prime256v1.
 Use the following list of commands:  
+
     openssl ecparam -name prime256v1 -genkey -out <your family name>.key  
     openssl req -new -key <your family name>.key -out <your family name>.csr  
     touch v3.ext
     openssl x509 -req -days 3650 -in <your family name>.csr -signkey <your family name>.key -out <your family name>.crt -extfile v3.ext  
 
-specify <your family name>.family.i2p.net for CN.
+Specify <your family name>.family.i2p.net for CN (Common Name) when requested.
 
-Once you are done with it place <your family name>.key and <your family name>.crt to <ip2d data>/family folder (for exmple ~/.i2pd/family).
+Once you are done with it place <your-family-name>.key and <your-family-name>.crt to <ip2d data>/family folder (for exmple ~/.i2pd/family).
 You should provide these two files to other members joining your family.
 If you want to register you family and let I2P network recorgnize it, create pull request for you .crt file into contrib/certificate/family.
-It will appear in i2pd and I2P next releases packages. Don't place .key file, it must be shared betwwen you family members only.
+It will appear in i2pd and I2P next releases packages. Dont place .key file, it must be shared between you family members only.
 
-Join existing family
+How to join existing family
---------------------
+---------------------------
-Once you and that family agree to do it, they must give you .key and .crt file and you must place to <ip2d data>/family folder.
+
+Once you and that family agree to do it, they must give you .key and .crt file and you must place in <i2pd datadir>/certificates/family/ folder.
 
 Publish your family
-------------------
+-------------------
-Run i2pd with parameter 'family=<your family name>', make sure you have <your family name>.key and <your family name>.crt in your 'family' folder.
-If everything is set properly, you router.info will contain two new fields: 'family' and 'family.sig'.
 
+Run i2pd with parameter 'family=<your-family-name>', make sure you have <your-family-name>.key and <your-family-name>.crt in your 'family' folder.
+If everything is set properly, you router.info will contain two new fields: 'family' and 'family.sig'.
+Otherwise your router will complain on startup with log messages starting with "Family:" prefix and severity 'warn' or 'error'.

docs/i2pd.conf

@@ -7,16 +7,19 @@
 ## by removing the "#" symbol.
 
 ## Tunnels config file
-## Default: ~/.i2pd/tunnels.cfg or /var/lib/i2pd/tunnels.cfg
+## Default: ~/.i2pd/tunnels.conf or /var/lib/i2pd/tunnels.conf
-#tunconf = /var/lib/i2pd/tunnels.cfg
+# tunconf = /var/lib/i2pd/tunnels.conf
 
 ## Where to write pidfile (don't write by default)
 # pidfile = /var/run/i2pd.pid
 
 ## Logging configuration section
-## By default logs go to stdout with level info
+## By default logs go to stdout with level 'info' and higher
 ##
-## Logs destination (stdout, file) 
+## Logs destination (valid values: stdout, file, syslog)
+##  * stdout - print log entries to stdout
+##  * file - log entries to a file
+##  * syslog - use syslog, see man 3 syslog
 # log = file
 ## Path to logfile (default - autodetect)
 # logfile = /var/log/i2pd.log
@@ -28,84 +31,79 @@
 # datadir = /var/lib/i2pd
 
 ## Daemon mode. Router will go to background after start
-#daemon 
+# daemon = true
 ## Run as a service. Router will use system folders like ‘/var/lib/i2pd’
-#service
+# service = true
 
 ## External IP address to listen for connections
 ## By default i2pd sets IP automatically
 # host = 1.2.3.4
+
 ## Port to listen for connections
 ## By default i2pd picks random port. You MUST pick a random number too,
 ## don't just uncomment this
 # port = 4321
+
 ## Enable communication through ipv6
-ipv6 
+ipv6 = true
+
 ## Bandwidth configuration
 ## L limit bandwidth to 32Kbs/sec, O - to 256Kbs/sec, P - unlimited
 ## Default is P for floodfill, L for regular node
 # bandwidth = L
 
 ## Router will not accept transit tunnels at startup
-#notransit 
+# notransit = true
 
 ## Router will be floodfill
-#floodfill
+# floodfill = true
 
-## Section for Web Console
-## By default it's available at 127.0.0.1:7070 even if it's not configured
 [http]
-## The address to listen on
+## Uncomment and set to 'false' to disable Web Console
+# enabled = true
+## Address and port service will listen on
 address = 127.0.0.1
-## The port to listen on
 port = 7070
 
-## Section for HTTP proxy
-## By default it's available at 127.0.0.1:4444 even if it's not configured
 [httpproxy]
-## The address to listen on
+## Uncomment and set to 'false' to disable HTTP Proxy
-address = 127.0.0.1 
+# enabled = true
-## The port to listen on
+## Address and port service will listen on
-port = 4444 
+# address = 127.0.0.1
+# port = 4444
 ## Optional keys file for proxy local destination
 # keys = http-proxy-keys.dat
-## Uncomment if you want to disable HTTP proxy
-#enabled=false
 
-## Section for Socks proxy
+[socksproxy]
-## By default it's available at 127.0.0.1:4447 even if it's not configured
+## Uncomment and set to 'false' to disable SOCKS Proxy
-#[socksproxy]
+# enabled = true
-## The address to listen on
+## Address and port service will listen on
 # address = 127.0.0.1
-## The port to listen on
 # port = 4447
 ## Optional keys file for proxy local destination
 # keys = socks-proxy-keys.dat
-## Uncomment if you want to disable Socks proxy
-#enabled=false
 ## Socks outproxy. Example below is set to use Tor for all connections except i2p
-## Address of outproxy
+## Address and port of outproxy
 # outproxy = 127.0.0.1
-## Outproxy remote port
 # outproxyport = 9050
 
-## Section for SAM bridge
+[sam]
-#[sam]
+## Uncomment and set to 'true' to enable SAM Bridge
-## The address to listen on
+# enabled = false
+## Address and port service will listen on
 # address = 127.0.0.1
-## Port of SAM bridge
 # port = 7656
 
-## Section for BOB command channel
+[bob]
-#[bob]
+## Uncomment and set to 'true' to enable BOB command channel
-## The address to listen on
+# enabled = false
+## Address and port service will listen on
 # address = 127.0.0.1
-## Port of BOB command channel. Usually 2827. BOB is off if not specified
 # port = 2827
 
-## Section for I2PControl protocol 
+[i2pcontrol]
-#[i2pcontrol]
+## Uncomment and set to 'true' to enable I2PControl protocol
-## The address to listen on
+# enabled = false
+## Address and port service will listen on
 # address = 127.0.0.1
-## Port of I2P control service
 # port = 7650