support zero-hops tunnels for destinations

Tunnel.cpp

@@ -768,6 +768,22 @@ namespace tunnel
 		return newTunnel;
 	}	
 
+	std::shared_ptr<InboundTunnel> Tunnels::CreateInboundTunnel (std::shared_ptr<TunnelConfig> config, std::shared_ptr<OutboundTunnel> outboundTunnel)
+	{
+		if (config->IsEmpty ())
+			return CreateZeroHopsInboundTunnel ();
+		else
+			return CreateTunnel<InboundTunnel>(config, outboundTunnel);
+	}
+
+	std::shared_ptr<OutboundTunnel> Tunnels::CreateOutboundTunnel (std::shared_ptr<TunnelConfig> config)
+	{
+		if (config->IsEmpty ())
+			return CreateZeroHopsOutboundTunnel ();
+		else	
+			return CreateTunnel<OutboundTunnel>(config);
+	}
+
 	void Tunnels::AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<InboundTunnel> tunnel)
 	{
 		m_PendingInboundTunnels[replyMsgID] = tunnel; 
@@ -815,20 +831,22 @@ namespace tunnel
 	}	
 
 	
-	void Tunnels::CreateZeroHopsInboundTunnel ()
+	std::shared_ptr<ZeroHopsInboundTunnel> Tunnels::CreateZeroHopsInboundTunnel ()
 	{
 		auto inboundTunnel = std::make_shared<ZeroHopsInboundTunnel> ();
 		inboundTunnel->SetState (eTunnelStateEstablished);
 		m_InboundTunnels.push_back (inboundTunnel);
 		m_Tunnels[inboundTunnel->GetTunnelID ()] = inboundTunnel;
+		return inboundTunnel;
 	}	
 
-	void Tunnels::CreateZeroHopsOutboundTunnel ()
+	std::shared_ptr<ZeroHopsOutboundTunnel> Tunnels::CreateZeroHopsOutboundTunnel ()
 	{
 		auto outboundTunnel = std::make_shared<ZeroHopsOutboundTunnel> ();
 		outboundTunnel->SetState (eTunnelStateEstablished);
 		m_OutboundTunnels.push_back (outboundTunnel);
 		// we don't insert into m_Tunnels
+		return outboundTunnel;
 	}
 
 	int Tunnels::GetTransitTunnelsExpirationTimeout ()
@@ -861,12 +879,6 @@ namespace tunnel
 		// TODO: locking
 		return m_OutboundTunnels.size();
 	}
-
-#ifdef ANDROID_ARM7A
-    template std::shared_ptr<InboundTunnel> Tunnels::CreateTunnel<InboundTunnel>(std::shared_ptr<TunnelConfig>, std::shared_ptr<OutboundTunnel>);
-    template std::shared_ptr<OutboundTunnel> Tunnels::CreateTunnel<OutboundTunnel>(std::shared_ptr<TunnelConfig>, std::shared_ptr<OutboundTunnel>);
-#endif
-
 }
 }
 

Tunnel.h

@@ -176,10 +176,10 @@ namespace tunnel
 			void AddTransitTunnel (std::shared_ptr<TransitTunnel> tunnel);
 			void AddOutboundTunnel (std::shared_ptr<OutboundTunnel> newTunnel);
 			void AddInboundTunnel (std::shared_ptr<InboundTunnel> newTunnel);
+			std::shared_ptr<InboundTunnel> CreateInboundTunnel (std::shared_ptr<TunnelConfig> config, std::shared_ptr<OutboundTunnel> outboundTunnel);
+			std::shared_ptr<OutboundTunnel> CreateOutboundTunnel (std::shared_ptr<TunnelConfig> config);
 			void PostTunnelData (std::shared_ptr<I2NPMessage> msg);
 			void PostTunnelData (const std::vector<std::shared_ptr<I2NPMessage> >& msgs);
-			template<class TTunnel>
-			std::shared_ptr<TTunnel> CreateTunnel (std::shared_ptr<TunnelConfig> config, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
 			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<InboundTunnel> tunnel);
 			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> tunnel);
 			std::shared_ptr<TunnelPool> CreateTunnelPool (int numInboundHops, 
@@ -189,6 +189,9 @@ namespace tunnel
 			
 		private:
 		
+			template<class TTunnel>
+			std::shared_ptr<TTunnel> CreateTunnel (std::shared_ptr<TunnelConfig> config, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
+
 			template<class TTunnel>
 			std::shared_ptr<TTunnel> GetPendingTunnel (uint32_t replyMsgID, const std::map<uint32_t, std::shared_ptr<TTunnel> >& pendingTunnels);			
 
@@ -204,8 +207,8 @@ namespace tunnel
 			void ManagePendingTunnels (PendingTunnels& pendingTunnels);
 			void ManageTunnelPools ();
 			
-			void CreateZeroHopsInboundTunnel ();
-			void CreateZeroHopsOutboundTunnel ();			
+			std::shared_ptr<ZeroHopsInboundTunnel> CreateZeroHopsInboundTunnel ();
+			std::shared_ptr<ZeroHopsOutboundTunnel> CreateZeroHopsOutboundTunnel ();			
 
 		private:
 

TunnelConfig.h

@@ -159,6 +159,11 @@ namespace tunnel
 				return num;
 			}
 
+			bool IsEmpty () const
+			{
+				return !m_FirstHop;
+			}			
+
 			virtual bool IsInbound () const { return m_FirstHop->isGateway; }
 
 			virtual uint32_t GetTunnelID () const 

TunnelPool.cpp

@@ -329,8 +329,9 @@ namespace tunnel
 	bool TunnelPool::SelectPeers (std::vector<std::shared_ptr<const i2p::data::IdentityEx> >& peers, bool isInbound)
 	{
 		if (m_ExplicitPeers) return SelectExplicitPeers (peers, isInbound);
-		auto prevHop = i2p::context.GetSharedRouterInfo ();	
 		int numHops = isInbound ? m_NumInboundHops : m_NumOutboundHops;
+		if (numHops <= 0) return true; // peers is empty 
+		auto prevHop = i2p::context.GetSharedRouterInfo ();			
 		if (i2p::transport::transports.GetNumPeers () > 25)
 		{
 			auto r = i2p::transport::transports.GetRandomPeer ();
@@ -390,8 +391,10 @@ namespace tunnel
 		if (SelectPeers (peers, true))
 		{
 			std::reverse (peers.begin (), peers.end ());	
-			auto tunnel = tunnels.CreateTunnel<InboundTunnel> (std::make_shared<TunnelConfig> (peers), outboundTunnel);
+			auto tunnel = tunnels.CreateInboundTunnel (std::make_shared<TunnelConfig> (peers), outboundTunnel);
 			tunnel->SetTunnelPool (shared_from_this ());
+			if (tunnel->IsEstablished ()) // zero hops
+				TunnelCreated (tunnel);
 		}	
 		else
 			LogPrint (eLogError, "Tunnels: Can't create inbound tunnel, no peers available");
@@ -403,8 +406,10 @@ namespace tunnel
 		if (!outboundTunnel)
 			outboundTunnel = tunnels.GetNextOutboundTunnel ();
 		LogPrint (eLogDebug, "Tunnels: Re-creating destination inbound tunnel...");
-		auto newTunnel = tunnels.CreateTunnel<InboundTunnel> (std::make_shared<TunnelConfig>(tunnel->GetPeers ()), outboundTunnel);
+		auto newTunnel = tunnels.CreateInboundTunnel (std::make_shared<TunnelConfig>(tunnel->GetPeers ()), outboundTunnel);
 		newTunnel->SetTunnelPool (shared_from_this());
+		if (newTunnel->IsEstablished ()) // zero hops
+			TunnelCreated (newTunnel);
 	}	
 		
 	void TunnelPool::CreateOutboundTunnel ()
@@ -418,9 +423,11 @@ namespace tunnel
 			std::vector<std::shared_ptr<const i2p::data::IdentityEx> > peers;
 			if (SelectPeers (peers, false))
 			{	
-				auto tunnel = tunnels.CreateTunnel<OutboundTunnel> (
+				auto tunnel = tunnels.CreateOutboundTunnel (
 					std::make_shared<TunnelConfig> (peers, inboundTunnel->GetNextTunnelID (), inboundTunnel->GetNextIdentHash ()));
 				tunnel->SetTunnelPool (shared_from_this ());
+				if (tunnel->IsEstablished ()) // zero hops
+					TunnelCreated (tunnel);
 			}	
 			else
 				LogPrint (eLogError, "Tunnels: Can't create outbound tunnel, no peers available");
@@ -437,10 +444,12 @@ namespace tunnel
 		if (inboundTunnel)
 		{	
 			LogPrint (eLogDebug, "Tunnels: Re-creating destination outbound tunnel...");
-			auto newTunnel = tunnels.CreateTunnel<OutboundTunnel> (
+			auto newTunnel = tunnels.CreateOutboundTunnel (
 				std::make_shared<TunnelConfig> (tunnel->GetPeers (),
 					inboundTunnel->GetNextTunnelID (), inboundTunnel->GetNextIdentHash ()));
 			newTunnel->SetTunnelPool (shared_from_this ());
+			if (newTunnel->IsEstablished ()) // zero hops
+				TunnelCreated (newTunnel);
 		}	
 		else
 			LogPrint (eLogDebug, "Tunnels: Can't re-create outbound tunnel, no inbound tunnels found");
@@ -449,7 +458,7 @@ namespace tunnel
 	void TunnelPool::CreatePairedInboundTunnel (std::shared_ptr<OutboundTunnel> outboundTunnel)
 	{
 		LogPrint (eLogDebug, "Tunnels: Creating paired inbound tunnel...");
-		auto tunnel = tunnels.CreateTunnel<InboundTunnel> (std::make_shared<TunnelConfig>(outboundTunnel->GetInvertedPeers ()), outboundTunnel);
+		auto tunnel = tunnels.CreateInboundTunnel (std::make_shared<TunnelConfig>(outboundTunnel->GetInvertedPeers ()), outboundTunnel);
 		tunnel->SetTunnelPool (shared_from_this ());
 	}	
 }