common tunnels' hash table

HTTPServer.cpp

@@ -619,13 +619,13 @@ namespace util
 		s << "<b>Transit tunnels:</b><br>\r\n<br>\r\n";
 		for (auto it: i2p::tunnel::tunnels.GetTransitTunnels ())
 		{
-			if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelGateway>(it.second))
+			if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelGateway>(it))
-				s << it.second->GetTunnelID () << " ⇒ ";
+				s << it->GetTunnelID () << " ⇒ ";
-			else if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelEndpoint>(it.second))
+			else if (std::dynamic_pointer_cast<i2p::tunnel::TransitTunnelEndpoint>(it))
-				s << " ⇒ " << it.second->GetTunnelID ();
+				s << " ⇒ " << it->GetTunnelID ();
 			else
-				s << " ⇒ " << it.second->GetTunnelID () << " ⇒ ";
+				s << " ⇒ " << it->GetTunnelID () << " ⇒ ";
-			s << " " << it.second->GetNumTransmittedBytes () << "<br>\r\n";
+			s << " " << it->GetNumTransmittedBytes () << "<br>\r\n";
 		}
 	}
 

Tunnel.cpp

@@ -266,15 +266,15 @@ namespace tunnel
 			return it->second;
 		return nullptr;
 	}	
-	
+
-	std::shared_ptr<TransitTunnel> Tunnels::GetTransitTunnel (uint32_t tunnelID)
+	std::shared_ptr<TunnelBase> Tunnels::GetTunnel (uint32_t tunnelID)
 	{
-		auto it = m_TransitTunnels.find(tunnelID);
+		auto it = m_Tunnels.find(tunnelID);
-		if (it != m_TransitTunnels.end ())
+		if (it != m_Tunnels.end ())
 			return it->second;
 		return nullptr;
 	}	
-	
+		
 	std::shared_ptr<InboundTunnel> Tunnels::GetPendingInboundTunnel (uint32_t replyMsgID)
 	{
 		return GetPendingTunnel (replyMsgID, m_PendingInboundTunnels);	
@@ -362,9 +362,10 @@ namespace tunnel
 		
 	void Tunnels::AddTransitTunnel (std::shared_ptr<TransitTunnel> tunnel)
 	{
-		std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
+		if (m_Tunnels.emplace (tunnel->GetTunnelID (), tunnel).second)
-		if (!m_TransitTunnels.insert (std::make_pair (tunnel->GetTunnelID (), tunnel)).second)
+			m_TransitTunnels.push_back (tunnel);
-			LogPrint (eLogError, "Tunnel: transit tunnel with id ", tunnel->GetTunnelID (), " already exists");
+		else
+			LogPrint (eLogError, "Tunnel: tunnel with id ", tunnel->GetTunnelID (), " already exists");
 	}	
 
 	void Tunnels::Start ()
@@ -414,10 +415,8 @@ namespace tunnel
 								else if (prevTunnel)
 									prevTunnel->FlushTunnelDataMsgs (); 
 						
-								if (!tunnel && typeID == eI2NPTunnelData)
-									tunnel = GetInboundTunnel (tunnelID);
 								if (!tunnel)
-									tunnel = GetTransitTunnel (tunnelID);
+									tunnel = GetTunnel (tunnelID);
 								if (tunnel)
 								{
 									if (typeID == eI2NPTunnelData)
@@ -574,6 +573,7 @@ namespace tunnel
 					auto pool = tunnel->GetTunnelPool ();
 					if (pool)
 						pool->TunnelExpired (tunnel);
+					// we don't have outbound tunnels in m_Tunnels
 					it = m_OutboundTunnels.erase (it);
 				}	
 				else 
@@ -622,6 +622,7 @@ namespace tunnel
 					auto pool = tunnel->GetTunnelPool ();
 					if (pool)
 						pool->TunnelExpired (tunnel);
+					m_Tunnels.erase (tunnel->GetTunnelID ());
 					it = m_InboundTunnels.erase (it);
 				}	
 				else 
@@ -676,14 +677,12 @@ namespace tunnel
 		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
 		for (auto it = m_TransitTunnels.begin (); it != m_TransitTunnels.end ();)
 		{
-			if (ts > it->second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
+			auto tunnel = *it;
+			if (ts > tunnel->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT)
 			{
-				auto tmp = it->second;
+				LogPrint (eLogDebug, "Tunnel: Transit tunnel with id ", tunnel->GetTunnelID (), " expired");
-				LogPrint (eLogDebug, "Tunnel: Transit tunnel with id ", tmp->GetTunnelID (), " expired");
+				m_Tunnels.erase (tunnel->GetTunnelID ());
-				{
+				it = m_TransitTunnels.erase (it);
-					std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
-					it = m_TransitTunnels.erase (it);
-				}	
 			}	
 			else 
 				it++;
@@ -737,6 +736,7 @@ namespace tunnel
 
 	void Tunnels::AddOutboundTunnel (std::shared_ptr<OutboundTunnel> newTunnel)
 	{
+		// we don't need to insert it to m_Tunnels
 		m_OutboundTunnels.push_back (newTunnel);
 		auto pool = newTunnel->GetTunnelPool ();
 		if (pool && pool->IsActive ())
@@ -747,22 +747,27 @@ namespace tunnel
 
 	void Tunnels::AddInboundTunnel (std::shared_ptr<InboundTunnel> newTunnel)
 	{
-		m_InboundTunnels[newTunnel->GetTunnelID ()] = newTunnel;
+		if (m_Tunnels.emplace (newTunnel->GetTunnelID (), newTunnel).second)
-		auto pool = newTunnel->GetTunnelPool ();
+		{	
-		if (!pool)
+			m_InboundTunnels[newTunnel->GetTunnelID ()] = newTunnel;
-		{		
+			auto pool = newTunnel->GetTunnelPool ();
-			// build symmetric outbound tunnel
+			if (!pool)
-			CreateTunnel<OutboundTunnel> (std::make_shared<TunnelConfig>(newTunnel->GetInvertedPeers (),
+			{		
-					newTunnel->GetNextTunnelID (), newTunnel->GetNextIdentHash ()), 
+				// build symmetric outbound tunnel
-				GetNextOutboundTunnel ());		
+				CreateTunnel<OutboundTunnel> (std::make_shared<TunnelConfig>(newTunnel->GetInvertedPeers (),
+						newTunnel->GetNextTunnelID (), newTunnel->GetNextIdentHash ()), 
+					GetNextOutboundTunnel ());		
+			}
+			else
+			{
+				if (pool->IsActive ())
+					pool->TunnelCreated (newTunnel);
+				else
+					newTunnel->SetTunnelPool (nullptr);
+			}
 		}
 		else
-		{
+			LogPrint (eLogError, "Tunnel: tunnel with id ", newTunnel->GetTunnelID (), " already exists");
-			if (pool->IsActive ())
-				pool->TunnelCreated (newTunnel);
-			else
-				newTunnel->SetTunnelPool (nullptr);
-		}	
 	}	
 
 	
@@ -779,10 +784,10 @@ namespace tunnel
 	{
 		int timeout = 0;
 		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
-		std::unique_lock<std::mutex> l(m_TransitTunnelsMutex);
+		// TODO: possible race condition with I2PControl
 		for (auto it: m_TransitTunnels)
 		{
-			int t = it.second->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT - ts;
+			int t = it->GetCreationTime () + TUNNEL_EXPIRATION_TIMEOUT - ts;
 			if (t > timeout) timeout = t;
 		}	
 		return timeout;

Tunnel.h

@@ -3,6 +3,7 @@
 
 #include <inttypes.h>
 #include <map>
+#include <unordered_map>
 #include <list>
 #include <vector>
 #include <string>
@@ -142,7 +143,7 @@ namespace tunnel
 			std::shared_ptr<InboundTunnel> GetNextInboundTunnel ();
 			std::shared_ptr<OutboundTunnel> GetNextOutboundTunnel ();
 			std::shared_ptr<TunnelPool> GetExploratoryPool () const { return m_ExploratoryPool; };
-			std::shared_ptr<TransitTunnel> GetTransitTunnel (uint32_t tunnelID);
+			std::shared_ptr<TunnelBase> GetTunnel (uint32_t tunnelID);
 			int GetTransitTunnelsExpirationTimeout ();
 			void AddTransitTunnel (std::shared_ptr<TransitTunnel> tunnel);
 			void AddOutboundTunnel (std::shared_ptr<OutboundTunnel> newTunnel);
@@ -185,8 +186,8 @@ namespace tunnel
 			std::map<uint32_t, std::shared_ptr<OutboundTunnel> > m_PendingOutboundTunnels; // by replyMsgID
 			std::map<uint32_t, std::shared_ptr<InboundTunnel> > m_InboundTunnels;
 			std::list<std::shared_ptr<OutboundTunnel> > m_OutboundTunnels;
-			std::mutex m_TransitTunnelsMutex;
+			std::list<std::shared_ptr<TransitTunnel> > m_TransitTunnels;
-			std::map<uint32_t, std::shared_ptr<TransitTunnel> > m_TransitTunnels;
+			std::unordered_map<uint32_t, std::shared_ptr<TunnelBase> > m_Tunnels; // tunnelID->tunnel known by this id
 			std::mutex m_PoolsMutex;
 			std::list<std::shared_ptr<TunnelPool>> m_Pools;
 			std::shared_ptr<TunnelPool> m_ExploratoryPool;