{
// 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;
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
chunks.push_back(chunk);
chunk_count++;
-
+
start = end + 1;
chunk_num++;
}
sp->reliable = reliable;
m_buf[seqnum] = sp;
}
-
+
IncomingSplitPacket *sp = m_buf[seqnum];
-
+
// TODO: These errors should be thrown or something? Dunno.
if(chunk_count != sp->chunk_count)
LOG(derr_con<<"Connection: WARNING: chunk_count="<<chunk_count
// lag and the server re-sends stuff.
if(sp->chunks.find(chunk_num) != sp->chunks.end())
return SharedBuffer<u8>();
-
+
// Cut chunk data out of packet
u32 chunkdatasize = p.data.getSize() - headersize;
SharedBuffer<u8> chunkdata(chunkdatasize);
memcpy(*chunkdata, &(p.data[headersize]), chunkdatasize);
-
+
// Set chunk data in buffer
sp->chunks[chunk_num] = chunkdata;
-
+
// If not all chunks are received, return empty buffer
if(sp->allReceived() == false)
return SharedBuffer<u8>();
{
totalsize += i->second.getSize();
}
-
+
SharedBuffer<u8> fulldata(totalsize);
// Copy chunks to data buffer
next_outgoing_split_seqnum(SEQNUM_INITIAL),
current_packet_loss(0),
current_packet_too_late(0),
+ current_packet_successfull(0),
packet_loss_counter(0),
current_bytes_transfered(0),
current_bytes_received(0),
bool UDPPeer::getAddress(MTProtocols type,Address& toset)
{
- if ((type == UDP) || (type == MINETEST_RELIABLE_UDP) || (type == PRIMARY))
+ if ((type == MTP_UDP) || (type == MTP_MINETEST_RELIABLE_UDP) || (type == MTP_PRIMARY))
{
toset = address;
return true;
SharedBuffer<u8> reliable = makeReliablePacket(data, seqnum);
Address peer_address;
- peer->getAddress(MINETEST_RELIABLE_UDP,peer_address);
+ peer->getAddress(MTP_MINETEST_RELIABLE_UDP, peer_address);
// Add base headers and make a packet
BufferedPacket p = con::makePacket(peer_address, reliable,
{
Address peer_address;
- if (peer->getAddress(UDP,peer_address))
+ if (peer->getAddress(MTP_UDP, peer_address))
{
// Add base headers and make a packet
BufferedPacket p = con::makePacket(peer_address, data,
// infrastructure
unsigned int packet_maxsize = 1500;
SharedBuffer<u8> packetdata(packet_maxsize);
-
+
bool packet_queued = true;
unsigned int loop_count = 0;
u16 peer_id = readPeerId(*packetdata);
u8 channelnum = readChannel(*packetdata);
-
+
if(channelnum > CHANNEL_COUNT-1){
LOG(derr_con<<m_connection->getDesc()
<<"Receive(): Invalid channel "<<channelnum<<std::endl);
throw InvalidIncomingDataException("Channel doesn't exist");
}
-
+
/* preserve original peer_id for later usage */
u16 packet_peer_id = peer_id;
/* The peer was not found in our lists. Add it. */
if(peer_id == PEER_ID_INEXISTENT)
{
- peer_id = m_connection->createPeer(sender,MINETEST_RELIABLE_UDP,0);
+ peer_id = m_connection->createPeer(sender, MTP_MINETEST_RELIABLE_UDP, 0);
}
PeerHelper peer = m_connection->getPeerNoEx(peer_id);
Address peer_address;
- if (peer->getAddress(UDP,peer_address)) {
+ if (peer->getAddress(MTP_UDP, peer_address)) {
if (peer_address != sender) {
LOG(derr_con<<m_connection->getDesc()
<<m_connection->getDesc()
}
}
-
+
/* mark peer as seen with id */
if (!(packet_peer_id == PEER_ID_INEXISTENT))
peer->setSentWithID();
{
channel = &(dynamic_cast<UDPPeer*>(&peer)->channels[channelnum]);
}
-
+
if (channel != 0) {
channel->UpdateBytesReceived(received_size);
}
SharedBuffer<u8> strippeddata(received_size - BASE_HEADER_SIZE);
memcpy(*strippeddata, &packetdata[BASE_HEADER_SIZE],
strippeddata.getSize());
-
+
try{
// Process it (the result is some data with no headers made by us)
SharedBuffer<u8> resultdata = processPacket
(channel, strippeddata, peer_id, channelnum, false);
-
+
LOG(dout_con<<m_connection->getDesc()
<<" ProcessPacket from peer_id: " << peer_id
<< ",channel: " << (channelnum & 0xFF) << ", returned "
<< resultdata.getSize() << " bytes" <<std::endl);
-
+
ConnectionEvent e;
e.dataReceived(peer_id, resultdata);
m_connection->putEvent(e);
{
Address peer_address;
- if (peer->getAddress(UDP,peer_address)) {
+ if (peer->getAddress(MTP_UDP, peer_address)) {
// We have to create a packet again for buffering
// This isn't actually too bad an idea.
Address peer_address;
// this is a reliable packet so we have a udp address for sure
- peer->getAddress(MINETEST_RELIABLE_UDP,peer_address);
+ peer->getAddress(MTP_MINETEST_RELIABLE_UDP, peer_address);
// 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.
Address tocheck;
- if ((peer->getAddress(MINETEST_RELIABLE_UDP,tocheck)) && (tocheck == sender))
+ if ((peer->getAddress(MTP_MINETEST_RELIABLE_UDP, tocheck)) && (tocheck == sender))
return peer->id;
- if ((peer->getAddress(UDP,tocheck)) && (tocheck == sender))
+ if ((peer->getAddress(MTP_UDP, tocheck)) && (tocheck == sender))
return peer->id;
}
Address peer_address;
//any peer has a primary address this never fails!
- peer->getAddress(PRIMARY,peer_address);
+ peer->getAddress(MTP_PRIMARY, peer_address);
// Create event
ConnectionEvent e;
e.peerRemoved(peer_id, timeout, peer_address);
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;
if (!peer)
throw PeerNotFoundException("No address for peer found!");
Address peer_address;
- peer->getAddress(PRIMARY,peer_address);
+ peer->getAddress(MTP_PRIMARY, peer_address);
return peer_address;
}
}
} // namespace
-
projects / dragonfireclient.git / blobdiff