Use binary format

daemon/i2pd.cpp

@@ -29,6 +29,8 @@ int main( int argc, char* argv[] )
 #include <ctime>
 #include <chrono>
 #include <mutex>
+#include <set>
+#include <array>
 #include <vector>
 #include <iomanip>
 
@@ -39,8 +41,9 @@ std::shared_ptr<std::thread> timeThread;
 
 namespace i2p
 {
-	extern std::mutex g_SSU2cResultsMutex;
-	extern std::vector<std::string> g_SSU2cResults;
+	extern std::mutex g_StatMutex;
+	extern std::vector<uint8_t> g_StatQueue;
+	extern std::set<std::array<uint8_t, 16> > g_StoredRIHashes;
 }
 
 void StartProfiling()
@@ -50,20 +53,19 @@ void StartProfiling()
 	{
 		std::ofstream ssu2cstatfs;
 #ifdef _WIN32
-		ssu2cstatfs.open("ssu2cstat.txt", std::ios::app);
+		ssu2cstatfs.open("ssu2cstat.bin", std::ios::app | std::ios::binary);
 #else
-		ssu2cstatfs.open("/tmp/ssu2cstat.txt", std::ios::app);
+		ssu2cstatfs.open("/tmp/ssu2cstat.bin", std::ios::app | std::ios::binary);
 #endif
 		for (;;)
 		{
 			time_t now = std::time(nullptr);
 			if (now / dumpInterval > lastRequestTime / dumpInterval)
 			{
 				lastRequestTime = now;
-				std::unique_lock<std::mutex> l(i2p::g_SSU2cResultsMutex);
-				for (size_t i = 0; i < i2p::g_SSU2cResults.size(); i++)
-					ssu2cstatfs << i2p::g_SSU2cResults[i] << std::endl;
-				i2p::g_SSU2cResults.clear();
+				std::unique_lock<std::mutex> l(i2p::g_StatMutex);
+				ssu2cstatfs.write((const char*)i2p::g_StatQueue.data(), i2p::g_StatQueue.size());
+				i2p::g_StatQueue.clear();
 				ssu2cstatfs << std::flush;
 			}
 			std::this_thread::sleep_for(std::chrono::milliseconds(250));

libi2pd/RouterInfo.cpp

@@ -60,6 +60,7 @@ namespace data
 			m_Addresses = boost::make_shared<Addresses>(); // create empty list
 			m_Buffer = buf;
 			m_BufferLen = len;
+			m_BufferBackup.assign(m_Buffer->data(), m_Buffer->data() + m_BufferLen);
 			ReadFromBuffer (true);
 		}
 		else
@@ -137,6 +138,7 @@ namespace data
 			if (!m_Buffer)
 				m_Buffer = NewBuffer ();
 			s.read((char *)m_Buffer->data (), m_BufferLen);
+			m_BufferBackup.assign(m_Buffer->data(), m_Buffer->data() + m_BufferLen);
 		}
 		else
 		{
@@ -1092,6 +1094,7 @@ namespace data
 		if (len > m_Buffer->size ()) len = m_Buffer->size ();
 		memcpy (m_Buffer->data (), buf, len);
 		m_BufferLen = len;
+		m_BufferBackup.assign(buf, buf + len);
 	}
 
 	std::shared_ptr<RouterInfo::Buffer> RouterInfo::NewBuffer () const

libi2pd/RouterInfo.h

@@ -263,6 +263,7 @@ namespace data
 			void ExcludeReachableTransports (CompatibleTransports transports) { m_ReachableTransports &= ~transports; };
 
 			const uint8_t * GetBuffer () const { return m_Buffer ? m_Buffer->data () : nullptr; };
+			const std::vector<uint8_t>& GetBufferBackup() const { return m_BufferBackup; }
 			const uint8_t * LoadBuffer (const std::string& fullPath); // load if necessary
 			size_t GetBufferLen () const { return m_BufferLen; };
 
@@ -319,6 +320,7 @@ namespace data
 			FamilyID m_FamilyID;
 			std::shared_ptr<const IdentityEx> m_RouterIdentity;
 			std::shared_ptr<Buffer> m_Buffer;
+			std::vector<uint8_t> m_BufferBackup;
 			size_t m_BufferLen;
 			uint64_t m_Timestamp; // in milliseconds
 			boost::shared_ptr<Addresses> m_Addresses; // TODO: use std::shared_ptr and std::atomic_store for gcc >= 4.9

libi2pd/SSU2Session.cpp

@@ -8,6 +8,7 @@
 
 #include <string.h>
 #include <openssl/rand.h>
+#include <openssl/md5.h>
 #include "Log.h"
 #include "Transports.h"
 #include "Gzip.h"
@@ -16,11 +17,14 @@
 
 #include <mutex>
 #include <vector>
+#include <set>
+#include <array>
 
 namespace i2p
 {
-	std::mutex g_SSU2cResultsMutex;
-	std::vector<std::string> g_SSU2cResults;
+	std::mutex g_StatMutex;
+	std::vector<uint8_t> g_StatQueue;
+	std::set<std::array<uint8_t, 16> > g_StoredRIHashes;
 
 namespace transport
 {
@@ -101,6 +105,7 @@ namespace transport
 		if (in_RemoteRouter && m_Address)
 		{
 			// outgoing
+			m_RIBuffer = in_RemoteRouter->GetBufferBackup();
 			InitNoiseXKState1 (*m_NoiseState, m_Address->s);
 			m_RemoteEndpoint = boost::asio::ip::udp::endpoint (m_Address->host, m_Address->port);
 			m_RemoteTransports = in_RemoteRouter->GetCompatibleTransports (false);
@@ -118,22 +123,41 @@ namespace transport
 	{
 	}
 
-	void SSU2Session::LogResult(char result, int state)
+	void SSU2Session::LogResult(char result, uint8_t state)
 	{
-		std::stringstream ss;
-		time_t now = std::time(nullptr);
-		ss << "[" << std::put_time(std::gmtime(&now), "%Y.%m.%d %H:%M:%S") << "]: ";
-		ss << (IsOutgoing() ? 'O' : 'I') << ' ';
-		ss << result;
-		if (result != 'E')
-			ss << state;
-		ss << ' ';
-		int durationMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+		std::stringstream ssres;
+		uint64_t ts = std::chrono::duration_cast<std::chrono::milliseconds>(
+			std::chrono::system_clock::now().time_since_epoch()).count();
+		uint16_t durationMs = std::chrono::duration_cast<std::chrono::milliseconds>(
 			std::chrono::high_resolution_clock::now() - m_CreationTimeHR).count();
-		ss << durationMs << " ";
-		ss << GetRemoteIdentity()->GetIdentHash().ToBase64();
-		std::unique_lock<std::mutex> l(i2p::g_SSU2cResultsMutex);
-		g_SSU2cResults.push_back(ss.str());
+		uint8_t isOutgoing = IsOutgoing();
+		std::array<uint8_t, 16> riHash;
+		MD5(m_RIBuffer.data(), m_RIBuffer.size(), riHash.data());
+
+		ssres.put(1);
+		ssres.write((const char*)&ts, 8);
+		ssres.put(isOutgoing);
+		ssres.put(result);
+		ssres.put(state);
+		ssres.write((const char*)&durationMs, 2);
+		ssres.write((const char*)riHash.data(), 16);
+
+		std::unique_lock<std::mutex> l(i2p::g_StatMutex);
+
+		if (i2p::g_StoredRIHashes.find(riHash) == i2p::g_StoredRIHashes.end())
+		{
+			uint16_t riSize = m_RIBuffer.size();
+			i2p::g_StoredRIHashes.insert(riHash);
+			std::stringstream ssri;
+			ssri.put(0);
+			ssri.write((const char*)&riSize, 2);
+			ssri.write((const char*)m_RIBuffer.data(), m_RIBuffer.size());
+			const std::string& ssris = ssri.str();
+			i2p::g_StatQueue.insert(i2p::g_StatQueue.end(), ssris.begin(), ssris.end());
+		}
+
+		const std::string& ssress = ssres.str();
+		i2p::g_StatQueue.insert(i2p::g_StatQueue.end(), ssress.begin(), ssress.end());
 	}
 
 	void SSU2Session::Connect ()
@@ -1110,6 +1134,7 @@ namespace transport
 			return false;
 		}
 		// update RouterInfo in netdb
+		m_RIBuffer = ri->GetBufferBackup();
 		ri = i2p::data::netdb.AddRouterInfo (ri->GetBuffer (), ri->GetBufferLen ()); // ri points to one from netdb now
 		if (!ri)
 		{
@@ -1548,7 +1573,10 @@ namespace transport
 					LogPrint (eLogDebug, "SSU2: RouterInfo");
 					auto ri = ExtractRouterInfo (buf + offset, size);
 					if (ri)
+					{
 						i2p::data::netdb.AddRouterInfo (ri->GetBuffer (), ri->GetBufferLen ());	// TODO: add ri
+						m_RIBuffer = ri->GetBufferBackup();
+					}
 					break;
 				}
 				case eSSU2BlkI2NPMessage:

libi2pd/SSU2Session.h

@@ -243,7 +243,7 @@ namespace transport
 			void SetOnEstablished (OnEstablished e) { m_OnEstablished = e; };
 			OnEstablished GetOnEstablished () const { return m_OnEstablished; };
 
-			void LogResult(char result, int state);
+			void LogResult(char result, uint8_t state);
 			void Connect ();
 			bool Introduce (std::shared_ptr<SSU2Session> session, uint32_t relayTag);
 			void WaitForIntroduction ();
@@ -334,11 +334,11 @@ namespace transport
 			size_t CreatePeerTestBlock (uint8_t * buf, size_t len, uint32_t nonce); // Alice
 			size_t CreateTerminationBlock (uint8_t * buf, size_t len);
 
-		public:
-			std::chrono::high_resolution_clock::time_point m_CreationTimeHR;
-
 		private:
 			bool m_Connecting;
+			std::chrono::high_resolution_clock::time_point m_CreationTimeHR;
+			std::vector<uint8_t> m_RIBuffer;
+
 			SSU2Server& m_Server;
 			std::shared_ptr<i2p::crypto::X25519Keys> m_EphemeralKeys;
 			std::unique_ptr<i2p::crypto::NoiseSymmetricState> m_NoiseState;