#define WINDOW_SIZE 5
-static u16 readPeerId(u8 *packetdata)
+static session_t readPeerId(u8 *packetdata)
{
return readU16(&packetdata[4]);
}
bool ConnectionSendThread::packetsQueued()
{
- std::list<u16> peerIds = m_connection->getPeerIDs();
+ std::list<session_t> peerIds = m_connection->getPeerIDs();
if (!m_outgoing_queue.empty() && !peerIds.empty())
return true;
- for (u16 peerId : peerIds) {
+ for (session_t peerId : peerIds) {
PeerHelper peer = m_connection->getPeerNoEx(peerId);
if (!peer)
void ConnectionSendThread::runTimeouts(float dtime)
{
- std::list<u16> timeouted_peers;
- std::list<u16> peerIds = m_connection->getPeerIDs();
+ std::list<session_t> timeouted_peers;
+ std::list<session_t> peerIds = m_connection->getPeerIDs();
- for (u16 &peerId : peerIds) {
+ for (session_t &peerId : peerIds) {
PeerHelper peer = m_connection->getPeerNoEx(peerId);
if (!peer)
for (std::list<BufferedPacket>::iterator k = timed_outs.begin();
k != timed_outs.end(); ++k) {
- u16 peer_id = readPeerId(*(k->data));
+ session_t peer_id = readPeerId(*(k->data));
u8 channelnum = readChannel(*(k->data));
u16 seqnum = readU16(&(k->data[BASE_HEADER_SIZE + 1]));
rawSend(p);
}
-bool ConnectionSendThread::rawSendAsPacket(u16 peer_id, u8 channelnum,
- const SharedBuffer<u8> &data, bool reliable)
+bool ConnectionSendThread::rawSendAsPacket(session_t peer_id, u8 channelnum,
+ SharedBuffer<u8> data, bool reliable)
{
PeerHelper peer = m_connection->getPeerNoEx(peer_id);
if (!peer) {
< channel->getWindowSize()) {
LOG(dout_con << m_connection->getDesc()
<< " INFO: sending a reliable packet to peer_id " << peer_id
- << " channel: " << channelnum
+ << " channel: " << (u32)channelnum
<< " seqnum: " << seqnum << std::endl);
sendAsPacketReliable(p, channel);
return true;
LOG(dout_con << m_connection->getDesc()
<< " INFO: queueing reliable packet for peer_id: " << peer_id
- << " channel: " << channelnum
+ << " channel: " << (u32)channelnum
<< " seqnum: " << seqnum << std::endl);
channel->queued_reliables.push(p);
return false;
// Send to all
- std::list<u16> peerids = m_connection->getPeerIDs();
+ std::list<session_t> peerids = m_connection->getPeerIDs();
- for (u16 peerid : peerids) {
+ for (session_t peerid : peerids) {
sendAsPacket(peerid, 0, data, false);
}
}
-void ConnectionSendThread::disconnect_peer(u16 peer_id)
+void ConnectionSendThread::disconnect_peer(session_t peer_id)
{
LOG(dout_con << m_connection->getDesc() << " disconnecting peer" << std::endl);
dynamic_cast<UDPPeer *>(&peer)->m_pending_disconnect = true;
}
-void ConnectionSendThread::send(u16 peer_id, u8 channelnum,
+void ConnectionSendThread::send(session_t peer_id, u8 channelnum,
SharedBuffer<u8> data)
{
assert(channelnum < CHANNEL_COUNT); // Pre-condition
void ConnectionSendThread::sendToAll(u8 channelnum, SharedBuffer<u8> data)
{
- std::list<u16> peerids = m_connection->getPeerIDs();
+ std::list<session_t> peerids = m_connection->getPeerIDs();
- for (u16 peerid : peerids) {
+ for (session_t peerid : peerids) {
send(peerid, channelnum, data);
}
}
void ConnectionSendThread::sendToAllReliable(ConnectionCommand &c)
{
- std::list<u16> peerids = m_connection->getPeerIDs();
+ std::list<session_t> peerids = m_connection->getPeerIDs();
- for (u16 peerid : peerids) {
+ for (session_t peerid : peerids) {
PeerHelper peer = m_connection->getPeerNoEx(peerid);
if (!peer)
void ConnectionSendThread::sendPackets(float dtime)
{
- std::list<u16> peerIds = m_connection->getPeerIDs();
- std::list<u16> pendingDisconnect;
- std::map<u16, bool> pending_unreliable;
+ std::list<session_t> peerIds = m_connection->getPeerIDs();
+ std::list<session_t> pendingDisconnect;
+ std::map<session_t, bool> pending_unreliable;
- for (u16 peerId : peerIds) {
+ for (session_t peerId : peerIds) {
PeerHelper peer = m_connection->getPeerNoEx(peerId);
//peer may have been removed
if (!peer) {
}
}
- for (u16 peerId : pendingDisconnect) {
+ for (session_t peerId : pendingDisconnect) {
if (!pending_unreliable[peerId]) {
m_connection->deletePeer(peerId, false);
}
}
}
-void ConnectionSendThread::sendAsPacket(u16 peer_id, u8 channelnum,
+void ConnectionSendThread::sendAsPacket(session_t peer_id, u8 channelnum,
SharedBuffer<u8> data, bool ack)
{
OutgoingPacket packet(peer_id, channelnum, data, false, ack);
if (debug_print_timer > 20.0) {
debug_print_timer -= 20.0;
- std::list<u16> peerids = m_connection->getPeerIDs();
+ std::list<session_t> peerids = m_connection->getPeerIDs();
- for (std::list<u16>::iterator i = peerids.begin();
+ for (std::list<session_t>::iterator i = peerids.begin();
i != peerids.end();
i++)
{
try {
if (packet_queued) {
bool data_left = true;
- u16 peer_id;
+ session_t peer_id;
SharedBuffer<u8> resultdata;
while (data_left) {
try {
continue;
}
- u16 peer_id = readPeerId(*packetdata);
+ session_t 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);
+ << "Receive(): Invalid channel " << (u32)channelnum << std::endl);
throw InvalidIncomingDataException("Channel doesn't exist");
}
LOG(dout_con << m_connection->getDesc()
<< " ProcessPacket from peer_id: " << peer_id
- << ",channel: " << (channelnum & 0xFF) << ", returned "
+ << ", channel: " << (u32)channelnum << ", returned "
<< resultdata.getSize() << " bytes" << std::endl);
ConnectionEvent e;
}
}
-bool ConnectionReceiveThread::getFromBuffers(u16 &peer_id, SharedBuffer<u8> &dst)
+bool ConnectionReceiveThread::getFromBuffers(session_t &peer_id, SharedBuffer<u8> &dst)
{
- std::list<u16> peerids = m_connection->getPeerIDs();
+ std::list<session_t> peerids = m_connection->getPeerIDs();
- for (u16 peerid : peerids) {
+ for (session_t peerid : peerids) {
PeerHelper peer = m_connection->getPeerNoEx(peerid);
if (!peer)
continue;
}
bool ConnectionReceiveThread::checkIncomingBuffers(Channel *channel,
- u16 &peer_id, SharedBuffer<u8> &dst)
+ session_t &peer_id, SharedBuffer<u8> &dst)
{
u16 firstseqnum = 0;
if (channel->incoming_reliables.getFirstSeqnum(firstseqnum)) {
}
SharedBuffer<u8> ConnectionReceiveThread::processPacket(Channel *channel,
- SharedBuffer<u8> &packetdata, u16 peer_id, u8 channelnum, bool reliable)
+ SharedBuffer<u8> packetdata, session_t peer_id, u8 channelnum, bool reliable)
{
PeerHelper peer = m_connection->getPeerNoEx(peer_id);
};
SharedBuffer<u8> ConnectionReceiveThread::handlePacketType_Control(Channel *channel,
- SharedBuffer<u8> &packetdata, Peer *peer, u8 channelnum, bool reliable)
+ SharedBuffer<u8> packetdata, Peer *peer, u8 channelnum, bool reliable)
{
if (packetdata.getSize() < 2)
throw InvalidIncomingDataException("packetdata.getSize() < 2");
// a overflow is quite unlikely but as it'd result in major
// rtt miscalculation we handle it here
+ float rtt = 0.0f;
if (current_time > p.absolute_send_time) {
- float rtt = (current_time - p.absolute_send_time) / 1000.0;
-
- // Let peer calculate stuff according to it
- // (avg_rtt and resend_timeout)
- dynamic_cast<UDPPeer *>(peer)->reportRTT(rtt);
+ rtt = (current_time - p.absolute_send_time) / 1000.0f;
} else if (p.totaltime > 0) {
- float rtt = p.totaltime;
+ rtt = p.totaltime;
+ }
- // Let peer calculate stuff according to it
- // (avg_rtt and resend_timeout)
+ // Let peer calculate stuff according to it
+ // (avg_rtt and resend_timeout)
+ if (rtt != 0.0f)
dynamic_cast<UDPPeer *>(peer)->reportRTT(rtt);
- }
}
// put bytes for max bandwidth calculation
channel->UpdateBytesSent(p.data.getSize(), 1);
if (packetdata.getSize() < 4)
throw InvalidIncomingDataException
("packetdata.getSize() < 4 (SET_PEER_ID header size)");
- u16 peer_id_new = readU16(&packetdata[2]);
+ session_t peer_id_new = readU16(&packetdata[2]);
LOG(dout_con << m_connection->getDesc() << "Got new peer id: " << peer_id_new
<< "... " << std::endl);
}
SharedBuffer<u8> ConnectionReceiveThread::handlePacketType_Original(Channel *channel,
- SharedBuffer<u8> &packetdata, Peer *peer, u8 channelnum, bool reliable)
+ SharedBuffer<u8> packetdata, Peer *peer, u8 channelnum, bool reliable)
{
if (packetdata.getSize() <= ORIGINAL_HEADER_SIZE)
throw InvalidIncomingDataException
}
SharedBuffer<u8> ConnectionReceiveThread::handlePacketType_Split(Channel *channel,
- SharedBuffer<u8> &packetdata, Peer *peer, u8 channelnum, bool reliable)
+ SharedBuffer<u8> packetdata, Peer *peer, u8 channelnum, bool reliable)
{
Address peer_address;
}
SharedBuffer<u8> ConnectionReceiveThread::handlePacketType_Reliable(Channel *channel,
- SharedBuffer<u8> &packetdata, Peer *peer, u8 channelnum, bool reliable)
+ SharedBuffer<u8> packetdata, Peer *peer, u8 channelnum, bool reliable)
{
assert(channel != NULL);