store DatagramSession for bulk

libi2pd/Datagram.cpp

@@ -34,31 +34,48 @@ namespace datagram
 
 	void DatagramDestination::SendDatagramTo(const uint8_t * payload, size_t len, const i2p::data::IdentHash & identity, uint16_t fromPort, uint16_t toPort)
 	{
-		if (m_Owner->GetIdentity ()->GetSigningKeyType () == i2p::data::SIGNING_KEY_TYPE_DSA_SHA1)
+		SendDatagram (ObtainSession(identity), payload, len, fromPort, toPort);
+	}
+
+	void DatagramDestination::SendRawDatagramTo(const uint8_t * payload, size_t len, const i2p::data::IdentHash & identity, uint16_t fromPort, uint16_t toPort)
+	{
+		SendRawDatagram (ObtainSession(identity), payload, len, fromPort, toPort);
+	}
+
+	std::shared_ptr<DatagramSession> DatagramDestination::GetSession(const i2p::data::IdentHash & ident)
+	{
+		return ObtainSession(ident);
+	}	
+		
+	void DatagramDestination::SendDatagram (std::shared_ptr<DatagramSession> session, const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort)
+	{
+		if (session)
 		{
-			uint8_t hash[32];
+			if (m_Owner->GetIdentity ()->GetSigningKeyType () == i2p::data::SIGNING_KEY_TYPE_DSA_SHA1)
-			SHA256(payload, len, hash);
+			{
-			m_Owner->Sign (hash, 32, m_Signature.data ());
+				uint8_t hash[32];
-		}
+				SHA256(payload, len, hash);
-		else
+				m_Owner->Sign (hash, 32, m_Signature.data ());
-			m_Owner->Sign (payload, len, m_Signature.data ());
+			}
+			else
+				m_Owner->Sign (payload, len, m_Signature.data ());
 
-		auto session = ObtainSession(identity);
+			auto msg = CreateDataMessage ({{m_From.data (), m_From.size ()}, {m_Signature.data (), m_Signature.size ()}, {payload, len}},
-		auto msg = CreateDataMessage ({{m_From.data (), m_From.size ()}, {m_Signature.data (), m_Signature.size ()}, {payload, len}},
+				fromPort, toPort, false, !session->IsRatchets ()); // datagram
-			fromPort, toPort, false, !session->IsRatchets ()); // datagram
+			session->SendMsg(msg);
-		session->SendMsg(msg);
+		}	
 	}	
 
-	void DatagramDestination::SendRawDatagramTo(const uint8_t * payload, size_t len, const i2p::data::IdentHash & identity, uint16_t fromPort, uint16_t toPort)
+	void DatagramDestination::SendRawDatagram (std::shared_ptr<DatagramSession> session, const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort)
 	{
-		auto session = ObtainSession(identity);
+		if (session)
-		auto msg = CreateDataMessage ({{payload, len}}, fromPort, toPort, true, !session->IsRatchets ()); // raw
+			session->SendMsg(CreateDataMessage ({{payload, len}}, fromPort, toPort, true, !session->IsRatchets ())); // raw
-		session->SendMsg(msg);
 	}
 		
-	void DatagramDestination::FlushSendQueue (const i2p::data::IdentHash & ident)
+	void DatagramDestination::FlushSendQueue (std::shared_ptr<DatagramSession> session)
 	{
-		 ObtainSession(ident)->FlushSendQueue ();
+		if (session)
+			session->FlushSendQueue ();
 	}	
 		
 	void DatagramDestination::HandleDatagram (uint16_t fromPort, uint16_t toPort,uint8_t * const &buf, size_t len)

libi2pd/Datagram.h

@@ -122,7 +122,12 @@ namespace datagram
 
 			void SendDatagramTo (const uint8_t * payload, size_t len, const i2p::data::IdentHash & ident, uint16_t fromPort = 0, uint16_t toPort = 0);
 			void SendRawDatagramTo (const uint8_t * payload, size_t len, const i2p::data::IdentHash & ident, uint16_t fromPort = 0, uint16_t toPort = 0);
-			void FlushSendQueue (const i2p::data::IdentHash & ident);
+			
+			std::shared_ptr<DatagramSession> GetSession(const i2p::data::IdentHash & ident);
+			void SendDatagram (std::shared_ptr<DatagramSession> session, const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort);
+			void SendRawDatagram (std::shared_ptr<DatagramSession> session, const uint8_t * payload, size_t len, uint16_t fromPort, uint16_t toPort);
+			void FlushSendQueue (std::shared_ptr<DatagramSession> session);
+			
 			void HandleDataMessagePayload (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len, bool isRaw = false);
 
 			void SetReceiver (const Receiver& receiver) { m_Receiver = receiver; };

libi2pd_client/I2PTunnel.cpp

@@ -810,7 +810,8 @@ namespace client
 		}	
 		// send off to remote i2p destination
 		LogPrint(eLogDebug, "UDP Client: send ", transferred, " to ", m_RemoteIdent->ToBase32(), ":", RemotePort);
-		m_LocalDest->GetDatagramDestination()->SendDatagramTo(m_RecvBuff, transferred, *m_RemoteIdent, remotePort, RemotePort);
+		auto session = m_LocalDest->GetDatagramDestination()->GetSession (*m_RemoteIdent);
+		m_LocalDest->GetDatagramDestination()->SendDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
 		size_t numPackets = 0;
 		while (numPackets < i2p::datagram::DATAGRAM_SEND_QUEUE_MAX_SIZE)
 		{	
@@ -820,14 +821,12 @@ namespace client
 			transferred = m_LocalSocket.receive_from (boost::asio::buffer (m_RecvBuff, I2P_UDP_MAX_MTU), m_RecvEndpoint, 0, ec);
 			remotePort = m_RecvEndpoint.port();
 			// TODO: check remotePort
-			m_LocalDest->GetDatagramDestination()->SendDatagramTo(m_RecvBuff, transferred, *m_RemoteIdent, remotePort, RemotePort);			
+			m_LocalDest->GetDatagramDestination()->SendDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);			
 			numPackets++;
 		}	
 		if (numPackets)
-		{	
 			LogPrint(eLogDebug, "UDP Client: sent ", numPackets, " more packets to ", m_RemoteIdent->ToBase32());
-			m_LocalDest->GetDatagramDestination()->FlushSendQueue (*m_RemoteIdent);
+		m_LocalDest->GetDatagramDestination()->FlushSendQueue (session);
-		}	
 		
 		// mark convo as active
 		if (m_LastSession)