Update tx.cpp

dujeonglee · web-flow · commit afa664d992f5 · 2017-06-29T17:13:18.000+09:00
Support IPv6
diff --git a/tx.cpp b/tx.cpp
@@ -29,12 +29,12 @@ TransmissionBlock::~TransmissionBlock()
 }
 
 
-const u16 TransmissionBlock::AckIndex()
+const uint16_t TransmissionBlock::AckIndex()
 {
     return m_BlockSequenceNumber%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2);
 }
 
-bool TransmissionBlock::Send(u08* buffer, u16 buffersize)
+bool TransmissionBlock::Send(uint8_t* buffer, uint16_t buffersize)
 {
     if(p_Session->m_IsConnected == false)
     {
@@ -47,7 +47,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)
 #if ENABLE_CRITICAL_EXCEPTIONS
         TEST_EXCEPTION(std::bad_alloc());
 #endif
-        m_OriginalPacketBuffer.emplace_back(std::unique_ptr<u08[]>(new u08[sizeof(Header::Data) + (m_BlockSize - 1) + buffersize]));
+        m_OriginalPacketBuffer.emplace_back(std::unique_ptr<uint8_t[]>(new uint8_t[sizeof(Header::Data) + (m_BlockSize - 1) + buffersize]));
     }
     catch(const std::bad_alloc& ex)
     {
@@ -77,7 +77,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)
         m_LargestOriginalPacketSize = buffersize;
     }
     DataHeader->m_LastIndicator = 1;/* This field is reserved to support fragmentation */
-    for(u08 i = 0 ; i < m_BlockSize ; i++)
+    for(uint8_t i = 0 ; i < m_BlockSize ; i++)
     {
         if(i != m_TransmissionCount)
         {
@@ -89,11 +89,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)
         }
     }
     memcpy(DataHeader->m_Codes + m_BlockSize, buffer, buffersize);
-    sockaddr_in RemoteAddress = {0};
-    RemoteAddress.sin_family = AF_INET;
-    RemoteAddress.sin_addr.s_addr = p_Session->c_IPv4;
-    RemoteAddress.sin_port = p_Session->c_Port;
-    sendto(p_Session->c_Socket, m_OriginalPacketBuffer[m_TransmissionCount++].get(), ntohs(DataHeader->m_TotalSize), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress));
+    sendto(p_Session->c_Socket, m_OriginalPacketBuffer[m_TransmissionCount++].get(), ntohs(DataHeader->m_TotalSize), 0, (sockaddr*)&p_Session->c_Addr.Addr, p_Session->c_Addr.AddrLength);
 
     if((m_TransmissionCount == m_BlockSize)/* || reqack == true*/)
     {
@@ -110,7 +106,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)
 
 void TransmissionBlock::Retransmission()
 {
-    const u08 c_AckIndex = AckIndex();
+    const uint8_t c_AckIndex = AckIndex();
     if(m_TransmissionMode == Parameter::BEST_EFFORT_TRANSMISSION_MODE)
     {
         if(m_TransmissionCount >= m_OriginalPacketBuffer.size() + m_RetransmissionRedundancy)
@@ -120,7 +116,7 @@ void TransmissionBlock::Retransmission()
     }
     if(p_Session->m_AckList[c_AckIndex] == true)
     {
-        for(u16 i = p_Session->m_MinBlockSequenceNumber ; i != p_Session->m_MaxBlockSequenceNumber ; i++)
+        for(uint16_t i = p_Session->m_MinBlockSequenceNumber ; i != p_Session->m_MaxBlockSequenceNumber ; i++)
         {
             if(p_Session->m_AckList[i%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2)] == true)
             {
@@ -139,13 +135,8 @@ void TransmissionBlock::Retransmission()
         delete this;
         return;
     }
-    sockaddr_in RemoteAddress = {0};
-    RemoteAddress.sin_family = AF_INET;
-    RemoteAddress.sin_addr.s_addr = p_Session->c_IPv4;
-    RemoteAddress.sin_port = p_Session->c_Port;
-
     {
-        std::vector<u08> RandomCoefficients;
+        std::vector<uint8_t> RandomCoefficients;
         Header::Data* RemedyHeader = reinterpret_cast<Header::Data*>(m_RemedyPacketBuffer);
         if(m_OriginalPacketBuffer.size() == 1)
         {
@@ -168,7 +159,7 @@ void TransmissionBlock::Retransmission()
         }
         else
         {
-            for(u08 Coef = 0 ; Coef < m_OriginalPacketBuffer.size() ; Coef++)
+            for(uint8_t Coef = 0 ; Coef < m_OriginalPacketBuffer.size() ; Coef++)
             {
                 do
                 {
@@ -198,18 +189,18 @@ void TransmissionBlock::Retransmission()
         RemedyHeader->m_MaximumRank = m_BlockSize;
         RemedyHeader->m_Flags = Header::Data::FLAGS_END_OF_BLK;
         RemedyHeader->m_TxCount = ++m_TransmissionCount;
-        for(u08 PacketIndex = 0 ; PacketIndex < m_OriginalPacketBuffer.size() ; PacketIndex++)
+        for(uint8_t PacketIndex = 0 ; PacketIndex < m_OriginalPacketBuffer.size() ; PacketIndex++)
         {
-            u08* OriginalBuffer = reinterpret_cast<u08*>(m_OriginalPacketBuffer[PacketIndex].get());
+            uint8_t* OriginalBuffer = reinterpret_cast<uint8_t*>(m_OriginalPacketBuffer[PacketIndex].get());
             Header::Data* OriginalHeader = reinterpret_cast<Header::Data*>(OriginalBuffer);
-            const u16 length = ntohs(OriginalHeader->m_TotalSize);
+            const uint16_t length = ntohs(OriginalHeader->m_TotalSize);
 #if 0
-            for(u16 CodingOffset = Header::Data::OffSets::CodingOffset ; CodingOffset < length ; CodingOffset++)
+            for(uint16_t CodingOffset = Header::Data::OffSets::CodingOffset ; CodingOffset < length ; CodingOffset++)
             {
                 m_RemedyPacketBuffer[CodingOffset] ^= FiniteField::instance()->mul(OriginalBuffer[CodingOffset], RandomCoefficients[PacketIndex]);
             }
 #else
-            u16 CodingOffset = Header::Data::OffSets::CodingOffset;
+            uint16_t CodingOffset = Header::Data::OffSets::CodingOffset;
             while(CodingOffset < length)
             {
                 /*if(length - CodingOffset > 1024)
@@ -262,7 +253,7 @@ void TransmissionBlock::Retransmission()
             }
 #endif
         }
-        sendto(p_Session->c_Socket, m_RemedyPacketBuffer, ntohs(RemedyHeader->m_TotalSize), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress));
+        sendto(p_Session->c_Socket, m_RemedyPacketBuffer, ntohs(RemedyHeader->m_TotalSize), 0, (sockaddr*)&p_Session->c_Addr.Addr, p_Session->c_Addr.AddrLength);
     }
     while(p_Session->m_IsConnected && p_Session->m_Timer.ScheduleTask(p_Session->m_RetransmissionInterval, [this](){
         const auto Priority = (p_Session->m_MinBlockSequenceNumber == m_BlockSequenceNumber?TransmissionSession::MIDDLE_PRIORITY:TransmissionSession::LOW_PRIORITY);
@@ -275,7 +266,7 @@ void TransmissionBlock::Retransmission()
 ////////////////////////////////////////////////////////////
 /////////////// TransmissionSession
 /*OK*/
-TransmissionSession::TransmissionSession(Transmission* const transmission, s32 Socket, u32 IPv4, u16 Port, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, u16 RetransmissionRedundancy): c_Transmission(transmission), c_Socket(Socket),c_IPv4(IPv4), c_Port(Port)
+TransmissionSession::TransmissionSession(Transmission* const transmission, int32_t Socket, const DataStructures::AddressType Addr, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, uint16_t RetransmissionRedundancy): c_Transmission(transmission), c_Socket(Socket), c_Addr(Addr)
 {
     m_TransmissionMode = TransmissionMode;
     m_BlockSize = BlockSize;
@@ -284,11 +275,12 @@ TransmissionSession::TransmissionSession(Transmission* const transmission, s32 S
     m_MinBlockSequenceNumber = 0;
     m_MaxBlockSequenceNumber = 0;
     p_TransmissionBlock = nullptr;
-    for(u32 i = 0 ; i < (Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2) ; i++)
+    for(uint32_t i = 0 ; i < (Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2) ; i++)
     {
         m_AckList[i] = true;
     }
     m_ConcurrentRetransmissions = 0;
+    m_IsConnected = false;
 }
 
 
@@ -318,7 +310,7 @@ void TransmissionSession::ChangeBlockSize(const Parameter::BLOCK_SIZE BlockSize)
 }
 
 /*OK*/
-void TransmissionSession::ChangeRetransmissionRedundancy(const u16 RetransmissionRedundancy)
+void TransmissionSession::ChangeRetransmissionRedundancy(const uint16_t RetransmissionRedundancy)
 {
     m_TaskQueue.Enqueue([this, RetransmissionRedundancy]()
     {
@@ -327,7 +319,7 @@ void TransmissionSession::ChangeRetransmissionRedundancy(const u16 Retransmissio
 }
 
 /*OK*/
-void TransmissionSession::ChangeSessionParameter(const Parameter::TRANSMISSION_MODE TransmissionMode, const Parameter::BLOCK_SIZE BlockSize, const u16 RetransmissionRedundancy)
+void TransmissionSession::ChangeSessionParameter(const Parameter::TRANSMISSION_MODE TransmissionMode, const Parameter::BLOCK_SIZE BlockSize, const uint16_t RetransmissionRedundancy)
 {
     m_TaskQueue.Enqueue([this, TransmissionMode, BlockSize, RetransmissionRedundancy]()
     {
@@ -351,25 +343,21 @@ void TransmissionSession::SendPing()
         TransmissionSession const * self = this;
         std::cout<<"Pong Timeout...Client is disconnected.["<<TimeSinceLastPongTime.count()<<"]"<<std::endl;
         std::thread DisconnectThread = std::thread([self](){
-            self->c_Transmission->Disconnect(self->c_IPv4, self->c_Port);
+            //self->c_Transmission->Disconnect(self->c_IPv4, self->c_Port);
         });
         DisconnectThread.detach();
         return;
     }
 
-    sockaddr_in RemoteAddress = {0};
-    RemoteAddress.sin_family = AF_INET;
-    RemoteAddress.sin_addr.s_addr = c_IPv4;
-    RemoteAddress.sin_port = c_Port;
-    sendto(c_Socket, reinterpret_cast<u08*>(&ping), sizeof(Header::Ping), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress));
+    sendto(c_Socket, reinterpret_cast<uint8_t*>(&ping), sizeof(Header::Ping), 0, (sockaddr*)&c_Addr.Addr, c_Addr.AddrLength);
     while(m_IsConnected && m_Timer.ScheduleTask(Parameter::PING_INTERVAL, [this](){
         while(m_IsConnected && m_TaskQueue.Enqueue([this](){
             SendPing();
         }, TransmissionSession::HIGH_PRIORITY)==false);
     })==false);
 }
 
-void TransmissionSession::UpdateRetransmissionInterval(const u16 rtt)
+void TransmissionSession::UpdateRetransmissionInterval(const uint16_t rtt)
 {
     m_TaskQueue.Enqueue([this, rtt]()
     {
@@ -380,7 +368,7 @@ void TransmissionSession::UpdateRetransmissionInterval(const u16 rtt)
 ////////////////////////////////////////////////////////////
 /////////////// Transmission
 /* OK */
-Transmission::Transmission(s32 Socket) : c_Socket(Socket){}
+Transmission::Transmission(int32_t Socket) : c_Socket(Socket){}
 
 /* OK */
 Transmission::~Transmission()
@@ -390,12 +378,12 @@ Transmission::~Transmission()
 }
 
 /* OK */
-bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, u16 RetransmissionRedundancy)
+bool Transmission::Connect(const DataStructures::AddressType Addr, uint32_t ConnectionTimeout, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, uint16_t RetransmissionRedundancy)
 {
     TransmissionSession* newsession = nullptr;
     {
         std::unique_lock< std::mutex > lock(m_Lock);
-        const DataStructures::IPv4PortKey key = {IPv4, Port};
+        const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);
         TransmissionSession** const session = m_Sessions.GetPtr(key);
         if(session != nullptr)
         {
@@ -406,7 +394,7 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:
             try
             {
                 TEST_EXCEPTION(std::bad_alloc());
-                newsession = new TransmissionSession(this, c_Socket, IPv4, Port, TransmissionMode, BlockSize, RetransmissionRedundancy);
+                newsession = new TransmissionSession(this, c_Socket, Addr, TransmissionMode, BlockSize, RetransmissionRedundancy);
             }
             catch(const std::bad_alloc& ex)
             {
@@ -429,11 +417,7 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:
     SyncPacket.m_Type = Header::Common::HeaderType::SYNC;
     SyncPacket.m_Sequence = htons(newsession->m_MaxBlockSequenceNumber);
 
-    sockaddr_in RemoteAddress = {0};
-    RemoteAddress.sin_family = AF_INET;
-    RemoteAddress.sin_addr.s_addr = newsession->c_IPv4;
-    RemoteAddress.sin_port = newsession->c_Port;
-    if(sendto(c_Socket, (u08*)&SyncPacket, sizeof(SyncPacket), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress)) != sizeof(SyncPacket))
+    if(sendto(c_Socket, (uint8_t*)&SyncPacket, sizeof(SyncPacket), 0, (sockaddr*)(&newsession->c_Addr.Addr), newsession->c_Addr.AddrLength) != sizeof(SyncPacket))
     {
         return false;
     }
@@ -456,12 +440,12 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:
 }
 
 /* OK */
-bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)
+bool Transmission::Send(const DataStructures::AddressType Addr, uint8_t* buffer, uint16_t buffersize)
 {
     TransmissionSession* p_session = nullptr;
     {
         std::unique_lock< std::mutex > lock(m_Lock);
-        const DataStructures::IPv4PortKey key = {IPv4, Port};
+        const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);
         TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
         if(pp_session)
         {
@@ -480,7 +464,7 @@ bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)
     std::atomic<bool> TransmissionIsCompleted(false);
     std::atomic<bool> TransmissionResult(false);
     while(p_session->m_ConcurrentRetransmissions >= Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION ||
-          (u16)(p_session->m_MaxBlockSequenceNumber - p_session->m_MinBlockSequenceNumber) >= (u16)Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION)
+          (uint16_t)(p_session->m_MaxBlockSequenceNumber - p_session->m_MinBlockSequenceNumber) >= (uint16_t)Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION)
     {
         if(!p_session->m_IsConnected)
         {
@@ -531,12 +515,12 @@ bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)
     return TransmissionResult;
 }
 
-bool Transmission::Flush(u32 IPv4, u16 Port)
+bool Transmission::Flush(const DataStructures::AddressType Addr)
 {
     TransmissionSession* p_session = nullptr;
     {
         std::unique_lock< std::mutex > lock(m_Lock);
-        const DataStructures::IPv4PortKey key = {IPv4, Port};
+        const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);
         TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
         if(pp_session)
         {
@@ -561,12 +545,12 @@ bool Transmission::Flush(u32 IPv4, u16 Port)
     }, TransmissionSession::LOW_PRIORITY);
 }
 
-void Transmission::WaitUntilTxIsCompleted(u32 IPv4, u16 Port)
+void Transmission::WaitUntilTxIsCompleted(const DataStructures::AddressType Addr)
 {
     TransmissionSession* p_session = nullptr;
     {
         std::unique_lock< std::mutex > lock(m_Lock);
-        const DataStructures::IPv4PortKey key = {IPv4, Port};
+        const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);
         TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
         if(pp_session)
         {
@@ -587,9 +571,9 @@ void Transmission::WaitUntilTxIsCompleted(u32 IPv4, u16 Port)
 	}
 }
 
-bool Transmission::Disconnect(u32 IPv4, u16 Port)
+bool Transmission::Disconnect(const DataStructures::AddressType Addr)
 {
-    const DataStructures::IPv4PortKey key = {IPv4, Port};
+    const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);
     TransmissionSession** pp_session = nullptr;
     {
         std::unique_lock< std::mutex > lock(m_Lock);
@@ -617,22 +601,22 @@ bool Transmission::Disconnect(u32 IPv4, u16 Port)
 }
 
 /* OK */
-void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const sender_addr, const u32 sender_addr_len)
+void Transmission::RxHandler(uint8_t* buffer, uint16_t size, const sockaddr* const sender_addr, const uint32_t sender_addr_len)
 {
     Header::Common* CommonHeader = reinterpret_cast< Header::Common* >(buffer);
     switch(CommonHeader->m_Type)
     {
         case Header::Common::HeaderType::DATA_ACK:
         {
             const Header::DataAck* Ack = reinterpret_cast< Header::DataAck* >(buffer);
-            const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};
+            const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);
             std::unique_lock< std::mutex > lock(m_Lock);
             TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
             if(pp_session)
             {
                 TransmissionSession* const SessionAddress = (*pp_session);
-                u16 Sequence = ntohs(Ack->m_Sequence);
-                u08 Loss = Ack->m_Losses;
+                uint16_t Sequence = ntohs(Ack->m_Sequence);
+                uint8_t Loss = Ack->m_Losses;
                 (*pp_session)->m_TaskQueue.Enqueue([SessionAddress,Sequence,Loss](){
                     if(SessionAddress->m_AckList[Sequence%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2)] == true)
                     {
@@ -649,7 +633,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se
         case Header::Common::HeaderType::SYNC_ACK:
         {
             const Header::Sync* sync = reinterpret_cast< Header::Sync* >(buffer);
-            const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};
+            const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);
             std::unique_lock< std::mutex > lock(m_Lock);
             TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
             if(pp_session)
@@ -665,7 +649,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se
         case Header::Common::PONG:
         {
             const Header::Pong* pong = reinterpret_cast< Header::Pong* >(buffer);
-            const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};
+            const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);
             std::unique_lock< std::mutex > lock(m_Lock);
             TransmissionSession** const pp_session = m_Sessions.GetPtr(key);
             if(pp_session)
@@ -680,7 +664,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se
                 }
                 else
                 {
-                    (*pp_session)->UpdateRetransmissionInterval((u16)(rtt.count()*1000.));
+                    (*pp_session)->UpdateRetransmissionInterval((uint16_t)(rtt.count()*1000.));
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,12 @@ TransmissionBlock::~TransmissionBlock()`
`29`	`29`	`}`
`30`	`30`
`31`	`31`
`32`		`-const u16 TransmissionBlock::AckIndex()`
	`32`	`+const uint16_t TransmissionBlock::AckIndex()`
`33`	`33`	`{`
`34`	`34`	`return m_BlockSequenceNumber%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2);`
`35`	`35`	`}`
`36`	`36`
`37`		`-bool TransmissionBlock::Send(u08* buffer, u16 buffersize)`
	`37`	`+bool TransmissionBlock::Send(uint8_t* buffer, uint16_t buffersize)`
`38`	`38`	`{`
`39`	`39`	`if(p_Session->m_IsConnected == false)`
`40`	`40`	`{`
`@@ -47,7 +47,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)`
`47`	`47`	`#if ENABLE_CRITICAL_EXCEPTIONS`
`48`	`48`	`TEST_EXCEPTION(std::bad_alloc());`
`49`	`49`	`#endif`
`50`		`- m_OriginalPacketBuffer.emplace_back(std::unique_ptr<u08[]>(new u08[sizeof(Header::Data) + (m_BlockSize - 1) + buffersize]));`
	`50`	`+ m_OriginalPacketBuffer.emplace_back(std::unique_ptr<uint8_t[]>(new uint8_t[sizeof(Header::Data) + (m_BlockSize - 1) + buffersize]));`
`51`	`51`	`}`
`52`	`52`	`catch(const std::bad_alloc& ex)`
`53`	`53`	`{`
`@@ -77,7 +77,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)`
`77`	`77`	`m_LargestOriginalPacketSize = buffersize;`
`78`	`78`	`}`
`79`	`79`	`DataHeader->m_LastIndicator = 1;/* This field is reserved to support fragmentation */`
`80`		`- for(u08 i = 0 ; i < m_BlockSize ; i++)`
	`80`	`+ for(uint8_t i = 0 ; i < m_BlockSize ; i++)`
`81`	`81`	`{`
`82`	`82`	`if(i != m_TransmissionCount)`
`83`	`83`	`{`
`@@ -89,11 +89,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`memcpy(DataHeader->m_Codes + m_BlockSize, buffer, buffersize);`
`92`		`- sockaddr_in RemoteAddress = {0};`
`93`		`- RemoteAddress.sin_family = AF_INET;`
`94`		`- RemoteAddress.sin_addr.s_addr = p_Session->c_IPv4;`
`95`		`- RemoteAddress.sin_port = p_Session->c_Port;`
`96`		`- sendto(p_Session->c_Socket, m_OriginalPacketBuffer[m_TransmissionCount++].get(), ntohs(DataHeader->m_TotalSize), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress));`
	`92`	`+ sendto(p_Session->c_Socket, m_OriginalPacketBuffer[m_TransmissionCount++].get(), ntohs(DataHeader->m_TotalSize), 0, (sockaddr*)&p_Session->c_Addr.Addr, p_Session->c_Addr.AddrLength);`
`97`	`93`
`98`	`94`	`if((m_TransmissionCount == m_BlockSize)/* \|\| reqack == true*/)`
`99`	`95`	`{`
`@@ -110,7 +106,7 @@ bool TransmissionBlock::Send(u08* buffer, u16 buffersize)`
`110`	`106`
`111`	`107`	`void TransmissionBlock::Retransmission()`
`112`	`108`	`{`
`113`		`- const u08 c_AckIndex = AckIndex();`
	`109`	`+ const uint8_t c_AckIndex = AckIndex();`
`114`	`110`	`if(m_TransmissionMode == Parameter::BEST_EFFORT_TRANSMISSION_MODE)`
`115`	`111`	`{`
`116`	`112`	`if(m_TransmissionCount >= m_OriginalPacketBuffer.size() + m_RetransmissionRedundancy)`
`@@ -120,7 +116,7 @@ void TransmissionBlock::Retransmission()`
`120`	`116`	`}`
`121`	`117`	`if(p_Session->m_AckList[c_AckIndex] == true)`
`122`	`118`	`{`
`123`		`- for(u16 i = p_Session->m_MinBlockSequenceNumber ; i != p_Session->m_MaxBlockSequenceNumber ; i++)`
	`119`	`+ for(uint16_t i = p_Session->m_MinBlockSequenceNumber ; i != p_Session->m_MaxBlockSequenceNumber ; i++)`
`124`	`120`	`{`
`125`	`121`	`if(p_Session->m_AckList[i%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2)] == true)`
`126`	`122`	`{`
`@@ -139,13 +135,8 @@ void TransmissionBlock::Retransmission()`
`139`	`135`	`delete this;`
`140`	`136`	`return;`
`141`	`137`	`}`
`142`		`- sockaddr_in RemoteAddress = {0};`
`143`		`- RemoteAddress.sin_family = AF_INET;`
`144`		`- RemoteAddress.sin_addr.s_addr = p_Session->c_IPv4;`
`145`		`- RemoteAddress.sin_port = p_Session->c_Port;`
`146`		`-`
`147`	`138`	`{`
`148`		`- std::vector<u08> RandomCoefficients;`
	`139`	`+ std::vector<uint8_t> RandomCoefficients;`
`149`	`140`	`Header::Data* RemedyHeader = reinterpret_cast<Header::Data*>(m_RemedyPacketBuffer);`
`150`	`141`	`if(m_OriginalPacketBuffer.size() == 1)`
`151`	`142`	`{`
`@@ -168,7 +159,7 @@ void TransmissionBlock::Retransmission()`
`168`	`159`	`}`
`169`	`160`	`else`
`170`	`161`	`{`
`171`		`- for(u08 Coef = 0 ; Coef < m_OriginalPacketBuffer.size() ; Coef++)`
	`162`	`+ for(uint8_t Coef = 0 ; Coef < m_OriginalPacketBuffer.size() ; Coef++)`
`172`	`163`	`{`
`173`	`164`	`do`
`174`	`165`	`{`
`@@ -198,18 +189,18 @@ void TransmissionBlock::Retransmission()`
`198`	`189`	`RemedyHeader->m_MaximumRank = m_BlockSize;`
`199`	`190`	`RemedyHeader->m_Flags = Header::Data::FLAGS_END_OF_BLK;`
`200`	`191`	`RemedyHeader->m_TxCount = ++m_TransmissionCount;`
`201`		`- for(u08 PacketIndex = 0 ; PacketIndex < m_OriginalPacketBuffer.size() ; PacketIndex++)`
	`192`	`+ for(uint8_t PacketIndex = 0 ; PacketIndex < m_OriginalPacketBuffer.size() ; PacketIndex++)`
`202`	`193`	`{`
`203`		`- u08* OriginalBuffer = reinterpret_cast<u08*>(m_OriginalPacketBuffer[PacketIndex].get());`
	`194`	`+ uint8_t* OriginalBuffer = reinterpret_cast<uint8_t*>(m_OriginalPacketBuffer[PacketIndex].get());`
`204`	`195`	`Header::Data* OriginalHeader = reinterpret_cast<Header::Data*>(OriginalBuffer);`
`205`		`- const u16 length = ntohs(OriginalHeader->m_TotalSize);`
	`196`	`+ const uint16_t length = ntohs(OriginalHeader->m_TotalSize);`
`206`	`197`	`#if 0`
`207`		`- for(u16 CodingOffset = Header::Data::OffSets::CodingOffset ; CodingOffset < length ; CodingOffset++)`
	`198`	`+ for(uint16_t CodingOffset = Header::Data::OffSets::CodingOffset ; CodingOffset < length ; CodingOffset++)`
`208`	`199`	`{`
`209`	`200`	`m_RemedyPacketBuffer[CodingOffset] ^= FiniteField::instance()->mul(OriginalBuffer[CodingOffset], RandomCoefficients[PacketIndex]);`
`210`	`201`	`}`
`211`	`202`	`#else`
`212`		`- u16 CodingOffset = Header::Data::OffSets::CodingOffset;`
	`203`	`+ uint16_t CodingOffset = Header::Data::OffSets::CodingOffset;`
`213`	`204`	`while(CodingOffset < length)`
`214`	`205`	`{`
`215`	`206`	`/*if(length - CodingOffset > 1024)`
`@@ -262,7 +253,7 @@ void TransmissionBlock::Retransmission()`
`262`	`253`	`}`
`263`	`254`	`#endif`
`264`	`255`	`}`
`265`		`- sendto(p_Session->c_Socket, m_RemedyPacketBuffer, ntohs(RemedyHeader->m_TotalSize), 0, (sockaddr*)&RemoteAddress, sizeof(RemoteAddress));`
	`256`	`+ sendto(p_Session->c_Socket, m_RemedyPacketBuffer, ntohs(RemedyHeader->m_TotalSize), 0, (sockaddr*)&p_Session->c_Addr.Addr, p_Session->c_Addr.AddrLength);`
`266`	`257`	`}`
`267`	`258`	`while(p_Session->m_IsConnected && p_Session->m_Timer.ScheduleTask(p_Session->m_RetransmissionInterval, [this](){`
`268`	`259`	`const auto Priority = (p_Session->m_MinBlockSequenceNumber == m_BlockSequenceNumber?TransmissionSession::MIDDLE_PRIORITY:TransmissionSession::LOW_PRIORITY);`
`@@ -275,7 +266,7 @@ void TransmissionBlock::Retransmission()`
`275`	`266`	`////////////////////////////////////////////////////////////`
`276`	`267`	`/////////////// TransmissionSession`
`277`	`268`	`/OK/`
`278`		`-TransmissionSession::TransmissionSession(Transmission* const transmission, s32 Socket, u32 IPv4, u16 Port, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, u16 RetransmissionRedundancy): c_Transmission(transmission), c_Socket(Socket),c_IPv4(IPv4), c_Port(Port)`
	`269`	`+TransmissionSession::TransmissionSession(Transmission* const transmission, int32_t Socket, const DataStructures::AddressType Addr, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, uint16_t RetransmissionRedundancy): c_Transmission(transmission), c_Socket(Socket), c_Addr(Addr)`
`279`	`270`	`{`
`280`	`271`	`m_TransmissionMode = TransmissionMode;`
`281`	`272`	`m_BlockSize = BlockSize;`
`@@ -284,11 +275,12 @@ TransmissionSession::TransmissionSession(Transmission* const transmission, s32 S`
`284`	`275`	`m_MinBlockSequenceNumber = 0;`
`285`	`276`	`m_MaxBlockSequenceNumber = 0;`
`286`	`277`	`p_TransmissionBlock = nullptr;`
`287`		`- for(u32 i = 0 ; i < (Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2) ; i++)`
	`278`	`+ for(uint32_t i = 0 ; i < (Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2) ; i++)`
`288`	`279`	`{`
`289`	`280`	`m_AckList[i] = true;`
`290`	`281`	`}`
`291`	`282`	`m_ConcurrentRetransmissions = 0;`
	`283`	`+ m_IsConnected = false;`
`292`	`284`	`}`
`293`	`285`
`294`	`286`
`@@ -318,7 +310,7 @@ void TransmissionSession::ChangeBlockSize(const Parameter::BLOCK_SIZE BlockSize)`
`318`	`310`	`}`
`319`	`311`
`320`	`312`	`/OK/`
`321`		`-void TransmissionSession::ChangeRetransmissionRedundancy(const u16 RetransmissionRedundancy)`
	`313`	`+void TransmissionSession::ChangeRetransmissionRedundancy(const uint16_t RetransmissionRedundancy)`
`322`	`314`	`{`
`323`	`315`	`m_TaskQueue.Enqueue([this, RetransmissionRedundancy]()`
`324`	`316`	`{`
`@@ -327,7 +319,7 @@ void TransmissionSession::ChangeRetransmissionRedundancy(const u16 Retransmissio`
`327`	`319`	`}`
`328`	`320`
`329`	`321`	`/OK/`
`330`		`-void TransmissionSession::ChangeSessionParameter(const Parameter::TRANSMISSION_MODE TransmissionMode, const Parameter::BLOCK_SIZE BlockSize, const u16 RetransmissionRedundancy)`
	`322`	`+void TransmissionSession::ChangeSessionParameter(const Parameter::TRANSMISSION_MODE TransmissionMode, const Parameter::BLOCK_SIZE BlockSize, const uint16_t RetransmissionRedundancy)`
`331`	`323`	`{`
`332`	`324`	`m_TaskQueue.Enqueue([this, TransmissionMode, BlockSize, RetransmissionRedundancy]()`
`333`	`325`	`{`
`@@ -351,25 +343,21 @@ void TransmissionSession::SendPing()`
`351`	`343`	`TransmissionSession const * self = this;`
`352`	`344`	`std::cout<<"Pong Timeout...Client is disconnected.["<<TimeSinceLastPongTime.count()<<"]"<<std::endl;`
`353`	`345`	`std::thread DisconnectThread = std::thread([self](){`
`354`		`- self->c_Transmission->Disconnect(self->c_IPv4, self->c_Port);`
	`346`	`+ //self->c_Transmission->Disconnect(self->c_IPv4, self->c_Port);`
`355`	`347`	`});`
`356`	`348`	`DisconnectThread.detach();`
`357`	`349`	`return;`
`358`	`350`	`}`
`359`	`351`
`360`		`- sockaddr_in RemoteAddress = {0};`
`361`		`- RemoteAddress.sin_family = AF_INET;`
`362`		`- RemoteAddress.sin_addr.s_addr = c_IPv4;`
`363`		`- RemoteAddress.sin_port = c_Port;`
`364`		`- sendto(c_Socket, reinterpret_cast<u08>(&ping), sizeof(Header::Ping), 0, (sockaddr)&RemoteAddress, sizeof(RemoteAddress));`
	`352`	`+ sendto(c_Socket, reinterpret_cast<uint8_t>(&ping), sizeof(Header::Ping), 0, (sockaddr)&c_Addr.Addr, c_Addr.AddrLength);`
`365`	`353`	`while(m_IsConnected && m_Timer.ScheduleTask(Parameter::PING_INTERVAL, [this](){`
`366`	`354`	`while(m_IsConnected && m_TaskQueue.Enqueue([this](){`
`367`	`355`	`SendPing();`
`368`	`356`	`}, TransmissionSession::HIGH_PRIORITY)==false);`
`369`	`357`	`})==false);`
`370`	`358`	`}`
`371`	`359`
`372`		`-void TransmissionSession::UpdateRetransmissionInterval(const u16 rtt)`
	`360`	`+void TransmissionSession::UpdateRetransmissionInterval(const uint16_t rtt)`
`373`	`361`	`{`
`374`	`362`	`m_TaskQueue.Enqueue([this, rtt]()`
`375`	`363`	`{`
`@@ -380,7 +368,7 @@ void TransmissionSession::UpdateRetransmissionInterval(const u16 rtt)`
`380`	`368`	`////////////////////////////////////////////////////////////`
`381`	`369`	`/////////////// Transmission`
`382`	`370`	`/* OK */`
`383`		`-Transmission::Transmission(s32 Socket) : c_Socket(Socket){}`
	`371`	`+Transmission::Transmission(int32_t Socket) : c_Socket(Socket){}`
`384`	`372`
`385`	`373`	`/* OK */`
`386`	`374`	`Transmission::~Transmission()`
`@@ -390,12 +378,12 @@ Transmission::~Transmission()`
`390`	`378`	`}`
`391`	`379`
`392`	`380`	`/* OK */`
`393`		`-bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, u16 RetransmissionRedundancy)`
	`381`	`+bool Transmission::Connect(const DataStructures::AddressType Addr, uint32_t ConnectionTimeout, Parameter::TRANSMISSION_MODE TransmissionMode, Parameter::BLOCK_SIZE BlockSize, uint16_t RetransmissionRedundancy)`
`394`	`382`	`{`
`395`	`383`	`TransmissionSession* newsession = nullptr;`
`396`	`384`	`{`
`397`	`385`	`std::unique_lock< std::mutex > lock(m_Lock);`
`398`		`- const DataStructures::IPv4PortKey key = {IPv4, Port};`
	`386`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);`
`399`	`387`	`TransmissionSession** const session = m_Sessions.GetPtr(key);`
`400`	`388`	`if(session != nullptr)`
`401`	`389`	`{`
`@@ -406,7 +394,7 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:`
`406`	`394`	`try`
`407`	`395`	`{`
`408`	`396`	`TEST_EXCEPTION(std::bad_alloc());`
`409`		`- newsession = new TransmissionSession(this, c_Socket, IPv4, Port, TransmissionMode, BlockSize, RetransmissionRedundancy);`
	`397`	`+ newsession = new TransmissionSession(this, c_Socket, Addr, TransmissionMode, BlockSize, RetransmissionRedundancy);`
`410`	`398`	`}`
`411`	`399`	`catch(const std::bad_alloc& ex)`
`412`	`400`	`{`
`@@ -429,11 +417,7 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:`
`429`	`417`	`SyncPacket.m_Type = Header::Common::HeaderType::SYNC;`
`430`	`418`	`SyncPacket.m_Sequence = htons(newsession->m_MaxBlockSequenceNumber);`
`431`	`419`
`432`		`- sockaddr_in RemoteAddress = {0};`
`433`		`- RemoteAddress.sin_family = AF_INET;`
`434`		`- RemoteAddress.sin_addr.s_addr = newsession->c_IPv4;`
`435`		`- RemoteAddress.sin_port = newsession->c_Port;`
`436`		`- if(sendto(c_Socket, (u08)&SyncPacket, sizeof(SyncPacket), 0, (sockaddr)&RemoteAddress, sizeof(RemoteAddress)) != sizeof(SyncPacket))`
	`420`	`+ if(sendto(c_Socket, (uint8_t)&SyncPacket, sizeof(SyncPacket), 0, (sockaddr)(&newsession->c_Addr.Addr), newsession->c_Addr.AddrLength) != sizeof(SyncPacket))`
`437`	`421`	`{`
`438`	`422`	`return false;`
`439`	`423`	`}`
`@@ -456,12 +440,12 @@ bool Transmission::Connect(u32 IPv4, u16 Port, u32 ConnectionTimeout, Parameter:`
`456`	`440`	`}`
`457`	`441`
`458`	`442`	`/* OK */`
`459`		`-bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)`
	`443`	`+bool Transmission::Send(const DataStructures::AddressType Addr, uint8_t* buffer, uint16_t buffersize)`
`460`	`444`	`{`
`461`	`445`	`TransmissionSession* p_session = nullptr;`
`462`	`446`	`{`
`463`	`447`	`std::unique_lock< std::mutex > lock(m_Lock);`
`464`		`- const DataStructures::IPv4PortKey key = {IPv4, Port};`
	`448`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);`
`465`	`449`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`466`	`450`	`if(pp_session)`
`467`	`451`	`{`
`@@ -480,7 +464,7 @@ bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)`
`480`	`464`	`std::atomic<bool> TransmissionIsCompleted(false);`
`481`	`465`	`std::atomic<bool> TransmissionResult(false);`
`482`	`466`	`while(p_session->m_ConcurrentRetransmissions >= Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION \|\|`
`483`		`- (u16)(p_session->m_MaxBlockSequenceNumber - p_session->m_MinBlockSequenceNumber) >= (u16)Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION)`
	`467`	`+ (uint16_t)(p_session->m_MaxBlockSequenceNumber - p_session->m_MinBlockSequenceNumber) >= (uint16_t)Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION)`
`484`	`468`	`{`
`485`	`469`	`if(!p_session->m_IsConnected)`
`486`	`470`	`{`
`@@ -531,12 +515,12 @@ bool Transmission::Send(u32 IPv4, u16 Port, u08* buffer, u16 buffersize)`
`531`	`515`	`return TransmissionResult;`
`532`	`516`	`}`
`533`	`517`
`534`		`-bool Transmission::Flush(u32 IPv4, u16 Port)`
	`518`	`+bool Transmission::Flush(const DataStructures::AddressType Addr)`
`535`	`519`	`{`
`536`	`520`	`TransmissionSession* p_session = nullptr;`
`537`	`521`	`{`
`538`	`522`	`std::unique_lock< std::mutex > lock(m_Lock);`
`539`		`- const DataStructures::IPv4PortKey key = {IPv4, Port};`
	`523`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);`
`540`	`524`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`541`	`525`	`if(pp_session)`
`542`	`526`	`{`
`@@ -561,12 +545,12 @@ bool Transmission::Flush(u32 IPv4, u16 Port)`
`561`	`545`	`}, TransmissionSession::LOW_PRIORITY);`
`562`	`546`	`}`
`563`	`547`
`564`		`-void Transmission::WaitUntilTxIsCompleted(u32 IPv4, u16 Port)`
	`548`	`+void Transmission::WaitUntilTxIsCompleted(const DataStructures::AddressType Addr)`
`565`	`549`	`{`
`566`	`550`	`TransmissionSession* p_session = nullptr;`
`567`	`551`	`{`
`568`	`552`	`std::unique_lock< std::mutex > lock(m_Lock);`
`569`		`- const DataStructures::IPv4PortKey key = {IPv4, Port};`
	`553`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);`
`570`	`554`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`571`	`555`	`if(pp_session)`
`572`	`556`	`{`
`@@ -587,9 +571,9 @@ void Transmission::WaitUntilTxIsCompleted(u32 IPv4, u16 Port)`
`587`	`571`	`}`
`588`	`572`	`}`
`589`	`573`
`590`		`-bool Transmission::Disconnect(u32 IPv4, u16 Port)`
	`574`	`+bool Transmission::Disconnect(const DataStructures::AddressType Addr)`
`591`	`575`	`{`
`592`		`- const DataStructures::IPv4PortKey key = {IPv4, Port};`
	`576`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey((sockaddr*)&Addr.Addr, Addr.AddrLength);`
`593`	`577`	`TransmissionSession** pp_session = nullptr;`
`594`	`578`	`{`
`595`	`579`	`std::unique_lock< std::mutex > lock(m_Lock);`
`@@ -617,22 +601,22 @@ bool Transmission::Disconnect(u32 IPv4, u16 Port)`
`617`	`601`	`}`
`618`	`602`
`619`	`603`	`/* OK */`
`620`		`-void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const sender_addr, const u32 sender_addr_len)`
	`604`	`+void Transmission::RxHandler(uint8_t* buffer, uint16_t size, const sockaddr* const sender_addr, const uint32_t sender_addr_len)`
`621`	`605`	`{`
`622`	`606`	`Header::Common* CommonHeader = reinterpret_cast< Header::Common* >(buffer);`
`623`	`607`	`switch(CommonHeader->m_Type)`
`624`	`608`	`{`
`625`	`609`	`case Header::Common::HeaderType::DATA_ACK:`
`626`	`610`	`{`
`627`	`611`	`const Header::DataAck* Ack = reinterpret_cast< Header::DataAck* >(buffer);`
`628`		`- const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};`
	`612`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);`
`629`	`613`	`std::unique_lock< std::mutex > lock(m_Lock);`
`630`	`614`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`631`	`615`	`if(pp_session)`
`632`	`616`	`{`
`633`	`617`	`TransmissionSession* const SessionAddress = (*pp_session);`
`634`		`- u16 Sequence = ntohs(Ack->m_Sequence);`
`635`		`- u08 Loss = Ack->m_Losses;`
	`618`	`+ uint16_t Sequence = ntohs(Ack->m_Sequence);`
	`619`	`+ uint8_t Loss = Ack->m_Losses;`
`636`	`620`	`(*pp_session)->m_TaskQueue.Enqueue([SessionAddress,Sequence,Loss](){`
`637`	`621`	`if(SessionAddress->m_AckList[Sequence%(Parameter::MAXIMUM_NUMBER_OF_CONCURRENT_RETRANSMISSION*2)] == true)`
`638`	`622`	`{`
`@@ -649,7 +633,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se`
`649`	`633`	`case Header::Common::HeaderType::SYNC_ACK:`
`650`	`634`	`{`
`651`	`635`	`const Header::Sync* sync = reinterpret_cast< Header::Sync* >(buffer);`
`652`		`- const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};`
	`636`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);`
`653`	`637`	`std::unique_lock< std::mutex > lock(m_Lock);`
`654`	`638`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`655`	`639`	`if(pp_session)`
`@@ -665,7 +649,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se`
`665`	`649`	`case Header::Common::PONG:`
`666`	`650`	`{`
`667`	`651`	`const Header::Pong* pong = reinterpret_cast< Header::Pong* >(buffer);`
`668`		`- const DataStructures::IPv4PortKey key = {sender_addr->sin_addr.s_addr, sender_addr->sin_port};`
	`652`	`+ const DataStructures::SessionKey key = DataStructures::GetSessionKey(sender_addr, sender_addr_len);`
`669`	`653`	`std::unique_lock< std::mutex > lock(m_Lock);`
`670`	`654`	`TransmissionSession** const pp_session = m_Sessions.GetPtr(key);`
`671`	`655`	`if(pp_session)`
`@@ -680,7 +664,7 @@ void Transmission::RxHandler(u08* buffer, u16 size, const sockaddr_in * const se`
`680`	`664`	`}`
`681`	`665`	`else`
`682`	`666`	`{`
`683`		`- (pp_session)->UpdateRetransmissionInterval((u16)(rtt.count()1000.));`
	`667`	`+ (pp_session)->UpdateRetransmissionInterval((uint16_t)(rtt.count()1000.));`
`684`	`668`	`}`
`685`	`669`	`}`
`686`	`670`	`}`