/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "connection.h"
#include "main.h"
#include "serialization.h"
#include "log.h"
#include "porting.h"
#include "util/serialize.h"
#include "util/numeric.h"
#include "util/string.h"
#include "settings.h"

namespace con
{

static u16 readPeerId(u8 *packetdata)
{
	return readU16(&packetdata[4]);
}
static u8 readChannel(u8 *packetdata)
{
	return readU8(&packetdata[6]);
}

BufferedPacket makePacket(Address &address, u8 *data, u32 datasize,
		u32 protocol_id, u16 sender_peer_id, u8 channel)
{
	u32 packet_size = datasize + BASE_HEADER_SIZE;
	BufferedPacket p(packet_size);
	p.address = address;

	writeU32(&p.data[0], protocol_id);
	writeU16(&p.data[4], sender_peer_id);
	writeU8(&p.data[6], channel);

	memcpy(&p.data[BASE_HEADER_SIZE], data, datasize);

	return p;
}

BufferedPacket makePacket(Address &address, SharedBuffer<u8> &data,
		u32 protocol_id, u16 sender_peer_id, u8 channel)
{
	return makePacket(address, *data, data.getSize(),
			protocol_id, sender_peer_id, channel);
}

SharedBuffer<u8> makeOriginalPacket(
		SharedBuffer<u8> data)
{
	u32 header_size = 1;
	u32 packet_size = data.getSize() + header_size;
	SharedBuffer<u8> b(packet_size);

	writeU8(&b[0], TYPE_ORIGINAL);

	memcpy(&b[header_size], *data, data.getSize());

	return b;
}

std::list<SharedBuffer<u8> > makeSplitPacket(
		SharedBuffer<u8> data,
		u32 chunksize_max,
		u16 seqnum)
{
	// Chunk packets, containing the TYPE_SPLIT header
	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)
			end = data.getSize() - 1;
		
		u32 payload_size = end - start + 1;
		u32 packet_size = chunk_header_size + payload_size;

		SharedBuffer<u8> chunk(packet_size);
		
		writeU8(&chunk[0], TYPE_SPLIT);
		writeU16(&chunk[1], seqnum);
		// [3] u16 chunk_count is written at next stage
		writeU16(&chunk[5], chunk_num);
		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);

	for(std::list<SharedBuffer<u8> >::iterator i = chunks.begin();
		i != chunks.end(); ++i)
	{
		// Write chunk_count
		writeU16(&((*i)[3]), chunk_count);
	}

	return chunks;
}

std::list<SharedBuffer<u8> > makeAutoSplitPacket(
		SharedBuffer<u8> data,
		u32 chunksize_max,
		u16 &split_seqnum)
{
	u32 original_header_size = 1;
	std::list<SharedBuffer<u8> > list;
	if(data.getSize() + original_header_size > chunksize_max)
	{
		list = makeSplitPacket(data, chunksize_max, split_seqnum);
		split_seqnum++;
		return list;
	}
	else
	{
		list.push_back(makeOriginalPacket(data));
	}
	return list;
}

SharedBuffer<u8> makeReliablePacket(
		SharedBuffer<u8> data,
		u16 seqnum)
{
	/*dstream<<"BEGIN SharedBuffer<u8> makeReliablePacket()"<<std::endl;
	dstream<<"data.getSize()="<<data.getSize()<<", data[0]="
			<<((unsigned int)data[0]&0xff)<<std::endl;*/
	u32 header_size = 3;
	u32 packet_size = data.getSize() + header_size;
	SharedBuffer<u8> b(packet_size);

	writeU8(&b[0], TYPE_RELIABLE);
	writeU16(&b[1], seqnum);

	memcpy(&b[header_size], *data, data.getSize());

	/*dstream<<"data.getSize()="<<data.getSize()<<", data[0]="
			<<((unsigned int)data[0]&0xff)<<std::endl;*/
	//dstream<<"END SharedBuffer<u8> makeReliablePacket()"<<std::endl;
	return b;
}

/*
	ReliablePacketBuffer
*/

ReliablePacketBuffer::ReliablePacketBuffer(): m_list_size(0) {}

void ReliablePacketBuffer::print()
{
	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<<" ";
	}
}
bool ReliablePacketBuffer::empty()
{
	return m_list.empty();
}
u32 ReliablePacketBuffer::size()
{
	return m_list_size;
}
RPBSearchResult ReliablePacketBuffer::findPacket(u16 seqnum)
{
	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
				<<", comparing to s="<<s<<std::endl;*/
		if(s == seqnum)
			break;
	}
	return i;
}
RPBSearchResult ReliablePacketBuffer::notFound()
{
	return m_list.end();
}
u16 ReliablePacketBuffer::getFirstSeqnum()
{
	if(empty())
		throw NotFoundException("Buffer is empty");
	BufferedPacket p = *m_list.begin();
	return readU16(&p.data[BASE_HEADER_SIZE+1]);
}
BufferedPacket ReliablePacketBuffer::popFirst()
{
	if(empty())
		throw NotFoundException("Buffer is empty");
	BufferedPacket p = *m_list.begin();
	m_list.erase(m_list.begin());
	--m_list_size;
	return p;
}
BufferedPacket ReliablePacketBuffer::popSeqnum(u16 seqnum)
{
	RPBSearchResult r = findPacket(seqnum);
	if(r == notFound()){
		dout_con<<"Not found"<<std::endl;
		throw NotFoundException("seqnum not found in buffer");
	}
	BufferedPacket p = *r;
	m_list.erase(r);
	--m_list_size;
	return p;
}
void ReliablePacketBuffer::insert(BufferedPacket &p)
{
	assert(p.data.getSize() >= BASE_HEADER_SIZE+3);
	u8 type = readU8(&p.data[BASE_HEADER_SIZE+0]);
	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
	if(m_list.empty())
	{
		m_list.push_back(p);
		// Done.
		return;
	}
	// Otherwise find the right place
	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){
		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)){
			break;
		}
	}
	// If we're at the end of the list, add the packet to the
	// end of the list
	if(i == m_list.end())
	{
		m_list.push_back(p);
		// Done.
		return;
	}
	// Insert before i
	m_list.insert(i, p);
}

void ReliablePacketBuffer::incrementTimeouts(float dtime)
{
	for(std::list<BufferedPacket>::iterator i = m_list.begin();
		i != m_list.end(); ++i)
	{
		i->time += dtime;
		i->totaltime += dtime;
	}
}

void ReliablePacketBuffer::resetTimedOuts(float timeout)
{
	for(std::list<BufferedPacket>::iterator i = m_list.begin();
		i != m_l<span class="hl com">/*</span>
<span class="hl com">Minetest</span>
<span class="hl com">Copyright (C) 2013 celeron55, Perttu Ahola &lt;celeron55&#64;gmail.com&gt;</span>
<span class="hl com"></span>
<span class="hl com">This program is free software; you can redistribute it and/or modify</span>
<span class="hl com">it under the terms of the GNU Lesser General Public License as published by</span>
<span class="hl com">the Free Software Foundation; either version 2.1 of the License, or</span>
<span class="hl com">(at your option) any later version.</span>
<span class="hl com"></span>
<span class="hl com">This program is distributed in the hope that it will be useful,</span>
<span class="hl com">but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="hl com">MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="hl com">GNU Lesser General Public License for more details.</span>
<span class="hl com"></span>
<span class="hl com">You should have received a copy of the GNU Lesser General Public License along</span>
<span class="hl com">with this program; if not, write to the Free Software Foundation, Inc.,</span>
<span class="hl com">51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.</span>
<span class="hl com">*/</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;test.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#include &lt;sstream&gt;</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;gamedef.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;inventory.h&quot;</span><span class="hl ppc"></span>

<span class="hl kwc">class</span> TestInventory <span class="hl opt">:</span> <span class="hl kwc">public</span> TestBase <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	<span class="hl kwd">TestInventory</span><span class="hl opt">() {</span> <span class="hl kwc">TestManager</span><span class="hl opt">::</span><span class="hl kwd">registerTestModule</span><span class="hl opt">(</span><span class="hl kwa">this</span><span class="hl opt">); }</span>
	<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwd">getName</span><span class="hl opt">() {</span> <span class="hl kwa">return</span> <span class="hl str">&quot;TestInventory&quot;</span><span class="hl opt">; }</span>

	<span class="hl kwb">void</span> <span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">);</span>

	<span class="hl kwb">void</span> <span class="hl kwd">testSerializeDeserialize</span><span class="hl opt">(</span>IItemDefManager <span class="hl opt">*</span>idef<span class="hl opt">);</span>

	<span class="hl kwb">static const char</span> <span class="hl opt">*</span>serialized_inventory_in<span class="hl opt">;</span>
	<span class="hl kwb">static const char</span> <span class="hl opt">*</span>serialized_inventory_out<span class="hl opt">;</span>
	<span class="hl kwb">static const char</span> <span class="hl opt">*</span>serialized_inventory_inc<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> TestInventory g_test_instance<span class="hl opt">;</span>

<span class="hl kwb">void</span> <span class="hl kwc">TestInventory</span><span class="hl opt">::</span><span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testSerializeDeserialize<span class="hl opt">,</span> gamedef<span class="hl opt">-&gt;</span><span class="hl kwd">getItemDefManager</span><span class="hl opt">());</span>
<span class="hl opt">}</span>

<span class="hl slc">////////////////////////////////////////////////////////////////////////////////</span>

<span class="hl kwb">void</span> <span class="hl kwc">TestInventory</span><span class="hl opt">::</span><span class="hl kwd">testSerializeDeserialize</span><span class="hl opt">(</span>IItemDefManager <span class="hl opt">*</span>idef<span class="hl opt">)</span>
<span class="hl opt">{</span>
	Inventory <span class="hl kwd">inv</span><span class="hl opt">(</span>idef<span class="hl opt">);</span>
	<span class="hl kwc">std</span><span class="hl opt">::</span>istringstream <span class="hl kwd">is</span><span class="hl opt">(</span>serialized_inventory_in<span class="hl opt">,</span> <span class="hl kwc">std</span><span class="hl opt">::</span><span class="hl kwc">ios</span><span class="hl opt">::</span>binary<span class="hl opt">);</span>

	inv<span class="hl opt">.</span><span class="hl kwd">deSerialize</span><span class="hl opt">(</span>is<span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span>inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;0&quot;</span><span class="hl opt">));</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(!</span>inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">));</span>

	inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;0&quot;</span><span class="hl opt">)-&gt;</span><span class="hl kwd">setName</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(!</span>inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;0&quot;</span><span class="hl opt">));</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span>inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">));</span>
	<span class="hl kwd">UASSERTEQ</span><span class="hl opt">(</span>u32<span class="hl opt">,</span> inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">)-&gt;</span><span class="hl kwd">getWidth</span><span class="hl opt">(),</span> <span class="hl num">3</span><span class="hl opt">);</span>

	inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">)-&gt;</span><span class="hl kwd">setWidth</span><span class="hl opt">(</span><span class="hl num">5</span><span class="hl opt">);</span>
	<span class="hl kwc">std</span><span class="hl opt">::</span>ostringstream <span class="hl kwd">inv_os</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span><span class="hl kwc">ios</span><span class="hl opt">::</span>binary<span class="hl opt">);</span>
	inv<span class="hl opt">.</span><span class="hl kwd">serialize</span><span class="hl opt">(</span>inv_os<span class="hl opt">,</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERTEQ</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>string<span class="hl opt">,</span> inv_os<span class="hl opt">.</span><span class="hl kwd">str</span><span class="hl opt">(),</span> serialized_inventory_out<span class="hl opt">);</span>

	inv<span class="hl opt">.</span><span class="hl kwd">setModified</span><span class="hl opt">(</span><span class="hl kwa">false</span><span class="hl opt">);</span>
	inv_os<span class="hl opt">.</span><span class="hl kwd">str</span><span class="hl opt">(</span><span class="hl str">&quot;&quot;</span><span class="hl opt">);</span>
	inv_os<span class="hl opt">.</span><span class="hl kwd">clear</span><span class="hl opt">();</span>
	inv<span class="hl opt">.</span><span class="hl kwd">serialize</span><span class="hl opt">(</span>inv_os<span class="hl opt">,</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERTEQ</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>string<span class="hl opt">,</span> inv_os<span class="hl opt">.</span><span class="hl kwd">str</span><span class="hl opt">(),</span> serialized_inventory_inc<span class="hl opt">);</span>

	ItemStack leftover <span class="hl opt">=</span> inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">)-&gt;</span><span class="hl kwd">takeItem</span><span class="hl opt">(</span><span class="hl num">7</span><span class="hl opt">,</span> <span class="hl num">99</span> <span class="hl opt">-</span> <span class="hl num">12</span><span class="hl opt">);</span>
	ItemStack wanted <span class="hl opt">=</span> <span class="hl kwd">ItemStack</span><span class="hl opt">(</span><span class="hl str">&quot;default:dirt&quot;</span><span class="hl opt">,</span> <span class="hl num">99</span> <span class="hl opt">-</span> <span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> idef<span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span>leftover <span class="hl opt">==</span> wanted<span class="hl opt">);</span>
	leftover <span class="hl opt">=</span> inv<span class="hl opt">.</span><span class="hl kwd">getList</span><span class="hl opt">(</span><span class="hl str">&quot;main&quot;</span><span class="hl opt">)-&gt;</span><span class="hl kwd">getItem</span><span class="hl opt">(</span><span class="hl num">7</span><span class="hl opt">);</span>
	wanted<span class="hl opt">.</span>count <span class="hl opt">=</span> <span class="hl num">12</span><span class="hl opt">;</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span>leftover <span class="hl opt">==</span> wanted<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwc">TestInventory</span><span class="hl opt">::</span>serialized_inventory_in <span class="hl opt">=</span>
	<span class="hl str">&quot;List 0 10</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Width 3</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:cobble 61</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:dirt 71</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:dirt 99</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:cobble 38</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventoryList</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;List abc 1</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:stick 3</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Width 0</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventoryList</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventory</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">;</span>

<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwc">TestInventory</span><span class="hl opt">::</span>serialized_inventory_out <span class="hl opt">=</span>
	<span class="hl str">&quot;List main 10</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Width 5</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:cobble 61</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:dirt 71</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:dirt 99</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:cobble 38</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Empty</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventoryList</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;List abc 1</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Width 0</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;Item default:stick 3</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventoryList</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventory</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">;</span>

<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwc">TestInventory</span><span class="hl opt">::</span>serialized_inventory_inc <span class="hl opt">=</span>
	<span class="hl str">&quot;KeepList main</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;KeepList abc</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
	<span class="hl str">&quot;EndInventory</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">;</span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.39.1</a>) at 2025-01-18 21:15:57 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>
ed_outs;
			
			Channel *channel = &peer->channels[i];

			// Remove timed out incomplete unreliable split packets
			channel->incoming_splits.removeUnreliableTimedOuts(dtime, m_timeout);
			
			// Increment reliable packet times
			channel->outgoing_reliables.incrementTimeouts(dtime);

			// Check reliable packet total times, remove peer if
			// over timeout.
			if(channel->outgoing_reliables.anyTotaltimeReached(m_timeout))
			{
				PrintInfo(derr_con);
				derr_con<<"RunTimeouts(): Peer "<<peer->id
						<<" has timed out."
						<<" (source=reliable packet totaltime)"
						<<std::endl;
				// Add peer to the to-be-removed list
				timeouted_peers.push_back(peer->id);
				goto nextpeer;
			}

			// Re-send timed out outgoing reliables
			
			timed_outs = channel->
					outgoing_reliables.getTimedOuts(resend_timeout);

			channel->outgoing_reliables.resetTimedOuts(resend_timeout);

			for(std::list<BufferedPacket>::iterator j = timed_outs.begin();
				j != timed_outs.end(); ++j)
			{
				u16 peer_id = readPeerId(*(j->data));
				u8 channel = readChannel(*(j->data));
				u16 seqnum = readU16(&(j->data[BASE_HEADER_SIZE+1]));

				PrintInfo(derr_con);
				derr_con<<"RE-SENDING timed-out RELIABLE to ";
				j->address.print(&derr_con);
				derr_con<<"(t/o="<<resend_timeout<<"): "
						<<"from_peer_id="<<peer_id
						<<", channel="<<((int)channel&0xff)
						<<", seqnum="<<seqnum
						<<std::endl;

				rawSend(*j);

				// Enlarge avg_rtt and resend_timeout:
				// The rtt will be at least the timeout.
				// NOTE: This won't affect the timeout of the next
				// checked channel because it was cached.
				peer->reportRTT(resend_timeout);
			}
		}
		
		/*
			Send pings
		*/
		peer->ping_timer += dtime;
		if(peer->ping_timer >= 5.0)
		{
			// Create and send PING packet
			SharedBuffer<u8> data(2);
			writeU8(&data[0], TYPE_CONTROL);
			writeU8(&data[1], CONTROLTYPE_PING);
			rawSendAsPacket(peer->id, 0, data, true);

			peer->ping_timer = 0.0;
		}
		
nextpeer:
		continue;
	}

	// Remove timed out peers
	for(std::list<u16>::iterator i = timeouted_peers.begin();
		i != timeouted_peers.end(); ++i)
	{
		PrintInfo(derr_con);
		derr_con<<"RunTimeouts(): Removing peer "<<(*i)<<std::endl;
		deletePeer(*i, true);
	}
}

void Connection::serve(u16 port)
{
	dout_con<<getDesc()<<" serving at port "<<port<<std::endl;
	try{
		m_socket.Bind(port);
		m_peer_id = PEER_ID_SERVER;
	}
	catch(SocketException &e){
		// Create event
		ConnectionEvent ce;
		ce.bindFailed();
		putEvent(ce);
	}
}

void Connection::connect(Address address)
{
	dout_con<<getDesc()<<" connecting to "<<address.serializeString()
			<<":"<<address.getPort()<<std::endl;

	std::map<u16, Peer*>::iterator node = m_peers.find(PEER_ID_SERVER);
	if(node != m_peers.end()){
		throw ConnectionException("Already connected to a server");
	}

	Peer *peer = new Peer(PEER_ID_SERVER, address);
	m_peers[peer->id] = peer;

	// Create event
	ConnectionEvent e;
	e.peerAdded(peer->id, peer->address);
	putEvent(e);
	
	m_socket.Bind(0);
	
	// Send a dummy packet to server with peer_id = PEER_ID_INEXISTENT
	m_peer_id = PEER_ID_INEXISTENT;
	SharedBuffer<u8> data(0);
	Send(PEER_ID_SERVER, 0, data, true);
}

void Connection::disconnect()
{
	dout_con<<getDesc()<<" disconnecting"<<std::endl;

	// Create and send DISCO packet
	SharedBuffer<u8> data(2);
	writeU8(&data[0], TYPE_CONTROL);
	writeU8(&data[1], CONTROLTYPE_DISCO);
	
	// Send to all
	for(std::map<u16, Peer*>::iterator j = m_peers.begin();
		j != m_peers.end(); ++j)
	{
		Peer *peer = j->second;
		rawSendAsPacket(peer->id, 0, data, false);
	}
}

void Connection::sendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable)
{
	for(std::map<u16, Peer*>::iterator j = m_peers.begin();
		j != m_peers.end(); ++j)
	{
		Peer *peer = j->second;
		send(peer->id, channelnum, data, reliable);
	}
}

void Connection::send(u16 peer_id, u8 channelnum,
		SharedBuffer<u8> data, bool reliable)
{
	dout_con<<getDesc()<<" sending to peer_id="<<peer_id<<std::endl;

	assert(channelnum < CHANNEL_COUNT);
	
	Peer *peer = getPeerNoEx(peer_id);
	if(peer == NULL)
		return;
	Channel *channel = &(peer->channels[channelnum]);

	u32 chunksize_max = m_max_packet_size - BASE_HEADER_SIZE;
	if(reliable)
		chunksize_max -= RELIABLE_HEADER_SIZE;

	std::list<SharedBuffer<u8> > originals;
	originals = makeAutoSplitPacket(data, chunksize_max,
			channel->next_outgoing_split_seqnum);
	
	for(std::list<SharedBuffer<u8> >::iterator i = originals.begin();
		i != originals.end(); ++i)
	{
		SharedBuffer<u8> original = *i;
		
		sendAsPacket(peer_id, channelnum, original, reliable);
	}
}

void Connection::sendAsPacket(u16 peer_id, u8 channelnum,
		SharedBuffer<u8> data, bool reliable)
{
	OutgoingPacket packet(peer_id, channelnum, data, reliable);
	m_outgoing_queue.push_back(packet);
}

void Connection::rawSendAsPacket(u16 peer_id, u8 channelnum,
		SharedBuffer<u8> data, bool reliable)
{
	Peer *peer = getPeerNoEx(peer_id);
	if(!peer)
		return;
	Channel *channel = &(peer->channels[channelnum]);

	if(reliable)
	{
		u16 seqnum = channel->next_outgoing_seqnum;
		channel->next_outgoing_seqnum++;

		SharedBuffer<u8> reliable = makeReliablePacket(data, seqnum);

		// Add base headers and make a packet
		BufferedPacket p = makePacket(peer->address, reliable,
				m_protocol_id, m_peer_id, channelnum);
		
		try{
			// Buffer the packet
			channel->outgoing_reliables.insert(p);
		}
		catch(AlreadyExistsException &e)
		{
			PrintInfo(derr_con);
			derr_con<<"WARNING: Going to send a reliable packet "
					"seqnum="<<seqnum<<" that is already "
					"in outgoing buffer"<<std::endl;
			//assert(0);
		}
		
		// Send the packet
		rawSend(p);
	}
	else
	{
		// Add base headers and make a packet
		BufferedPacket p = makePacket(peer->address, data,
				m_protocol_id, m_peer_id, channelnum);

		// Send the packet
		rawSend(p);
	}
}

void Connection::rawSend(const BufferedPacket &packet)
{
	try{
		m_socket.Send(packet.address, *packet.data, packet.data.getSize());
	} catch(SendFailedException &e){
		derr_con<<"Connection::rawSend(): SendFailedException: "
				<<packet.address.serializeString()<<std::endl;
	}
}

Peer* Connection::getPeer(u16 peer_id)
{
	std::map<u16, Peer*>::iterator node = m_peers.find(peer_id);

	if(node == m_peers.end()){
		throw PeerNotFoundException("GetPeer: Peer not found (possible timeout)");
	}

	// Error checking
	assert(node->second->id == peer_id);

	return node->second;
}

Peer* Connection::getPeerNoEx(u16 peer_id)
{
	std::map<u16, Peer*>::iterator node = m_peers.find(peer_id);

	if(node == m_peers.end()){
		return NULL;
	}

	// Error checking
	assert(node->second->id == peer_id);

	return node->second;
}

std::list<Peer*> Connection::getPeers()
{
	std::list<Peer*> list;
	for(std::map<u16, Peer*>::iterator j = m_peers.begin();
		j != m_peers.end(); ++j)
	{
		Peer *peer = j->second;
		list.push_back(peer);
	}
	return list;
}

bool Connection::getFromBuffers(u16 &peer_id, SharedBuffer<u8> &dst)
{
	for(std::map<u16, Peer*>::iterator j = m_peers.begin();
		j != m_peers.end(); ++j)
	{
		Peer *peer = j->second;
		for(u16 i=0; i<CHANNEL_COUNT; i++)
		{
			Channel *channel = &peer->channels[i];
			SharedBuffer<u8> resultdata;
			bool got = checkIncomingBuffers(channel, peer_id, resultdata);
			if(got){
				dst = resultdata;
				return true;
			}
		}
	}
	return false;
}

bool Connection::checkIncomingBuffers(Channel *channel, u16 &peer_id,
		SharedBuffer<u8> &dst)
{
	u16 firstseqnum = 0;
	// Clear old packets from start of buffer
	try{
	for(;;){
		firstseqnum = channel->incoming_reliables.getFirstSeqnum();
		if(seqnum_higher(channel->next_incoming_seqnum, firstseqnum))
			channel->incoming_reliables.popFirst();
		else
			break;
	}
	// This happens if all packets are old
	}catch(con::NotFoundException)
	{}
	
	if(channel->incoming_reliables.empty() == false)
	{
		if(firstseqnum == channel->next_incoming_seqnum)
		{
			BufferedPacket p = channel->incoming_reliables.popFirst();
			
			peer_id = readPeerId(*p.data);
			u8 channelnum = readChannel(*p.data);
			u16 seqnum = readU16(&p.data[BASE_HEADER_SIZE+1]);

			PrintInfo();
			dout_con<<"UNBUFFERING TYPE_RELIABLE"
					<<" seqnum="<<seqnum
					<<" peer_id="<<peer_id
					<<" channel="<<((int)channelnum&0xff)
					<<std::endl;

			channel->next_incoming_seqnum++;
			
			u32 headers_size = BASE_HEADER_SIZE + RELIABLE_HEADER_SIZE;
			// Get out the inside packet and re-process it
			SharedBuffer<u8> payload(p.data.getSize() - headers_size);
			memcpy(*payload, &p.data[headers_size], payload.getSize());

			dst = processPacket(channel, payload, peer_id, channelnum, true);
			return true;
		}
	}
	return false;
}

SharedBuffer<u8> Connection::processPacket(Channel *channel,
		SharedBuffer<u8> packetdata, u16 peer_id,
		u8 channelnum, bool reliable)
{
	IndentationRaiser iraiser(&(m_indentation));

	if(packetdata.getSize() < 1)
		throw InvalidIncomingDataException("packetdata.getSize() < 1");

	u8 type = readU8(&packetdata[0]);
	
	if(type == TYPE_CONTROL)
	{
		if(packetdata.getSize() < 2)
			throw InvalidIncomingDataException("packetdata.getSize() < 2");

		u8 controltype = readU8(&packetdata[1]);

		if(controltype == CONTROLTYPE_ACK)
		{
			if(packetdata.getSize() < 4)
				throw InvalidIncomingDataException
						("packetdata.getSize() < 4 (ACK header size)");

			u16 seqnum = readU16(&packetdata[2]);
			PrintInfo();
			dout_con<<"Got CONTROLTYPE_ACK: channelnum="
					<<((int)channelnum&0xff)<<", peer_id="<<peer_id
					<<", seqnum="<<seqnum<<std::endl;

			try{
				BufferedPacket p = channel->outgoing_reliables.popSeqnum(seqnum);
				// Get round trip time
				float rtt = p.totaltime;

				// Let peer calculate stuff according to it
				// (avg_rtt and resend_timeout)
				Peer *peer = getPeer(peer_id);
				peer->reportRTT(rtt);

				//PrintInfo(dout_con);
				//dout_con<<"RTT = "<<rtt<<std::endl;

				/*dout_con<<"OUTGOING: ";
				PrintInfo();
				channel->outgoing_reliables.print();
				dout_con<<std::endl;*/
			}
			catch(NotFoundException &e){
				PrintInfo(derr_con);
				derr_con<<"WARNING: ACKed packet not "
						"in outgoing queue"
						<<std::endl;
			}

			throw ProcessedSilentlyException("Got an ACK");
		}
		else if(controltype == CONTROLTYPE_SET_PEER_ID)
		{
			if(packetdata.getSize() < 4)
				throw InvalidIncomingDataException
						("packetdata.getSize() < 4 (SET_PEER_ID header size)");
			u16 peer_id_new = readU16(&packetdata[2]);
			PrintInfo();
			dout_con<<"Got new peer id: "<<peer_id_new<<"... "<<std::endl;

			if(GetPeerID() != PEER_ID_INEXISTENT)
			{
				PrintInfo(derr_con);
				derr_con<<"WARNING: Not changing"
						" existing peer id."<<std::endl;
			}
			else
			{
				dout_con<<"changing."<<std::endl;
				SetPeerID(peer_id_new);
			}
			throw ProcessedSilentlyException("Got a SET_PEER_ID");
		}
		else if(controltype == CONTROLTYPE_PING)
		{
			// Just ignore it, the incoming data already reset
			// the timeout counter
			PrintInfo();
			dout_con<<"PING"<<std::endl;
			throw ProcessedSilentlyException("Got a PING");
		}
		else if(controltype == CONTROLTYPE_DISCO)
		{
			// Just ignore it, the incoming data already reset
			// the timeout counter
			PrintInfo();
			dout_con<<"DISCO: Removing peer "<<(peer_id)<<std::endl;
			
			if(deletePeer(peer_id, false) == false)
			{
				PrintInfo(derr_con);
				derr_con<<"DISCO: Peer not found"<<std::endl;
			}

			throw ProcessedSilentlyException("Got a DISCO");
		}
		else{
			PrintInfo(derr_con);
			derr_con<<"INVALID TYPE_CONTROL: invalid controltype="
					<<((int)controltype&0xff)<<std::endl;
			throw InvalidIncomingDataException("Invalid control type");
		}
	}
	else if(type == TYPE_ORIGINAL)
	{
		if(packetdata.getSize() < ORIGINAL_HEADER_SIZE)
			throw InvalidIncomingDataException
					("packetdata.getSize() < ORIGINAL_HEADER_SIZE");
		PrintInfo();
		dout_con<<"RETURNING TYPE_ORIGINAL to user"
				<<std::endl;
		// Get the inside packet out and return it
		SharedBuffer<u8> payload(packetdata.getSize() - ORIGINAL_HEADER_SIZE);
		memcpy(*payload, &packetdata[ORIGINAL_HEADER_SIZE], payload.getSize());
		return payload;
	}
	else if(type == TYPE_SPLIT)
	{
		// We have to create a packet again for buffering
		// This isn't actually too bad an idea.
		BufferedPacket packet = makePacket(
				getPeer(peer_id)->address,
				packetdata,
				GetProtocolID(),
				peer_id,
				channelnum);
		// Buffer the packet
		SharedBuffer<u8> data = channel->incoming_splits.insert(packet, reliable);
		if(data.getSize() != 0)
		{
			PrintInfo();
			dout_con<<"RETURNING TYPE_SPLIT: Constructed full data, "
					<<"size="<<data.getSize()<<std::endl;
			return data;
		}
		PrintInfo();
		dout_con<<"BUFFERED TYPE_SPLIT"<<std::endl;
		throw ProcessedSilentlyException("Buffered a split packet chunk");
	}
	else if(type == TYPE_RELIABLE)
	{
		// Recursive reliable packets not allowed
		assert(reliable == false);

		if(packetdata.getSize() < RELIABLE_HEADER_SIZE)
			throw InvalidIncomingDataException
					("packetdata.getSize() < RELIABLE_HEADER_SIZE");

		u16 seqnum = readU16(&packetdata[1]);

		bool is_future_packet = seqnum_higher(seqnum, channel->next_incoming_seqnum);
		bool is_old_packet = seqnum_higher(channel->next_incoming_seqnum, seqnum);
		
		PrintInfo();
		if(is_future_packet)
			dout_con<<"BUFFERING";
		else if(is_old_packet)
			dout_con<<"OLD";
		else
			dout_con<<"RECUR";
		dout_con<<" TYPE_RELIABLE seqnum="<<seqnum
				<<" next="<<channel->next_incoming_seqnum;
		dout_con<<" [sending CONTROLTYPE_ACK"
				" to peer_id="<<peer_id<<"]";
		dout_con<<std::endl;
		
		//DEBUG
		//assert(channel->incoming_reliables.size() < 100);

		// Send a CONTROLTYPE_ACK
		SharedBuffer<u8> reply(4);
		writeU8(&reply[0], TYPE_CONTROL);
		writeU8(&reply[1], CONTROLTYPE_ACK);
		writeU16(&reply[2], seqnum);
		rawSendAsPacket(peer_id, channelnum, reply, false);

		//if(seqnum_higher(seqnum, channel->next_incoming_seqnum))
		if(is_future_packet)
		{
			/*PrintInfo();
			dout_con<<"Buffering reliable packet (seqnum="
					<<seqnum<<")"<<std::endl;*/
			
			// This one comes later, buffer it.
			// Actually we have to make a packet to buffer one.
			// Well, we have all the ingredients, so just do it.
			BufferedPacket packet = makePacket(
					getPeer(peer_id)->address,
					packetdata,
					GetProtocolID(),
					peer_id,
					channelnum);
			try{
				channel->incoming_reliables.insert(packet);
				
				/*PrintInfo();
				dout_con<<"INCOMING: ";
				channel->incoming_reliables.print();
				dout_con<<std::endl;*/
			}
			catch(AlreadyExistsException &e)
			{
			}

			throw ProcessedSilentlyException("Buffered future reliable packet");
		}
		//else if(seqnum_higher(channel->next_incoming_seqnum, seqnum))
		else if(is_old_packet)
		{
			// An old packet, dump it
			throw InvalidIncomingDataException("Got an old reliable packet");
		}

		channel->next_incoming_seqnum++;

		// Get out the inside packet and re-process it
		SharedBuffer<u8> payload(packetdata.getSize() - RELIABLE_HEADER_SIZE);
		memcpy(*payload, &packetdata[RELIABLE_HEADER_SIZE], payload.getSize());

		return processPacket(channel, payload, peer_id, channelnum, true);
	}
	else
	{
		PrintInfo(derr_con);
		derr_con<<"Got invalid type="<<((int)type&0xff)<<std::endl;
		throw InvalidIncomingDataException("Invalid packet type");
	}
	
	// We should never get here.
	// If you get here, add an exception or a return to some of the
	// above conditionals.
	assert(0);
	throw BaseException("Error in Channel::ProcessPacket()");
}

bool Connection::deletePeer(u16 peer_id, bool timeout)
{
	if(m_peers.find(peer_id) == m_peers.end())
		return false;
	
	Peer *peer = m_peers[peer_id];

	// Create event
	ConnectionEvent e;
	e.peerRemoved(peer_id, timeout, peer->address);
	putEvent(e);

	delete m_peers[peer_id];
	m_peers.erase(peer_id);
	return true;
}

/* Interface */

ConnectionEvent Connection::getEvent()
{
	if(m_event_queue.empty()){
		ConnectionEvent e;
		e.type = CONNEVENT_NONE;
		return e;
	}
	return m_event_queue.pop_front();
}

ConnectionEvent Connection::waitEvent(u32 timeout_ms)
{
	try{
		return m_event_queue.pop_front(timeout_ms);
	} catch(ItemNotFoundException &ex){
		ConnectionEvent e;
		e.type = CONNEVENT_NONE;
		return e;
	}
}

void Connection::putCommand(ConnectionCommand &c)
{
	m_command_queue.push_back(c);
}

void Connection::Serve(unsigned short port)
{
	ConnectionCommand c;
	c.serve(port);
	putCommand(c);
}

void Connection::Connect(Address address)
{
	ConnectionCommand c;
	c.connect(address);
	putCommand(c);
}

bool Connection::Connected()
{
	JMutexAutoLock peerlock(m_peers_mutex);

	if(m_peers.size() != 1)
		return false;
		
	std::map<u16, Peer*>::iterator node = m_peers.find(PEER_ID_SERVER);
	if(node == m_peers.end())
		return false;
	
	if(m_peer_id == PEER_ID_INEXISTENT)
		return false;
	
	return true;
}

void Connection::Disconnect()
{
	ConnectionCommand c;
	c.disconnect();
	putCommand(c);
}

u32 Connection::Receive(u16 &peer_id, SharedBuffer<u8> &data)
{
	for(;;){
		ConnectionEvent e = waitEvent(m_bc_receive_timeout);
		if(e.type != CONNEVENT_NONE)
			dout_con<<getDesc()<<": Receive: got event: "
					<<e.describe()<<std::endl;
		switch(e.type){
		case CONNEVENT_NONE:
			throw NoIncomingDataException("No incoming data");
		case CONNEVENT_DATA_RECEIVED:
			peer_id = e.peer_id;
			data = SharedBuffer<u8>(e.data);
			return e.data.getSize();
		case CONNEVENT_PEER_ADDED: {
			Peer tmp(e.peer_id, e.address);
			if(m_bc_peerhandler)
				m_bc_peerhandler->peerAdded(&tmp);
			continue; }
		case CONNEVENT_PEER_REMOVED: {
			Peer tmp(e.peer_id, e.address);
			if(m_bc_peerhandler)
				m_bc_peerhandler->deletingPeer(&tmp, e.timeout);
			continue; }
		case CONNEVENT_BIND_FAILED:
			throw ConnectionBindFailed("Failed to bind socket "
					"(port already in use?)");
		}
	}
	throw NoIncomingDataException("No incoming data");
}

void Connection::SendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable)
{
	assert(channelnum < CHANNEL_COUNT);

	ConnectionCommand c;
	c.sendToAll(channelnum, data, reliable);
	putCommand(c);
}

void Connection::Send(u16 peer_id, u8 channelnum,
		SharedBuffer<u8> data, bool reliable)
{
	assert(channelnum < CHANNEL_COUNT);

	ConnectionCommand c;
	c.send(peer_id, channelnum, data, reliable);
	putCommand(c);
}

void Connection::RunTimeouts(float dtime)
{
	// No-op
}

Address Connection::GetPeerAddress(u16 peer_id)
{
	JMutexAutoLock peerlock(m_peers_mutex);
	return getPeer(peer_id)->address;
}

float Connection::GetPeerAvgRTT(u16 peer_id)
{
	JMutexAutoLock peerlock(m_peers_mutex);
	return getPeer(peer_id)->avg_rtt;
}

void Connection::DeletePeer(u16 peer_id)
{
	ConnectionCommand c;
	c.deletePeer(peer_id);
	putCommand(c);
}

void Connection::PrintInfo(std::ostream &out)
{
	out<<getDesc()<<": ";
}

void Connection::PrintInfo()
{
	PrintInfo(dout_con);
}

std::string Connection::getDesc()
{
	return std::string("con(")+itos(m_socket.GetHandle())+"/"+itos(m_peer_id)+")";
}

} // namespace