|
|
|
|
@ -76,19 +76,20 @@ SharedBuffer<u8> makeOriginalPacket( |
|
|
|
|
return b; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
core::list<SharedBuffer<u8> > makeSplitPacket( |
|
|
|
|
std::list<SharedBuffer<u8> > makeSplitPacket( |
|
|
|
|
SharedBuffer<u8> data, |
|
|
|
|
u32 chunksize_max, |
|
|
|
|
u16 seqnum) |
|
|
|
|
{ |
|
|
|
|
// Chunk packets, containing the TYPE_SPLIT header
|
|
|
|
|
core::list<SharedBuffer<u8> > chunks; |
|
|
|
|
std::list<SharedBuffer<u8> > chunks; |
|
|
|
|
|
|
|
|
|
u32 chunk_header_size = 7; |
|
|
|
|
u32 maximum_data_size = chunksize_max - chunk_header_size; |
|
|
|
|
u32 start = 0; |
|
|
|
|
u32 end = 0; |
|
|
|
|
u32 chunk_num = 0; |
|
|
|
|
u16 chunk_count = 0; |
|
|
|
|
do{ |
|
|
|
|
end = start + maximum_data_size - 1; |
|
|
|
|
if(end > data.getSize() - 1) |
|
|
|
|
@ -106,16 +107,15 @@ core::list<SharedBuffer<u8> > makeSplitPacket( |
|
|
|
|
memcpy(&chunk[chunk_header_size], &data[start], payload_size); |
|
|
|
|
|
|
|
|
|
chunks.push_back(chunk); |
|
|
|
|
chunk_count++; |
|
|
|
|
|
|
|
|
|
start = end + 1; |
|
|
|
|
chunk_num++; |
|
|
|
|
} |
|
|
|
|
while(end != data.getSize() - 1); |
|
|
|
|
|
|
|
|
|
u16 chunk_count = chunks.getSize(); |
|
|
|
|
|
|
|
|
|
core::list<SharedBuffer<u8> >::Iterator i = chunks.begin(); |
|
|
|
|
for(; i != chunks.end(); i++) |
|
|
|
|
for(std::list<SharedBuffer<u8> >::iterator i = chunks.begin(); |
|
|
|
|
i != chunks.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
// Write chunk_count
|
|
|
|
|
writeU16(&((*i)[3]), chunk_count); |
|
|
|
|
@ -124,13 +124,13 @@ core::list<SharedBuffer<u8> > makeSplitPacket( |
|
|
|
|
return chunks; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
core::list<SharedBuffer<u8> > makeAutoSplitPacket( |
|
|
|
|
std::list<SharedBuffer<u8> > makeAutoSplitPacket( |
|
|
|
|
SharedBuffer<u8> data, |
|
|
|
|
u32 chunksize_max, |
|
|
|
|
u16 &split_seqnum) |
|
|
|
|
{ |
|
|
|
|
u32 original_header_size = 1; |
|
|
|
|
core::list<SharedBuffer<u8> > list; |
|
|
|
|
std::list<SharedBuffer<u8> > list; |
|
|
|
|
if(data.getSize() + original_header_size > chunksize_max) |
|
|
|
|
{ |
|
|
|
|
list = makeSplitPacket(data, chunksize_max, split_seqnum); |
|
|
|
|
@ -170,11 +170,13 @@ SharedBuffer<u8> makeReliablePacket( |
|
|
|
|
ReliablePacketBuffer |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
ReliablePacketBuffer::ReliablePacketBuffer(): m_list_size(0) {} |
|
|
|
|
|
|
|
|
|
void ReliablePacketBuffer::print() |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++) |
|
|
|
|
for(std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
i != m_list.end(); |
|
|
|
|
++i) |
|
|
|
|
{ |
|
|
|
|
u16 s = readU16(&(i->data[BASE_HEADER_SIZE+1])); |
|
|
|
|
dout_con<<s<<" "; |
|
|
|
|
@ -186,13 +188,12 @@ bool ReliablePacketBuffer::empty() |
|
|
|
|
} |
|
|
|
|
u32 ReliablePacketBuffer::size() |
|
|
|
|
{ |
|
|
|
|
return m_list.getSize(); |
|
|
|
|
return m_list_size; |
|
|
|
|
} |
|
|
|
|
RPBSearchResult ReliablePacketBuffer::findPacket(u16 seqnum) |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++) |
|
|
|
|
std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
u16 s = readU16(&(i->data[BASE_HEADER_SIZE+1])); |
|
|
|
|
/*dout_con<<"findPacket(): finding seqnum="<<seqnum
|
|
|
|
|
@ -218,8 +219,8 @@ BufferedPacket ReliablePacketBuffer::popFirst() |
|
|
|
|
if(empty()) |
|
|
|
|
throw NotFoundException("Buffer is empty"); |
|
|
|
|
BufferedPacket p = *m_list.begin(); |
|
|
|
|
core::list<BufferedPacket>::Iterator i = m_list.begin(); |
|
|
|
|
m_list.erase(i); |
|
|
|
|
m_list.erase(m_list.begin()); |
|
|
|
|
--m_list_size; |
|
|
|
|
return p; |
|
|
|
|
} |
|
|
|
|
BufferedPacket ReliablePacketBuffer::popSeqnum(u16 seqnum) |
|
|
|
|
@ -231,6 +232,7 @@ BufferedPacket ReliablePacketBuffer::popSeqnum(u16 seqnum) |
|
|
|
|
} |
|
|
|
|
BufferedPacket p = *r; |
|
|
|
|
m_list.erase(r); |
|
|
|
|
--m_list_size; |
|
|
|
|
return p; |
|
|
|
|
} |
|
|
|
|
void ReliablePacketBuffer::insert(BufferedPacket &p) |
|
|
|
|
@ -240,6 +242,7 @@ void ReliablePacketBuffer::insert(BufferedPacket &p) |
|
|
|
|
assert(type == TYPE_RELIABLE); |
|
|
|
|
u16 seqnum = readU16(&p.data[BASE_HEADER_SIZE+1]); |
|
|
|
|
|
|
|
|
|
++m_list_size; |
|
|
|
|
// Find the right place for the packet and insert it there
|
|
|
|
|
|
|
|
|
|
// If list is empty, just add it
|
|
|
|
|
@ -250,12 +253,12 @@ void ReliablePacketBuffer::insert(BufferedPacket &p) |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
// Otherwise find the right place
|
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
// Find the first packet in the list which has a higher seqnum
|
|
|
|
|
for(; i != m_list.end(); i++){ |
|
|
|
|
for(; i != m_list.end(); ++i){ |
|
|
|
|
u16 s = readU16(&(i->data[BASE_HEADER_SIZE+1])); |
|
|
|
|
if(s == seqnum){ |
|
|
|
|
--m_list_size; |
|
|
|
|
throw AlreadyExistsException("Same seqnum in list"); |
|
|
|
|
} |
|
|
|
|
if(seqnum_higher(s, seqnum)){ |
|
|
|
|
@ -271,14 +274,14 @@ void ReliablePacketBuffer::insert(BufferedPacket &p) |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
// Insert before i
|
|
|
|
|
m_list.insert_before(i, p); |
|
|
|
|
m_list.insert(i, p); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void ReliablePacketBuffer::incrementTimeouts(float dtime) |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++){ |
|
|
|
|
for(std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
i != m_list.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
i->time += dtime; |
|
|
|
|
i->totaltime += dtime; |
|
|
|
|
} |
|
|
|
|
@ -286,9 +289,9 @@ void ReliablePacketBuffer::incrementTimeouts(float dtime) |
|
|
|
|
|
|
|
|
|
void ReliablePacketBuffer::resetTimedOuts(float timeout) |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++){ |
|
|
|
|
for(std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
i != m_list.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
if(i->time >= timeout) |
|
|
|
|
i->time = 0.0; |
|
|
|
|
} |
|
|
|
|
@ -296,21 +299,20 @@ void ReliablePacketBuffer::resetTimedOuts(float timeout) |
|
|
|
|
|
|
|
|
|
bool ReliablePacketBuffer::anyTotaltimeReached(float timeout) |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++){ |
|
|
|
|
for(std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
i != m_list.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
if(i->totaltime >= timeout) |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
core::list<BufferedPacket> ReliablePacketBuffer::getTimedOuts(float timeout) |
|
|
|
|
std::list<BufferedPacket> ReliablePacketBuffer::getTimedOuts(float timeout) |
|
|
|
|
{ |
|
|
|
|
core::list<BufferedPacket> timed_outs; |
|
|
|
|
core::list<BufferedPacket>::Iterator i; |
|
|
|
|
i = m_list.begin(); |
|
|
|
|
for(; i != m_list.end(); i++) |
|
|
|
|
std::list<BufferedPacket> timed_outs; |
|
|
|
|
for(std::list<BufferedPacket>::iterator i = m_list.begin(); |
|
|
|
|
i != m_list.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
if(i->time >= timeout) |
|
|
|
|
timed_outs.push_back(*i); |
|
|
|
|
@ -324,11 +326,10 @@ core::list<BufferedPacket> ReliablePacketBuffer::getTimedOuts(float timeout) |
|
|
|
|
|
|
|
|
|
IncomingSplitBuffer::~IncomingSplitBuffer() |
|
|
|
|
{ |
|
|
|
|
core::map<u16, IncomingSplitPacket*>::Iterator i; |
|
|
|
|
i = m_buf.getIterator(); |
|
|
|
|
for(; i.atEnd() == false; i++) |
|
|
|
|
for(std::map<u16, IncomingSplitPacket*>::iterator i = m_buf.begin(); |
|
|
|
|
i != m_buf.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
delete i.getNode()->getValue(); |
|
|
|
|
delete i->second; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
/*
|
|
|
|
|
@ -346,7 +347,7 @@ SharedBuffer<u8> IncomingSplitBuffer::insert(BufferedPacket &p, bool reliable) |
|
|
|
|
u16 chunk_num = readU16(&p.data[BASE_HEADER_SIZE+5]); |
|
|
|
|
|
|
|
|
|
// Add if doesn't exist
|
|
|
|
|
if(m_buf.find(seqnum) == NULL) |
|
|
|
|
if(m_buf.find(seqnum) == m_buf.end()) |
|
|
|
|
{ |
|
|
|
|
IncomingSplitPacket *sp = new IncomingSplitPacket(); |
|
|
|
|
sp->chunk_count = chunk_count; |
|
|
|
|
@ -369,7 +370,7 @@ SharedBuffer<u8> IncomingSplitBuffer::insert(BufferedPacket &p, bool reliable) |
|
|
|
|
// If chunk already exists, ignore it.
|
|
|
|
|
// Sometimes two identical packets may arrive when there is network
|
|
|
|
|
// lag and the server re-sends stuff.
|
|
|
|
|
if(sp->chunks.find(chunk_num) != NULL) |
|
|
|
|
if(sp->chunks.find(chunk_num) != sp->chunks.end()) |
|
|
|
|
return SharedBuffer<u8>(); |
|
|
|
|
|
|
|
|
|
// Cut chunk data out of packet
|
|
|
|
|
@ -386,11 +387,10 @@ SharedBuffer<u8> IncomingSplitBuffer::insert(BufferedPacket &p, bool reliable) |
|
|
|
|
|
|
|
|
|
// Calculate total size
|
|
|
|
|
u32 totalsize = 0; |
|
|
|
|
core::map<u16, SharedBuffer<u8> >::Iterator i; |
|
|
|
|
i = sp->chunks.getIterator(); |
|
|
|
|
for(; i.atEnd() == false; i++) |
|
|
|
|
for(std::map<u16, SharedBuffer<u8> >::iterator i = sp->chunks.begin(); |
|
|
|
|
i != sp->chunks.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
totalsize += i.getNode()->getValue().getSize(); |
|
|
|
|
totalsize += i->second.getSize(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
SharedBuffer<u8> fulldata(totalsize); |
|
|
|
|
@ -407,34 +407,32 @@ SharedBuffer<u8> IncomingSplitBuffer::insert(BufferedPacket &p, bool reliable) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Remove sp from buffer
|
|
|
|
|
m_buf.remove(seqnum); |
|
|
|
|
m_buf.erase(seqnum); |
|
|
|
|
delete sp; |
|
|
|
|
|
|
|
|
|
return fulldata; |
|
|
|
|
} |
|
|
|
|
void IncomingSplitBuffer::removeUnreliableTimedOuts(float dtime, float timeout) |
|
|
|
|
{ |
|
|
|
|
core::list<u16> remove_queue; |
|
|
|
|
core::map<u16, IncomingSplitPacket*>::Iterator i; |
|
|
|
|
i = m_buf.getIterator(); |
|
|
|
|
for(; i.atEnd() == false; i++) |
|
|
|
|
std::list<u16> remove_queue; |
|
|
|
|
for(std::map<u16, IncomingSplitPacket*>::iterator i = m_buf.begin(); |
|
|
|
|
i != m_buf.end(); ++i) |
|
|
|
|
{ |
|
|
|
|
IncomingSplitPacket *p = i.getNode()->getValue(); |
|
|
|
|
IncomingSplitPacket *p = i->second; |
|
|
|
|
// Reliable ones are not removed by timeout
|
|
|
|
|
if(p->reliable == true) |
|
|
|
|
continue; |
|
|
|
|
p->time += dtime; |
|
|
|
|
if(p->time >= timeout) |
|
|
|
|
remove_queue.push_back(i.getNode()->getKey()); |
|
|
|
|
remove_queue.push_back(i->first); |
|
|
|
|
} |
|
|
|
|
core::list<u16>::Iterator j; |
|
|
|
|
j = remove_queue.begin(); |
|
|
|
|
for(; j != remove_queue.end(); j++) |
|
|
|
|
for(std::list<u16>::iterator j = remove_queue.begin(); |
|
|
|
|
j != remove_queue.end(); ++j) |
|
|
|
|
{ |
|
|
|
|
dout_con<<"NOTE: Removing timed out unreliable split packet" |
|
|
|
|
<<std::endl; |
|
|
|
|
delete m_buf[*j]; |
|
|
|
|
m_buf.remove(*j); |
|
|
|
|
m_buf.erase(*j); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -556,12 +554,11 @@ Connection::~Connection() |
|
|
|
|
{ |
|
|
|
|
stop(); |
|
|
|
|
// Delete peers
|
|
|
|
|
for(core::map<u16, Peer*>::Iterator |
|
|
|
|
j = m_peers.getIterator(); |
|
|
|
|
j.atEnd() == false; j++) |
|
|
|
|
for(std::map<u16, Peer*>::iterator |
|
|
|
|
j = m_peers.begin(); |
|
|
|
|
j != m_peers.end(); ++j) |
|
|
|
|
{ |
|
|
|
|
Peer *peer = j.getNode()->getValue(); |
|
|
|
|
delete peer; |
|
|
|
|
delete j->second; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -591,7 +588,7 @@ void * Connection::Thread() |
|
|
|
|
|
|
|
|
|
runTimeouts(dtime); |
|
|
|
|
|
|
|
|
|
while(m_command_queue.size() != 0){ |
|
|
|
|
while(!m_command_queue.empty()){ |
|
|
|
|
ConnectionCommand c = m_command_queue.pop_front(); |
|
|
|
|
processCommand(c); |
|
|
|
|
} |
|
|
|
|
@ -648,18 +645,18 @@ void Connection::processCommand(ConnectionCommand &c) |
|
|
|
|
|
|
|
|
|
void Connection::send(float dtime) |
|
|
|
|
{ |
|
|
|
|
for(core::map<u16, Peer*>::Iterator |
|
|
|
|
j = m_peers.getIterator(); |
|
|
|
|
j.atEnd() == false; j++) |
|
|
|
|
for(std::map<u16, Peer*>::iterator |
|
|
|
|
j = m_peers.begin(); |
|
|
|
|
j != m_peers.end(); ++j) |
|
|
|
|
{ |
|
|
|
|
Peer *peer = j.getNode()->getValue(); |
|
|
|
|
Peer *peer = j->second; |
|
|
|
|
peer->m_sendtime_accu += dtime; |
|
|
|
|
peer->m_num_sent = 0; |
|
|
|
|
peer->m_max_num_sent = peer->m_sendtime_accu * |
|
|
|
|
peer->m_max_packets_per_second; |
|
|
|
|
} |
|
|
|
|
Queue<OutgoingPacket> postponed_packets; |
|
|
|
|
while(m_outgoing_queue.size() != 0){ |
|
|
|
|
while(!m_outgoing_queue.empty()){ |
|
|
|
|
OutgoingPacket packet = m_outgoing_queue.pop_front(); |
|
|
|
|
Peer *peer = getPeerNoEx(packet.peer_id); |
|
|
|
|
if(!peer) |
|
|
|
|
@ -674,14 +671,14 @@ void Connection::send(float dtime) |
|
|
|
|
postponed_packets.push_back(packet); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
while(postponed_packets.size() != 0){ |
|
|
|
|
while(!postponed_packets.empty()){ |
|
|
|
|
m_outgoing_queue.push_back(postponed_packets.pop_front()); |
|
|
|
|
} |
|
|
|
|
for(core::map<u16, Peer*>::Iterator |
|
|
|
|
j = m_peers.getIterator(); |
|
|
|
|
j.atEnd() == false; j++) |
|
|
|
|
for(std::map<u16, Peer*>::iterator |
|
|
|
|
j = m_peers.begin(); |
|
|
|
|
j != m_peers.end(); ++j) |
|
|
|
|
{ |
|
|
|
|
Peer *peer = j.getNode()->getValue(); |
|
|
|
|
Peer *peer = j->second; |
|
|
|
|
peer->m_sendtime_accu -= (float)peer->m_num_sent / |
|
|
|
|
peer->m_max_packets_per_second; |
|
|
|
|
if(peer->m_sendtime_accu > 10. / peer->m_max_packets_per_second) |
|
|
|
|
@ -751,11 +748,11 @@ void Connection::receive() |
|
|
|
|
Allow only entries that have has_sent_with_id==false. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
core::map<u16, Peer*>::Iterator j; |
|
|
|
|
j = m_peers.getIterator(); |
|
|
|
|
for(; j.atEnd() == false; j++) |
|
|
|
|
std::map<u16, Peer*>::iterator j; |
|
|
|
|
j = m_peers.begin(); |
|
|
|
|
for(; j != m_peers.end(); ++j) |
|
|
|
|
{ |
|
|
|
|
Peer *peer = j.getNode()->getValue(); |
|
|
|
|
Peer *peer = j |
Ilya Zhuravlev
10 years ago
committed by