Merge 6e639f0e6a into 3d19fa12f6

libi2pd/Family.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2025, The PurpleI2P Project
+* Copyright (c) 2013-2024, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -90,10 +90,10 @@ namespace data
 	}
 
 	bool Families::VerifyFamily (const std::string& family, const IdentHash& ident,
-		std::string_view signature, const char * key) const
+		const char * signature, const char * key) const
 	{
 		uint8_t buf[100], signatureBuf[64];
-		size_t len = family.length ();
+		size_t len = family.length (), signatureLen = strlen (signature);
 		if (len + 32 > 100)
 		{
 			LogPrint (eLogError, "Family: ", family, " is too long");
@@ -105,7 +105,7 @@ namespace data
 			memcpy (buf, family.c_str (), len);
 			memcpy (buf + len, (const uint8_t *)ident, 32);
 			len += 32;
-			auto signatureBufLen = Base64ToByteStream (signature.data (), signature.length (), signatureBuf, 64);
+			auto signatureBufLen = Base64ToByteStream (signature, signatureLen, signatureBuf, 64);
 			if (signatureBufLen)
 			{
 				EVP_MD_CTX * ctx = EVP_MD_CTX_create ();

libi2pd/Family.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2025, The PurpleI2P Project
+* Copyright (c) 2013-2024, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -11,7 +11,6 @@
 
 #include <map>
 #include <string>
-#include <string_view>
 #include <memory>
 #include <openssl/evp.h>
 #include "Identity.h"
@@ -29,7 +28,7 @@ namespace data
 			~Families ();
 			void LoadCertificates ();
 			bool VerifyFamily (const std::string& family, const IdentHash& ident,
-				std::string_view signature, const char * key = nullptr) const;
+				const char * signature, const char * key = nullptr) const;
 			FamilyID GetFamilyID (const std::string& family) const;
 
 		private:

libi2pd/RouterContext.cpp

@@ -675,12 +675,12 @@ namespace i2p
 
 	void RouterContext::SetBandwidth (int limit)
 	{
-		if      (limit > (int)i2p::data::EXTRA_BANDWIDTH_LIMIT) { SetBandwidth('X'); }
+		if      (limit > 2000) { SetBandwidth('X'); }
-		else if (limit > (int)i2p::data::HIGH_BANDWIDTH_LIMIT) { SetBandwidth('P'); }
+		else if (limit >  256) { SetBandwidth('P'); }
-		else if (limit > 128) { SetBandwidth('O'); }
+		else if (limit >  128) { SetBandwidth('O'); }
-		else if (limit > 64) { SetBandwidth('N'); }
+		else if (limit >   64) { SetBandwidth('N'); }
-		else if (limit > (int)i2p::data::LOW_BANDWIDTH_LIMIT) { SetBandwidth('M'); }
+		else if (limit >   48) { SetBandwidth('M'); }
-		else if (limit > 12) { SetBandwidth('L'); }
+		else if (limit >   12) { SetBandwidth('L'); }
 		else                   { SetBandwidth('K'); }
 		m_BandwidthLimit = limit; // set precise limit
 	}

libi2pd/RouterInfo.cpp

@@ -11,7 +11,7 @@
 #include "I2PEndian.h"
 #include <fstream>
 #include <memory>
-#include <charconv>
+#include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp> // for boost::to_lower
 #ifndef __cpp_lib_atomic_shared_ptr
 #include <boost/atomic.hpp>
@@ -106,7 +106,8 @@ namespace data
 			// skip identity
 			size_t identityLen = m_RouterIdentity->GetFullLen ();
 			// read new RI
-			ReadFromBuffer (buf + identityLen, len - identityLen);
+			std::stringstream str (std::string ((char *)buf + identityLen, len - identityLen));
+			ReadFromStream (str);
 			if (!m_IsUnreachable)
 				UpdateBuffer (buf, len); // save buffer	
 			// don't delete buffer until saved to the file
@@ -194,34 +195,39 @@ namespace data
 			}
 		}
 		// parse RI
-		if (!ReadFromBuffer (m_Buffer->data () + identityLen, bufferLen - identityLen))
+		std::stringstream str;
+		str.write ((const char *)m_Buffer->data () + identityLen, bufferLen - identityLen);
+		ReadFromStream (str);
+		if (!str)
 		{
 			LogPrint (eLogError, "RouterInfo: Malformed message");
 			m_IsUnreachable = true;
 		}
 	}
 
-	bool RouterInfo::ReadFromBuffer (const uint8_t * buf, size_t len)
+	void RouterInfo::ReadFromStream (std::istream& s)
 	{
-		if (len < 9) return false;
+		if (!s) return;
 		m_Caps = 0; m_Congestion = eLowCongestion;
-		m_Timestamp = bufbe64toh (buf);
+		s.read ((char *)&m_Timestamp, sizeof (m_Timestamp));
-		size_t offset = 8; // timestamp
+		m_Timestamp = be64toh (m_Timestamp);
 		// read addresses
 		auto addresses = NewAddresses ();
-		uint8_t numAddresses = buf[offset]; offset++;
+		uint8_t numAddresses;
+		s.read ((char *)&numAddresses, sizeof (numAddresses));
 		for (int i = 0; i < numAddresses; i++)
 		{
-			if (offset + 9 > len) return false; // 1 byte cost + 8 bytes date
 			uint8_t supportedTransports = 0;
 			auto address = NewAddress ();
-			offset++; // cost, ignore
+			uint8_t cost; // ignore
-			address->date = bufbe64toh (buf + offset); offset += 8; // date
+			s.read ((char *)&cost, sizeof (cost));
+			s.read ((char *)&address->date, sizeof (address->date));
 			bool isHost = false, isStaticKey = false, isV2 = false, isIntroKey = false;
-			auto transportStyle = ExtractString (buf + offset, len - offset); offset += transportStyle.length () + 1;
+			char transportStyle[6];
-			if (!transportStyle.compare (0, 4, "NTCP")) // NTCP or NTCP2
+			ReadString (transportStyle, 6, s);
+			if (!strncmp (transportStyle, "NTCP", 4)) // NTCP or NTCP2
 				address->transportStyle = eTransportNTCP2;
-			else if (!transportStyle.compare (0, 3, "SSU")) // SSU or SSU2
+			else if (!strncmp (transportStyle, "SSU", 3)) // SSU or SSU2
 			{
 				address->transportStyle = eTransportSSU2;
 				address->ssu.reset (new SSUExt ());
@@ -231,22 +237,24 @@ namespace data
 				address->transportStyle = eTransportUnknown;
 			address->caps = 0;
 			address->port = 0;
-			if (offset + 2 > len) return false;
+			uint16_t size, r = 0;
-			uint16_t size = bufbe16toh (buf + offset); offset += 2; // size
+			s.read ((char *)&size, sizeof (size)); if (!s) return;
-			if (offset + size >= len) return false;
+			size = be16toh (size);
 			if (address->transportStyle == eTransportUnknown)
 			{
 				// skip unknown address
-				offset += size;
+				s.seekg (size, std::ios_base::cur);
-				continue;
+				if (s) continue; else return;
 			}
-			size_t r = 0;
 			while (r < size)
 			{
-				auto [key, value, sz] = ExtractParam (buf + offset, len - offset);
+				char key[255], value[255];
-				r += sz; offset += sz;
+				r += ReadString (key, 255, s);
-				if (key.empty ()) continue;
+				s.seekg (1, std::ios_base::cur); r++; // =
-				if (key == "host")
+				r += ReadString (value, 255, s);
+				s.seekg (1, std::ios_base::cur); r++; // ;
+				if (!s) return;
+				if (!strcmp (key, "host"))
 				{
 					boost::system::error_code ecode;
 					address->host = boost::asio::ip::make_address (value, ecode);
@@ -260,53 +268,63 @@ namespace data
 							address->transportStyle = eTransportUnknown;
 					}
 				}
-				else if (key == "port")
+				else if (!strcmp (key, "port"))
 				{
-					auto res = std::from_chars(value.data(), value.data() + value.size(), address->port);
+					try
-					if (res.ec != std::errc())
+					{
-						LogPrint (eLogWarning, "RouterInfo: 'port' conversion error: ", std::make_error_code (res.ec).message ());
+						address->port = boost::lexical_cast<int>(value);
+					}
+					catch (std::exception& ex)
+					{
+						LogPrint (eLogWarning, "RouterInfo: 'port' exception ", ex.what ());
+					}
 				}
-				else if (key == "mtu")
+				else if (!strcmp (key, "mtu"))
 				{
 					if (address->ssu)
 					{
-						auto res = std::from_chars(value.data(), value.data() + value.size(), address->ssu->mtu);
+						try
-						if (res.ec != std::errc())
+						{
-							LogPrint (eLogWarning, "RouterInfo: 'mtu' conversion error: ", std::make_error_code (res.ec).message ());
+							address->ssu->mtu = boost::lexical_cast<int>(value);
+						}
+						catch (std::exception& ex)
+						{
+							LogPrint (eLogWarning, "RouterInfo: 'mtu' exception ", ex.what ());
+						}
 					}
 					else
 						LogPrint (eLogWarning, "RouterInfo: Unexpected field 'mtu' for NTCP2");
 				}
-				else if (key == "caps")
+				else if (!strcmp (key, "caps"))
 					address->caps = ExtractAddressCaps (value);
-				else if (key == "s") // ntcp2 or ssu2 static key
+				else if (!strcmp (key, "s")) // ntcp2 or ssu2 static key
 				{
-					if (Base64ToByteStream (value.data (), value.length (), address->s, 32) == 32 &&
+					if (Base64ToByteStream (value, strlen (value), address->s, 32) == 32 &&
 						!(address->s[31] & 0x80)) // check if x25519 public key
 							isStaticKey = true;
 					else
 						address->transportStyle = eTransportUnknown; // invalid address
 				}
-				else if (key == "i") // ntcp2 iv or ssu2 intro
+				else if (!strcmp (key, "i")) // ntcp2 iv or ssu2 intro
 				{
 					if (address->IsNTCP2 ())
 					{
-						if (Base64ToByteStream (value.data (), value.length (), address->i, 16) == 16)
+						if (Base64ToByteStream (value, strlen (value), address->i, 16) == 16)
 							address->published = true; // presence of "i" means "published" NTCP2
 						else
 							address->transportStyle = eTransportUnknown; // invalid address
 					}
 					else if (address->IsSSU2 ())
 					{	
-						if (Base64ToByteStream (value.data (), value.length (), address->i, 32) == 32)
+						if (Base64ToByteStream (value, strlen (value), address->i, 32) == 32)
 							isIntroKey = true;
 						else
 							address->transportStyle = eTransportUnknown; // invalid address
 					}	
 				}
-				else if (key == "v")
+				else if (!strcmp (key, "v"))
 				{
-					if (value == "2")
+					if (!strcmp (value, "2"))
 						isV2 = true;
 					else
 					{	
@@ -322,11 +340,13 @@ namespace data
 						LogPrint (eLogError, "RouterInfo: Introducer is presented for non-SSU address. Skipped");
 						continue;
 					}
-					unsigned char index = key[key.length () - 1] - '0'; // TODO:
+					size_t l = strlen(key);
+					unsigned char index = key[l-1] - '0'; // TODO:
+					key[l-1] = 0;
 					if (index > 9)
 					{
 						LogPrint (eLogError, "RouterInfo: Unexpected introducer's index ", index, " skipped");
-						continue;
+						if (s) continue; else return;
 					}
 					if (index >= address->ssu->introducers.size ())
 					{
@@ -335,23 +355,34 @@ namespace data
 						address->ssu->introducers.resize (index + 1);
 					}
 					Introducer& introducer = address->ssu->introducers.at (index);
-					auto key1 = key.substr(0, key.length () - 1);
+					if (!strcmp (key, "itag"))
-					if (key1 == "itag")
 					{
-						auto res = std::from_chars(value.data(), value.data() + value.size(), introducer.iTag);
+						try
-						if (res.ec != std::errc())
+						{
-							LogPrint (eLogWarning, "RouterInfo: 'itag' conversion error: ", std::make_error_code (res.ec).message ());
+							introducer.iTag = boost::lexical_cast<uint32_t>(value);
+						}
+						catch (std::exception& ex)
+						{
+							LogPrint (eLogWarning, "RouterInfo: 'itag' exception ", ex.what ());
+						}
 					}
-					else if (key1 == "ih")
+					else if (!strcmp (key, "ih"))
-						Base64ToByteStream (value.data (), value.length (), introducer.iH, 32);
+						Base64ToByteStream (value, strlen (value), introducer.iH, 32);
-					else if (key1 == "iexp")
+					else if (!strcmp (key, "iexp"))
 					{
-						auto res = std::from_chars(value.data(), value.data() + value.size(), introducer.iExp);
+						try
-						if (res.ec != std::errc())
+						{
-							LogPrint (eLogWarning, "RouterInfo: 'iexp' conversion error: ", std::make_error_code (res.ec).message ());
+							introducer.iExp = boost::lexical_cast<uint32_t>(value);
+						}
+						catch (std::exception& ex)
+						{
+							LogPrint (eLogWarning, "RouterInfo: 'iexp' exception ", ex.what ());
+						}
 					}
 				}
+				if (!s) return;
 			}
+			
 			if (address->transportStyle == eTransportNTCP2)
 			{
 				if (isStaticKey)
@@ -415,41 +446,45 @@ namespace data
 		boost::atomic_store (&m_Addresses, addresses);
 #endif
 		// read peers
-		if (offset + 1 > len) return false;
+		uint8_t numPeers;
-		uint8_t numPeers = buf[offset]; offset++; // num peers
+		s.read ((char *)&numPeers, sizeof (numPeers)); if (!s) return;
-		offset += numPeers*32; // TODO: read peers
+		s.seekg (numPeers*32, std::ios_base::cur); // TODO: read peers
 		// read properties
-		if (offset + 2 > len) return false;
 		m_Version = 0;
 		bool isNetId = false;
 		std::string family;
-		uint16_t size = bufbe16toh (buf + offset); offset += 2; // size
+		uint16_t size, r = 0;
-		if (offset + size > len) return false;
+		s.read ((char *)&size, sizeof (size)); if (!s) return;
-		size_t r = 0;
+		size = be16toh (size);
 		while (r < size)
 		{
-			auto [key, value, sz] = ExtractParam (buf + offset, len - offset);
+			char key[255], value[255];
-			r += sz; offset += sz;
+			r += ReadString (key, 255, s);
-			if (key.empty ()) continue;
+			s.seekg (1, std::ios_base::cur); r++; // =
+			r += ReadString (value, 255, s);
+			s.seekg (1, std::ios_base::cur); r++; // ;
+			if (!s) return;
 			SetProperty (key, value);
 
 			// extract caps
-			if (key == "caps")
+			if (!strcmp (key, "caps"))
 			{	
 				ExtractCaps (value);
 				m_IsFloodfill = IsDeclaredFloodfill ();
 			}	
 			// extract version
-			else if (key == ROUTER_INFO_PROPERTY_VERSION)
+			else if (!strcmp (key, ROUTER_INFO_PROPERTY_VERSION))
 			{
 				m_Version = 0;
-				for (auto ch: value)
+				char * ch = value;
+				while (*ch)
 				{
-					if (ch >= '0' && ch <= '9')
+					if (*ch >= '0' && *ch <= '9')
 					{
 						m_Version *= 10;
-						m_Version += (ch - '0');
+						m_Version += (*ch - '0');
 					}
+					ch++;
 				}
 				if (m_Version < NETDB_MIN_PEER_TEST_VERSION && (m_SupportedTransports & (eSSU2V4 | eSSU2V6)))
 				{
@@ -462,26 +497,24 @@ namespace data
 				}	
 			}
 			// check netId
-			else if (key == ROUTER_INFO_PROPERTY_NETID)
+			else if (!strcmp (key, ROUTER_INFO_PROPERTY_NETID))
 			{
 				isNetId = true;
-				int netID;
+				if (atoi (value) != i2p::context.GetNetID ())
-				auto res = std::from_chars(value.data(), value.data() + value.size(), netID);
-				if (res.ec != std::errc() || netID != i2p::context.GetNetID ())
 				{
 					LogPrint (eLogError, "RouterInfo: Unexpected ", ROUTER_INFO_PROPERTY_NETID, "=", value);
 					m_IsUnreachable = true;
 				}
 			}
 			// family
-			else if (key == ROUTER_INFO_PROPERTY_FAMILY)
+			else if (!strcmp (key, ROUTER_INFO_PROPERTY_FAMILY))
 			{
 				family = value;
 				boost::to_lower (family);
 			}
-			else if (key == ROUTER_INFO_PROPERTY_FAMILY_SIG)
+			else if (!strcmp (key, ROUTER_INFO_PROPERTY_FAMILY_SIG))
 			{
-				if (netdb.GetFamilies ().VerifyFamily (family, GetIdentHash (), value)) // TODO
+				if (netdb.GetFamilies ().VerifyFamily (family, GetIdentHash (), value))
 					m_FamilyID = netdb.GetFamilies ().GetFamilyID (family);
 				else
 				{	
@@ -489,12 +522,12 @@ namespace data
 					SetUnreachable (true);	
 				}		
 			}
+
+			if (!s) return;
 		}
 
 		if (!m_SupportedTransports || !isNetId || !m_Version)
 			SetUnreachable (true);
-		
-		return true;
 	}
 
 	bool RouterInfo::IsFamily (FamilyID famid) const
@@ -502,11 +535,12 @@ namespace data
 		return m_FamilyID == famid;
 	}
 
-	void RouterInfo::ExtractCaps (std::string_view value)
+	void RouterInfo::ExtractCaps (const char * value)
 	{
-		for (auto cap: value)
+		const char * cap = value;
+		while (*cap)
 		{
-			switch (cap)
+			switch (*cap)
 			{
 				case CAPS_FLAG_FLOODFILL:
 					m_Caps |= Caps::eFloodfill;
@@ -515,16 +549,16 @@ namespace data
 				case CAPS_FLAG_LOW_BANDWIDTH2:
 				case CAPS_FLAG_LOW_BANDWIDTH3:
 				case CAPS_FLAG_LOW_BANDWIDTH4:
-					m_BandwidthCap = cap;
+					m_BandwidthCap = *cap;
 				break;
 				case CAPS_FLAG_HIGH_BANDWIDTH:
 					m_Caps |= Caps::eHighBandwidth;
-					m_BandwidthCap = cap;
+					m_BandwidthCap = *cap;
 				break;
 				case CAPS_FLAG_EXTRA_BANDWIDTH1:
 				case CAPS_FLAG_EXTRA_BANDWIDTH2:
 					m_Caps |= Caps::eExtraBandwidth | Caps::eHighBandwidth;
-					m_BandwidthCap = cap;
+					m_BandwidthCap = *cap;
 				break;
 				case CAPS_FLAG_HIDDEN:
 					m_Caps |= Caps::eHidden;
@@ -546,15 +580,17 @@ namespace data
 				break;	
 				default: ;
 			}
+			cap++;
 		}
 	}
 
-	uint8_t RouterInfo::ExtractAddressCaps (std::string_view value) const
+	uint8_t RouterInfo::ExtractAddressCaps (const char * value) const
 	{
 		uint8_t caps = 0;
-		for (auto cap: value)
+		const char * cap = value;
+		while (*cap)
 		{
-			switch (cap)
+			switch (*cap)
 			{
 				case CAPS_FLAG_V4:
 					caps |= AddressCaps::eV4;
@@ -570,6 +606,7 @@ namespace data
 				break;
 				default: ;
 			}
+			cap++;
 		}
 		return caps;
 	}
@@ -633,39 +670,23 @@ namespace data
 		return SaveToFile (fullPath, m_Buffer);
 	}
 
-	std::string_view RouterInfo::ExtractString (const uint8_t * buf, size_t len) const
+	size_t RouterInfo::ReadString (char * str, size_t len, std::istream& s) const
 	{
-		uint8_t l = buf[0];
+		uint8_t l;
-		if (l > len)
+		s.read ((char *)&l, 1);
+		if (l < len)
+		{
+			s.read (str, l);
+			if (!s) l = 0; // failed, return empty string
+			str[l] = 0;
+		}
+		else
 		{
 			LogPrint (eLogWarning, "RouterInfo: String length ", (int)l, " exceeds buffer size ", len);
-			l = len;
+			s.seekg (l, std::ios::cur); // skip
+			str[0] = 0;
 		}
-		return { (const char *)(buf + 1), l };
+		return l+1;
-	}
-
-	std::tuple<std::string_view, std::string_view, size_t> RouterInfo::ExtractParam (const uint8_t * buf, size_t len) const
-	{
-		auto key = ExtractString (buf, len);
-		size_t offset = key.length () + 1;
-		if (offset >= len) return { std::string_view(), std::string_view(), len };
-		if (buf[offset] != '=')
-		{	
-			LogPrint (eLogWarning, "RouterInfo: Unexpected character ", buf[offset], " instead '=' after ", key);
-			key = std::string_view();
-		}	
-		offset++;
-		if (offset >= len) return { key, std::string_view(), len };
-		auto value = ExtractString (buf + offset, len - offset);
-		offset += value.length () + 1;
-		if (offset >= len) return { key, std::string_view(), len };
-		if (buf[offset] != ';')
-		{	
-			LogPrint (eLogWarning, "RouterInfo: Unexpected character ", buf[offset], " instead ';' after ", value);
-			value = std::string_view();
-		}	
-		offset++;
-		return { key, value, offset };
 	}
 
 	void RouterInfo::AddNTCP2Address (const uint8_t * staticKey, const uint8_t * iv,int port, uint8_t caps)
@@ -1381,9 +1402,9 @@ namespace data
 						if (!introducer.iTag) continue;
 						if (introducer.iExp) // expiration is specified
 						{
-							WriteString ("iexp" + std::to_string(i), properties);
+							WriteString ("iexp" + boost::lexical_cast<std::string>(i), properties);
 							properties << '=';
-							WriteString (std::to_string(introducer.iExp), properties);
+							WriteString (boost::lexical_cast<std::string>(introducer.iExp), properties);
 							properties << ';';
 						}
 						i++;
@@ -1392,7 +1413,7 @@ namespace data
 					for (const auto& introducer: address.ssu->introducers)
 					{
 						if (!introducer.iTag) continue;
-						WriteString ("ih" + std::to_string(i), properties);
+						WriteString ("ih" + boost::lexical_cast<std::string>(i), properties);
 						properties << '=';
 						char value[64];
 						size_t l = ByteStreamToBase64 (introducer.iH, 32, value, 64);
@@ -1405,9 +1426,9 @@ namespace data
 					for (const auto& introducer: address.ssu->introducers)
 					{
 						if (!introducer.iTag) continue;
-						WriteString ("itag" + std::to_string(i), properties);
+						WriteString ("itag" + boost::lexical_cast<std::string>(i), properties);
 						properties << '=';
-						WriteString (std::to_string(introducer.iTag), properties);
+						WriteString (boost::lexical_cast<std::string>(introducer.iTag), properties);
 						properties << ';';
 						i++;
 					}
@@ -1421,7 +1442,7 @@ namespace data
 				{
 					WriteString ("mtu", properties);
 					properties << '=';
-					WriteString (std::to_string(address.ssu->mtu), properties);
+					WriteString (boost::lexical_cast<std::string>(address.ssu->mtu), properties);
 					properties << ';';
 				}
 			}
@@ -1429,7 +1450,7 @@ namespace data
 			{
 				WriteString ("port", properties);
 				properties << '=';
-				WriteString (std::to_string(address.port), properties);
+				WriteString (boost::lexical_cast<std::string>(address.port), properties);
 				properties << ';';
 			}
 			if (address.IsNTCP2 () || address.IsSSU2 ())
@@ -1464,11 +1485,9 @@ namespace data
 		s.write (properties.str ().c_str (), properties.str ().size ());
 	}
 
-	void LocalRouterInfo::SetProperty (std::string_view key, std::string_view value)
+	void LocalRouterInfo::SetProperty (const std::string& key, const std::string& value)
 	{
-		auto [it, inserted] = m_Properties.emplace (key, value);
+		m_Properties[key] = value;
-		if (!inserted)
-			it->second = value;
 	}
 
 	void LocalRouterInfo::DeleteProperty (const std::string& key)

libi2pd/RouterInfo.h

@@ -11,8 +11,6 @@
 
 #include <inttypes.h>
 #include <string>
-#include <string_view>
-#include <tuple>
 #include <map>
 #include <vector>
 #include <array>
@@ -221,7 +219,7 @@ namespace data
 			std::string GetIdentHashBase64 () const { return GetIdentHash ().ToBase64 (); };
 			uint64_t GetTimestamp () const { return m_Timestamp; };
 			int GetVersion () const { return m_Version; };
-			virtual void SetProperty (std::string_view key, std::string_view value) {};
+			virtual void SetProperty (const std::string& key, const std::string& value) {};
 			virtual void ClearProperties () {};
 			AddressesPtr GetAddresses () const; // should be called for local RI only, otherwise must return shared_ptr
 			std::shared_ptr<const Address> GetNTCP2V4Address () const;
@@ -335,12 +333,11 @@ namespace data
 
 			bool LoadFile (const std::string& fullPath);
 			void ReadFromFile (const std::string& fullPath);
-			bool ReadFromBuffer (const uint8_t * buf, size_t len); // return false if malformed
+			void ReadFromStream (std::istream& s);
 			void ReadFromBuffer (bool verifySignature);
-			std::string_view ExtractString (const uint8_t * buf, size_t len) const;
+			size_t ReadString (char* str, size_t len, std::istream& s) const;
-			std::tuple<std::string_view, std::string_view, size_t> ExtractParam (const uint8_t * buf, size_t len) const;
+			void ExtractCaps (const char * value);
-			void ExtractCaps (std::string_view value);
+			uint8_t ExtractAddressCaps (const char * value) const;
-			uint8_t ExtractAddressCaps (std::string_view value) const;
 			void UpdateIntroducers (std::shared_ptr<Address> address, uint64_t ts); 
 			template<typename Filter>
 			std::shared_ptr<const Address> GetAddress (Filter filter) const;
@@ -382,7 +379,7 @@ namespace data
 			void UpdateCaps (uint8_t caps);
 			bool UpdateCongestion (Congestion c); // returns true if updated
 
-			void SetProperty (std::string_view key, std::string_view value) override;
+			void SetProperty (const std::string& key, const std::string& value) override;
 			void DeleteProperty (const std::string& key);
 			std::string GetProperty (const std::string& key) const;
 			void ClearProperties () override { m_Properties.clear (); };

libi2pd/SSU2OutOfSession.cpp

@@ -191,7 +191,12 @@ namespace transport
 
 	void SSU2PeerTestSession::SendPeerTest (uint8_t msg, const uint8_t * signedData, size_t signedDataLen, bool delayed)
 	{
+#if __cplusplus >= 202002L // C++20
 		m_SignedData.assign (signedData, signedData + signedDataLen);
+#else		
+		m_SignedData.resize (signedDataLen);
+		memcpy (m_SignedData.data (), signedData, signedDataLen);
+#endif		
 		if (!delayed)
 			SendPeerTest (msg);
 		// schedule resend for msgs 5 or 6
@@ -252,7 +257,7 @@ namespace transport
 	{
 		// we are Charlie
 		uint64_t destConnID = htobe64 (((uint64_t)nonce << 32) | nonce); // dest id
-		uint64_t sourceConnID = ~destConnID;
+		uint32_t sourceConnID = ~destConnID;
 		SetSourceConnID (sourceConnID);
 		SetDestConnID (destConnID);	
 		SetState (eSSU2SessionStateHolePunch);
@@ -308,7 +313,12 @@ namespace transport
 
 	void SSU2HolePunchSession::SendHolePunch (const uint8_t * relayResponseBlock, size_t relayResponseBlockLen)
 	{
+#if __cplusplus >= 202002L // C++20
 		m_RelayResponseBlock.assign (relayResponseBlock, relayResponseBlock + relayResponseBlockLen);
+#else		
+		m_RelayResponseBlock.resize (relayResponseBlockLen);
+		memcpy (m_RelayResponseBlock.data (), relayResponseBlock, relayResponseBlockLen);
+#endif		
 		SendHolePunch ();
 		ScheduleResend ();
 	}	

libi2pd/SSU2Session.cpp

@@ -189,7 +189,7 @@ namespace transport
 		if (!asz) return false;
 		payload[17] = asz;
 		packet->payloadSize = asz + 18;
-		SignedData<128> s;
+		SignedData s;
 		s.Insert ((const uint8_t *)"RelayRequestData", 16); // prologue
 		s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 		s.Insert (session->GetRemoteIdentity ()->GetIdentHash (), 32); // chash
@@ -1965,7 +1965,6 @@ namespace transport
 	void SSU2Session::HandleRelayRequest (const uint8_t * buf, size_t len)
 	{
 		// we are Bob
-		if (len < 9) return;
 		auto mts = i2p::util::GetMillisecondsSinceEpoch ();
 		uint32_t nonce = bufbe32toh (buf + 1); // nonce
 		uint32_t relayTag = bufbe32toh (buf + 5); // relay tag
@@ -1999,7 +1998,7 @@ namespace transport
 			packet->payloadSize = r ? CreateRouterInfoBlock (packet->payload, m_MaxPayloadSize - len - 32, r) : 0;
 			if (!packet->payloadSize && r)
 				session->SendFragmentedMessage (CreateDatabaseStoreMsg (r));
-			packet->payloadSize += CreateRelayIntroBlock (packet->payload + packet->payloadSize, m_MaxPayloadSize - packet->payloadSize, buf + 1, len - 1);
+			packet->payloadSize += CreateRelayIntroBlock (packet->payload + packet->payloadSize, m_MaxPayloadSize - packet->payloadSize, buf + 1, len -1);
 			if (packet->payloadSize < m_MaxPayloadSize)
 				packet->payloadSize += CreatePaddingBlock (packet->payload + packet->payloadSize, m_MaxPayloadSize - packet->payloadSize);
 			uint32_t packetNum = session->SendData (packet->payload, packet->payloadSize);
@@ -2014,24 +2013,18 @@ namespace transport
 	void SSU2Session::HandleRelayIntro (const uint8_t * buf, size_t len, int attempts)
 	{
 		// we are Charlie
-		if (len < 47) return;
 		SSU2RelayResponseCode code = eSSU2RelayResponseCodeAccept;
 		boost::asio::ip::udp::endpoint ep;
 		std::shared_ptr<const i2p::data::RouterInfo::Address> addr;
 		auto r = i2p::data::netdb.FindRouter (buf + 1); // Alice
 		if (r)
 		{
-			SignedData<128> s;
+			SignedData s;
 			s.Insert ((const uint8_t *)"RelayRequestData", 16); // prologue
 			s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 			s.Insert (i2p::context.GetIdentHash (), 32); // chash
 			s.Insert (buf + 33, 14); // nonce, relay tag, timestamp, ver, asz
 			uint8_t asz = buf[46];
-			if (asz + 47 + r->GetIdentity ()->GetSignatureLen () > len) 
-			{	
-				LogPrint (eLogWarning, "SSU2: Malformed RelayIntro len=", len);
-				return; 
-			}	
 			s.Insert (buf + 47, asz); // Alice Port, Alice IP
 			if (s.Verify (r->GetIdentity (), buf + 47 + asz))
 			{
@@ -2120,7 +2113,6 @@ namespace transport
 
 	void SSU2Session::HandleRelayResponse (const uint8_t * buf, size_t len)
 	{
-		if (len < 6) return;
 		uint32_t nonce = bufbe32toh (buf + 2);
 		if (m_State == eSSU2SessionStateIntroduced)
 		{
@@ -2141,9 +2133,7 @@ namespace transport
 		auto it = m_RelaySessions.find (nonce);
 		if (it != m_RelaySessions.end ())
 		{
-			auto relaySession = it->second.first;
+			if (it->second.first && it->second.first->IsEstablished ())
-			m_RelaySessions.erase (it);
-			if (relaySession && relaySession->IsEstablished ())
 			{
 				// we are Bob, message from Charlie
 				auto packet = m_Server.GetSentPacketsPool ().AcquireShared ();
@@ -2153,12 +2143,12 @@ namespace transport
 				memcpy (payload + 3, buf, len); // forward to Alice as is
 				packet->payloadSize = len + 3;
 				packet->payloadSize += CreatePaddingBlock (payload + packet->payloadSize, m_MaxPayloadSize - packet->payloadSize);
-				uint32_t packetNum = relaySession->SendData (packet->payload, packet->payloadSize);
+				uint32_t packetNum = it->second.first->SendData (packet->payload, packet->payloadSize);
 				if (m_RemoteVersion >= SSU2_MIN_RELAY_RESPONSE_RESEND_VERSION)
 				{	
 					// sometimes Alice doesn't ack this RelayResponse in older versions
 					packet->sendTime = i2p::util::GetMillisecondsSinceEpoch ();
-					relaySession->m_SentPackets.emplace (packetNum, packet);
+					it->second.first->m_SentPackets.emplace (packetNum, packet);
 				}	
 			}
 			else
@@ -2167,31 +2157,25 @@ namespace transport
 				if (!buf[1]) // status code accepted?
 				{
 					// verify signature
-					uint8_t csz = (len >= 12) ? buf[11] : 0;
+					uint8_t csz = buf[11];
-					if (csz + 12 + relaySession->GetRemoteIdentity ()->GetSignatureLen () > len)
+					SignedData s;
-					{
-						LogPrint (eLogWarning, "SSU2: Malformed RelayResponse len=", len);
-						relaySession->Done ();
-						return;
-					}	
-					SignedData<128> s;
 					s.Insert ((const uint8_t *)"RelayAgreementOK", 16); // prologue
 					s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 					s.Insert (buf + 2, 10 + csz); // nonce, timestamp, ver, csz and Charlie's endpoint
-					if (s.Verify (relaySession->GetRemoteIdentity (), buf + 12 + csz))
+					if (s.Verify (it->second.first->GetRemoteIdentity (), buf + 12 + csz))
 					{
-						if (relaySession->m_State == eSSU2SessionStateIntroduced) // HolePunch not received yet
+						if (it->second.first->m_State == eSSU2SessionStateIntroduced) // HolePunch not received yet
 						{
 							// update Charlie's endpoint
-							if (ExtractEndpoint (buf + 12, csz, relaySession->m_RemoteEndpoint))
+							if (ExtractEndpoint (buf + 12, csz, it->second.first->m_RemoteEndpoint))
 							{
 								// update token
 								uint64_t token;
 								memcpy (&token, buf + len - 8, 8);
-								m_Server.UpdateOutgoingToken (relaySession->m_RemoteEndpoint,
+								m_Server.UpdateOutgoingToken (it->second.first->m_RemoteEndpoint,
 									token, i2p::util::GetSecondsSinceEpoch () + SSU2_TOKEN_EXPIRATION_TIMEOUT);
 								// connect to Charlie, HolePunch will be ignored
-								relaySession->ConnectAfterIntroduction ();
+								it->second.first->ConnectAfterIntroduction ();
 							}
 							else
 								LogPrint (eLogWarning, "SSU2: RelayResponse can't extract endpoint");
@@ -2200,15 +2184,16 @@ namespace transport
 					else
 					{
 						LogPrint (eLogWarning, "SSU2: RelayResponse signature verification failed");
-						relaySession->Done ();
+						it->second.first->Done ();
 					}
 				}
 				else
 				{
 					LogPrint (eLogInfo, "SSU2: RelayResponse status code=", (int)buf[1], " nonce=", bufbe32toh (buf + 2));
-					relaySession->Done ();
+					it->second.first->Done ();
 				}
 			}
+			m_RelaySessions.erase (it);
 		}
 		else
 			LogPrint (eLogDebug, "SSU2: RelayResponse unknown nonce ", bufbe32toh (buf + 2));
@@ -2277,13 +2262,10 @@ namespace transport
 			case 2: // Charlie from Bob
 			{
 				// sign with Charlie's key
-				if (len < offset + 9) return;
 				uint8_t asz = buf[offset + 9];
-				size_t l = asz + 10 + i2p::context.GetIdentity ()->GetSignatureLen ();
+				std::vector<uint8_t> newSignedData (asz + 10 + i2p::context.GetIdentity ()->GetSignatureLen ());
-				if (len < offset + l) return;
-				std::vector<uint8_t> newSignedData (l);
 				memcpy (newSignedData.data (), buf + offset, asz + 10);
-				SignedData<128> s;
+				SignedData s;
 				s.Insert ((const uint8_t *)"PeerTestValidate", 16); // prologue
 				s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 				s.Insert (buf + 3, 32); // ahash
@@ -2391,16 +2373,10 @@ namespace transport
 						if (GetRouterStatus () == eRouterStatusUnknown)
 							SetTestingState (true);
 						auto r = i2p::data::netdb.FindRouter (buf + 3); // find Charlie
-						if (r && len >= offset + 9)
+						if (r)
 						{
 							uint8_t asz = buf[offset + 9];
-							if (len < offset + asz + 10 + r->GetIdentity ()->GetSignatureLen ())
+							SignedData s;
-							{
-								LogPrint (eLogWarning, "Malformed PeerTest 4 len=", len);
-								session->Done ();
-								return;
-							}	
-							SignedData<128> s;
 							s.Insert ((const uint8_t *)"PeerTestValidate", 16); // prologue
 							s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 							s.Insert (i2p::context.GetIdentity ()->GetIdentHash (), 32); // ahash
@@ -2786,7 +2762,7 @@ namespace transport
 	size_t SSU2Session::CreatePaddingBlock (uint8_t * buf, size_t len, size_t minSize)
 	{
 		if (len < 3 || len < minSize) return 0;
-		size_t paddingSize = m_Server.GetRng ()() & 0x1F; // 0 - 31
+		size_t paddingSize = m_Server.GetRng ()() & 0x0F; // 0 - 15
 		if (paddingSize + 3 > len) paddingSize = len - 3;
 		else if (paddingSize + 3 < minSize) paddingSize = minSize - 3;
 		buf[0] = eSSU2BlkPadding;
@@ -2888,7 +2864,7 @@ namespace transport
 			LogPrint (eLogError, "SSU2: Buffer for RelayResponse signature is too small ", len);
 			return 0;
 		}
-		SignedData<128> s;
+		SignedData s;
 		s.Insert ((const uint8_t *)"RelayAgreementOK", 16); // prologue
 		if (code == eSSU2RelayResponseCodeAccept || code >= 64) // Charlie
 			s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
@@ -2950,7 +2926,7 @@ namespace transport
 		size_t asz = CreateEndpoint (signedData + 10, 86, boost::asio::ip::udp::endpoint (localAddress->host, localAddress->port));
 		signedData[9] = asz;
 		// signature
-		SignedData<128> s;
+		SignedData s;
 		s.Insert ((const uint8_t *)"PeerTestValidate", 16); // prologue
 		s.Insert (GetRemoteIdentity ()->GetIdentHash (), 32); // bhash
 		s.Insert (signedData, 10 + asz); // ver, nonce, ts, asz, Alice's endpoint

libi2pd/Streaming.cpp

@@ -613,8 +613,10 @@ namespace stream
 			if (wasInitial)
 				ScheduleResend ();
 		}
-		if (m_IsClientChoked && ackThrough >= m_DropWindowDelaySequenceNumber)
+		if (m_IsClientChoked && ackThrough > m_DropWindowDelaySequenceNumber)
+		{
 			m_IsClientChoked = false;
+		}
 		if (m_IsWinDropped && ackThrough > m_DropWindowDelaySequenceNumber)
 		{
 			m_IsFirstRttSample = true;
@@ -1295,7 +1297,7 @@ namespace stream
 					m_NumPacketsToSend = 1; m_PacingTimeRem = 0;
 				}	
 				m_IsSendTime = true;
-				if (m_WindowIncCounter && (m_WindowSize < MAX_WINDOW_SIZE || m_WindowDropTargetSize) && !m_SendBuffer.IsEmpty () && m_PacingTime > m_MinPacingTime && m_RTT <= m_SlowRTT)
+				if (m_WindowIncCounter && (m_WindowSize < MAX_WINDOW_SIZE || m_WindowDropTargetSize) && !m_SendBuffer.IsEmpty () && m_PacingTime > m_MinPacingTime)
 				{
 					for (int i = 0; i < m_NumPacketsToSend; i++)
 					{
@@ -1305,7 +1307,7 @@ namespace stream
 							{
 								if (m_LastWindowDropSize && (m_LastWindowDropSize >= m_WindowDropTargetSize))
 									m_WindowDropTargetSize += 1 - (1 / ((m_LastWindowDropSize + PREV_SPEED_KEEP_TIME_COEFF) / m_WindowDropTargetSize)); // some magic here
-								else if (m_LastWindowDropSize && (m_LastWindowDropSize < m_WindowDropTargetSize))
+								else if (m_LastWindowDropSize && (m_LastWindowDropSize < m_WindowSize))
 									m_WindowDropTargetSize += (m_WindowDropTargetSize - (m_LastWindowDropSize - PREV_SPEED_KEEP_TIME_COEFF)) / m_WindowDropTargetSize; // some magic here
 								else
 									m_WindowDropTargetSize += (m_WindowDropTargetSize - (1 - PREV_SPEED_KEEP_TIME_COEFF)) / m_WindowDropTargetSize;
@@ -1644,22 +1646,14 @@ namespace stream
 
 	void Stream::ProcessWindowDrop ()
 	{
-		if (m_WindowDropTargetSize)
+		if (m_WindowSize > m_LastWindowDropSize)
-			m_WindowDropTargetSize = (m_WindowDropTargetSize / 2) * 0.75; // congestion window size and -25% to drain queue
-		else
 		{
-			if (m_WindowSize < m_LastWindowDropSize)
+			m_LastWindowDropSize = (m_LastWindowDropSize + m_WindowSize + m_WindowSizeTail) / 2;
-			{
+			if (m_LastWindowDropSize > MAX_WINDOW_SIZE) m_LastWindowDropSize = MAX_WINDOW_SIZE;
-				m_LastWindowDropSize = m_WindowSize - (m_LastWindowDropSize - m_WindowSize);
-				if (m_LastWindowDropSize < MIN_WINDOW_SIZE) m_LastWindowDropSize = MIN_WINDOW_SIZE;
-			}
-			else
-			{
-				m_LastWindowDropSize = (m_LastWindowDropSize + m_WindowSize + m_WindowSizeTail) / 2;
-				if (m_LastWindowDropSize > MAX_WINDOW_SIZE) m_LastWindowDropSize = MAX_WINDOW_SIZE;
-			}
-			m_WindowDropTargetSize = m_LastWindowDropSize * 0.75; // -25% to drain queue
 		}
+		else
+			m_LastWindowDropSize = m_WindowSize;
+		m_WindowDropTargetSize = m_LastWindowDropSize - (m_LastWindowDropSize / 4); // -25%;
 		if (m_WindowDropTargetSize < MIN_WINDOW_SIZE)
 			m_WindowDropTargetSize = MIN_WINDOW_SIZE;
 		m_WindowIncCounter = 0; // disable window growth

libi2pd/TransportSession.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2025, The PurpleI2P Project
+* Copyright (c) 2013-2024, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -10,7 +10,7 @@
 #define TRANSPORT_SESSION_H__
 
 #include <inttypes.h>
-#include <string.h>
+#include <iostream>
 #include <memory>
 #include <vector>
 #include <mutex>
@@ -28,51 +28,45 @@ namespace transport
 	const size_t IPV6_HEADER_SIZE = 40;
 	const size_t UDP_HEADER_SIZE = 8;
 
-	template<size_t sz>
 	class SignedData
 	{
 		public:
 
-			SignedData (): m_Size(0) {}
+			SignedData () {}
 			SignedData (const SignedData& other)
 			{
-				m_Size = other.m_Size;
+				m_Stream << other.m_Stream.rdbuf ();
-				memcpy (m_Buf, other.m_Buf, m_Size);
 			}
 
 			void Reset ()
 			{
-				m_Size = 0;
+				m_Stream.str("");
 			}
 
-			size_t Insert (const uint8_t * buf, size_t len)
+			void Insert (const uint8_t * buf, size_t len)
 			{
-				if (m_Size + len > sz) len = sz - m_Size;
+				m_Stream.write ((char *)buf, len);
-				memcpy (m_Buf + m_Size, buf, len); 
-				m_Size += len;
-				return len;
 			}
 
 			template<typename T>
 			void Insert (T t)
 			{
-				Insert ((const uint8_t *)&t, sizeof (T));
+				m_Stream.write ((char *)&t, sizeof (T));
 			}
 
 			bool Verify (std::shared_ptr<const i2p::data::IdentityEx> ident, const uint8_t * signature) const
 			{
-				return ident->Verify (m_Buf, m_Size, signature);
+				return ident->Verify ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature);
 			}
 
 			void Sign (const i2p::data::PrivateKeys& keys, uint8_t * signature) const
 			{
-				keys.Sign (m_Buf, m_Size, signature);
+				keys.Sign ((const uint8_t *)m_Stream.str ().c_str (), m_Stream.str ().size (), signature);
 			}
 
 		private:
 
-			uint8_t m_Buf[sz];
+			std::stringstream m_Stream;
-			size_t m_Size;
 	};
 
 	const int64_t TRANSPORT_SESSION_SLOWNESS_THRESHOLD = 500; // in milliseconds

libi2pd_client/I2CP.cpp

@@ -571,7 +571,7 @@ namespace client
 			m_IsSending = false;
 	}
 
-	std::string_view I2CPSession::ExtractString (const uint8_t * buf, size_t len) const
+	std::string_view I2CPSession::ExtractString (const uint8_t * buf, size_t len)
 	{
 		uint8_t l = buf[0];
 		if (l > len) l = len;
@@ -588,7 +588,7 @@ namespace client
 		return l + 1;
 	}
 
-	void I2CPSession::ExtractMapping (const uint8_t * buf, size_t len, std::map<std::string, std::string>& mapping) const
+	void I2CPSession::ExtractMapping (const uint8_t * buf, size_t len, std::map<std::string, std::string>& mapping)
 	// TODO: move to Base.cpp
 	{
 		size_t offset = 0;

libi2pd_client/I2CP.h

@@ -194,9 +194,9 @@ namespace client
 
 			void HandleI2CPMessageSent (const boost::system::error_code& ecode, std::size_t bytes_transferred);
 
-			std::string_view ExtractString (const uint8_t * buf, size_t len) const;
+			std::string_view ExtractString (const uint8_t * buf, size_t len);
 			size_t PutString (uint8_t * buf, size_t len, std::string_view str);
-			void ExtractMapping (const uint8_t * buf, size_t len, std::map<std::string, std::string>& mapping) const;
+			void ExtractMapping (const uint8_t * buf, size_t len, std::map<std::string, std::string>& mapping);
 			void SendSessionStatusMessage (I2CPSessionStatus status);
 			void SendHostReplyMessage (uint32_t requestID, std::shared_ptr<const i2p::data::IdentityEx> identity);