handle explicitPeers I2CP parameter

Destination.cpp

@@ -24,6 +24,7 @@ namespace client
 		int outboundTunnelLen = DEFAULT_OUTBOUND_TUNNEL_LENGTH;
 		int inboundTunnelsQuantity = DEFAULT_INBOUND_TUNNELS_QUANTITY;
 		int outboundTunnelsQuantity = DEFAULT_OUTBOUND_TUNNELS_QUANTITY;
+		std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers;
 		if (params)
 		{
 			auto it = params->find (I2CP_PARAM_INBOUND_TUNNEL_LENGTH);
@@ -66,8 +67,24 @@ namespace client
 					LogPrint (eLogInfo, "Outbound tunnels quantity set to ", quantity);
 				}	
 			}
+			it = params->find (I2CP_PARAM_EXPLICIT_PEERS);
+			if (it != params->end ())
+			{
+				explicitPeers = std::make_shared<std::vector<i2p::data::IdentHash> >();
+				std::stringstream ss(it->second);
+				std::string b64;
+				while (std::getline (ss, b64, ','))
+				{
+					i2p::data::IdentHash ident;
+					ident.FromBase64 (b64);
+					explicitPeers->push_back (ident);
+				}
+				LogPrint (eLogInfo, "Explicit peers set to ", it->second);
+			}
 		}	
 		m_Pool = i2p::tunnel::tunnels.CreateTunnelPool (this, inboundTunnelLen, outboundTunnelLen, inboundTunnelsQuantity, outboundTunnelsQuantity);  
+		if (explicitPeers)
+			m_Pool->SetExplicitPeers (explicitPeers);
 		if (m_IsPublic)
 			LogPrint (eLogInfo, "Local address ", i2p::client::GetB32Address(GetIdentHash()), " created");
 		m_StreamingDestination = std::make_shared<i2p::stream::StreamingDestination> (*this); // TODO:

Destination.h

@@ -40,6 +40,7 @@ namespace client
 	const int DEFAULT_INBOUND_TUNNELS_QUANTITY = 5;
 	const char I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY[] = "outbound.quantity";
 	const int DEFAULT_OUTBOUND_TUNNELS_QUANTITY = 5;
+	const char I2CP_PARAM_EXPLICIT_PEERS[] = "explicitPeers";
 	const int STREAM_REQUEST_TIMEOUT = 60; //in seconds
 
 	typedef std::function<void (std::shared_ptr<i2p::stream::Stream> stream)> StreamRequestComplete;

Identity.h

@@ -69,6 +69,11 @@ namespace data
 				i2p::data::Base32ToByteStream (s.c_str (), s.length (), m_Buf, sz);
 			}
 
+			void FromBase64 (const std::string& s)
+			{
+				i2p::data::Base64ToByteStream (s.c_str (), s.length (), m_Buf, sz);
+			}
+
 		private:
 
 			union // 8 bytes alignment

TunnelPool.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include "I2PEndian.h"
 #include "CryptoConst.h"
 #include "Tunnel.h"
@@ -22,6 +23,27 @@ namespace tunnel
 		DetachTunnels ();
 	}
 
+	void TunnelPool::SetExplicitPeers (std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers)
+	{
+		m_ExplicitPeers = explicitPeers;
+		if (m_ExplicitPeers)
+		{
+			int size = m_ExplicitPeers->size ();
+			if (m_NumInboundHops > size) 
+			{
+				m_NumInboundHops = size;
+				LogPrint (eLogInfo, "Inbound tunnel length has beed adjusted to ", size, " for explicit peers");
+			} 
+			if (m_NumOutboundHops > size) 
+			{
+				m_NumOutboundHops = size;
+				LogPrint (eLogInfo, "Outbound tunnel length has beed adjusted to ", size, " for explicit peers");
+			} 
+			m_NumInboundTunnels = 1;
+			m_NumOutboundTunnels = 1;
+		}	
+	}
+
 	void TunnelPool::DetachTunnels ()
 	{
 		{
@@ -291,10 +313,11 @@ namespace tunnel
 		return hop;	
 	}	
 
-	bool TunnelPool::SelectPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops)
+	bool TunnelPool::SelectPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops, bool isInbound)
 	{
+		if (m_ExplicitPeers) return SelectExplicitPeers (hops, isInbound);
 		auto prevHop = i2p::context.GetSharedRouterInfo ();	
-		int numHops = m_NumInboundHops;
+		int numHops = isInbound ? m_NumInboundHops : m_NumOutboundHops;
 		if (i2p::transport::transports.GetNumPeers () > 25)
 		{
 			auto r = i2p::transport::transports.GetRandomPeer ();
@@ -320,6 +343,30 @@ namespace tunnel
 		return true;
 	}	
 	
+	bool TunnelPool::SelectExplicitPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops, bool isInbound)
+	{
+		int size = m_ExplicitPeers->size ();
+		std::vector<int> peerIndicies;
+		for (int i = 0; i < size; i++) peerIndicies.push_back(i);
+		std::random_shuffle (peerIndicies.begin(), peerIndicies.end());
+	
+		int numHops = isInbound ? m_NumInboundHops : m_NumOutboundHops;		
+		for (int i = 0; i < numHops; i++) 
+		{
+			auto& ident = (*m_ExplicitPeers)[peerIndicies[i]];
+			auto r = i2p::data::netdb.FindRouter (ident);
+			if (r)
+				hops.push_back (r);
+			else
+			{
+				LogPrint (eLogInfo, "Can't find router for ", ident.ToBase64 ());
+				i2p::data::netdb.RequestDestination (ident);
+				return false;
+			}
+		}
+		return true;
+	}
+	
 	void TunnelPool::CreateInboundTunnel ()
 	{
 		auto outboundTunnel = GetNextOutboundTunnel ();
@@ -327,7 +374,7 @@ namespace tunnel
 			outboundTunnel = tunnels.GetNextOutboundTunnel ();
 		LogPrint ("Creating destination inbound tunnel...");
 		std::vector<std::shared_ptr<const i2p::data::RouterInfo> > hops;
-		if (SelectPeers (hops))
+		if (SelectPeers (hops, true))
 		{
 			std::reverse (hops.begin (), hops.end ());	
 			auto tunnel = tunnels.CreateTunnel<InboundTunnel> (std::make_shared<TunnelConfig> (hops), outboundTunnel);
@@ -356,7 +403,7 @@ namespace tunnel
 		{	
 			LogPrint ("Creating destination outbound tunnel...");
 			std::vector<std::shared_ptr<const i2p::data::RouterInfo> > hops;
-			if (SelectPeers (hops))
+			if (SelectPeers (hops, false))
 			{	
 				auto tunnel = tunnels.CreateTunnel<OutboundTunnel> (
 					std::make_shared<TunnelConfig> (hops, inboundTunnel->GetTunnelConfig ()));

TunnelPool.h

@@ -32,6 +32,7 @@ namespace tunnel
 		
 			i2p::garlic::GarlicDestination * GetLocalDestination () const { return m_LocalDestination; };
 			void SetLocalDestination (i2p::garlic::GarlicDestination * destination) { m_LocalDestination = destination; };
+			void SetExplicitPeers (std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers);
 
 			void CreateTunnels ();
 			void TunnelCreated (std::shared_ptr<InboundTunnel> createdTunnel);
@@ -61,12 +62,14 @@ namespace tunnel
 			template<class TTunnels>
 			typename TTunnels::value_type GetNextTunnel (TTunnels& tunnels, typename TTunnels::value_type excluded) const;
 			std::shared_ptr<const i2p::data::RouterInfo> SelectNextHop (std::shared_ptr<const i2p::data::RouterInfo> prevHop) const;
-			bool SelectPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops);
+			bool SelectPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops, bool isInbound);
+			bool SelectExplicitPeers (std::vector<std::shared_ptr<const i2p::data::RouterInfo> >& hops, bool isInbound);			
 
 		private:
 
 			i2p::garlic::GarlicDestination * m_LocalDestination;
 			int m_NumInboundHops, m_NumOutboundHops, m_NumInboundTunnels, m_NumOutboundTunnels;
+			std::shared_ptr<std::vector<i2p::data::IdentHash> > m_ExplicitPeers;	
 			mutable std::mutex m_InboundTunnelsMutex;
 			std::set<std::shared_ptr<InboundTunnel>, TunnelCreationTimeCmp> m_InboundTunnels; // recent tunnel appears first
 			mutable std::mutex m_OutboundTunnelsMutex;