};
typedef enum MTProtocols {
- PRIMARY,
- UDP,
- MINETEST_RELIABLE_UDP
+ MTP_PRIMARY,
+ MTP_UDP,
+ MTP_MINETEST_RELIABLE_UDP
} MTProtocols;
#define SEQNUM_MAX 65535
struct BufferedPacket
{
BufferedPacket(u8 *a_data, u32 a_size):
- data(a_data, a_size), time(0.0), totaltime(0.0), absolute_send_time(-1)
+ data(a_data, a_size), time(0.0), totaltime(0.0), absolute_send_time(-1),
+ resend_count(0)
{}
BufferedPacket(u32 a_size):
- data(a_size), time(0.0), totaltime(0.0), absolute_send_time(-1)
+ data(a_size), time(0.0), totaltime(0.0), absolute_send_time(-1),
+ resend_count(0)
{}
SharedBuffer<u8> data; // Data of the packet, including headers
float time; // Seconds from buffering the packet or re-sending
float totaltime; // Seconds from buffering the packet
unsigned int absolute_send_time;
Address address; // Sender or destination
+ unsigned int resend_count;
};
// This adds the base headers to the data and makes a packet out of it
RPBSearchResult findPacket(u16 seqnum);
std::list<BufferedPacket> m_list;
- u16 m_list_size;
+ u32 m_list_size;
u16 m_oldest_non_answered_ack;
JMutex m_list_mutex;
-
- unsigned int writeptr;
};
/*
void UpdatePacketTooLateCounter();
void UpdateBytesSent(unsigned int bytes,unsigned int packages=1);
void UpdateBytesLost(unsigned int bytes);
+ void UpdateBytesReceived(unsigned int bytes);
- void UpdateTimers(float dtime);
+ void UpdateTimers(float dtime, bool legacy_peer);
const float getCurrentDownloadRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return cur_kbps; };
const float getMaxLossRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return max_kbps_lost; };
+ const float getCurrentIncomingRateKB()
+ { JMutexAutoLock lock(m_internal_mutex); return cur_incoming_kbps; };
+ const float getMaxIncomingRateKB()
+ { JMutexAutoLock lock(m_internal_mutex); return max_incoming_kbps; };
+
const float getAvgDownloadRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return avg_kbps; };
const float getAvgLossRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return avg_kbps_lost; };
+ const float getAvgIncomingRateKB()
+ { JMutexAutoLock lock(m_internal_mutex); return avg_incoming_kbps; };
const unsigned int getWindowSize() const { return window_size; };
void setWindowSize(unsigned int size) { window_size = size; };
private:
JMutex m_internal_mutex;
- unsigned int window_size;
+ int window_size;
u16 next_incoming_seqnum;
float packet_loss_counter;
unsigned int current_bytes_transfered;
+ unsigned int current_bytes_received;
unsigned int current_bytes_lost;
float max_kbps;
float cur_kbps;
float avg_kbps;
+ float max_incoming_kbps;
+ float cur_incoming_kbps;
+ float avg_incoming_kbps;
float max_kbps_lost;
float cur_kbps_lost;
float avg_kbps_lost;
float bpm_counter;
+
+ unsigned int rate_samples;
};
class Peer;
class Connection;
-typedef enum rtt_stat_type {
+typedef enum {
MIN_RTT,
MAX_RTT,
AVG_RTT,
AVG_JITTER
} rtt_stat_type;
+typedef enum {
+ CUR_DL_RATE,
+ AVG_DL_RATE,
+ CUR_INC_RATE,
+ AVG_INC_RATE,
+ CUR_LOSS_RATE,
+ AVG_LOSS_RATE,
+} rate_stat_type;
+
class Peer {
public:
friend class PeerHelper;
friend class PeerHelper;
friend class ConnectionReceiveThread;
friend class ConnectionSendThread;
+ friend class Connection;
UDPPeer(u16 a_id, Address a_address, Connection* connection);
virtual ~UDPPeer() {};
Connection* m_connection;
- unsigned int m_max_packet_size;
};
class Connection
void Send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable);
u16 GetPeerID(){ return m_peer_id; }
Address GetPeerAddress(u16 peer_id);
- float GetPeerAvgRTT(u16 peer_id);
+ float getPeerStat(u16 peer_id, rtt_stat_type type);
+ float getLocalStat(rate_stat_type type);
const u32 GetProtocolID() const { return m_protocol_id; };
const std::string getDesc();
void DisconnectPeer(u16 peer_id);