{}
};
-/*class ThrottlingException : public BaseException
-{
-public:
- ThrottlingException(const char *s):
- BaseException(s)
- {}
-};*/
-
class InvalidIncomingDataException : public BaseException
{
public:
};
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;
};
/*
CONNCMD_DISCONNECT_PEER,
CONNCMD_SEND,
CONNCMD_SEND_TO_ALL,
- CONNCMD_DELETE_PEER,
CONCMD_ACK,
CONCMD_CREATE_PEER,
CONCMD_DISABLE_LEGACY
struct ConnectionCommand
{
enum ConnectionCommandType type;
- u16 port;
Address address;
u16 peer_id;
u8 channelnum;
ConnectionCommand(): type(CONNCMD_NONE), peer_id(PEER_ID_INEXISTENT), reliable(false), raw(false) {}
- void serve(u16 port_)
+ void serve(Address address_)
{
type = CONNCMD_SERVE;
- port = port_;
+ address = address_;
}
void connect(Address address_)
{
data = data_;
reliable = reliable_;
}
- void deletePeer(u16 peer_id_)
- {
- type = CONNCMD_DELETE_PEER;
- peer_id = peer_id_;
- }
void ack(u16 peer_id_, u8 channelnum_, SharedBuffer<u8> data_)
{
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;
+enum PeerChangeType
+{
+ PEER_ADDED,
+ PEER_REMOVED
+};
+struct PeerChange
+{
+ PeerChangeType type;
+ u16 peer_id;
+ bool timeout;
+};
+
class PeerHandler
{
public:
+
PeerHandler()
{
}
virtual ~PeerHandler()
{
}
-
+
/*
This is called after the Peer has been inserted into the
Connection's peer container.
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();
+ virtual ~UDPPeer() {};
void PutReliableSendCommand(ConnectionCommand &c,
unsigned int max_packet_size);
bool getAddress(MTProtocols type, Address& toset);
- void setNonLegacyPeer()
- { m_legacy_peer = false; }
+ void setNonLegacyPeer();
bool getLegacyPeer()
{ return m_legacy_peer; }
SharedBuffer<u8> addSpiltPacket(u8 channel,
BufferedPacket toadd,
bool reliable);
+
+
protected:
/*
Calculates avg_rtt and resend_timeout.
bool Ping(float dtime,SharedBuffer<u8>& data);
Channel channels[CHANNEL_COUNT];
+ bool m_pending_disconnect;
private:
// This is changed dynamically
float resend_timeout;
void processReliableCommand (ConnectionCommand &c);
void processNonReliableCommand (ConnectionCommand &c);
- void serve (u16 port);
+ void serve (Address bind_address);
void connect (Address address);
void disconnect ();
void disconnect_peer(u16 peer_id);
Connection* m_connection;
- unsigned int m_max_packet_size;
};
class Connection
void putCommand(ConnectionCommand &c);
void SetTimeoutMs(int timeout){ m_bc_receive_timeout = timeout; }
- void Serve(unsigned short port);
+ void Serve(Address bind_addr);
void Connect(Address address);
bool Connected();
void Disconnect();
u32 Receive(u16 &peer_id, SharedBuffer<u8> &data);
void SendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable);
void Send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable);
- void RunTimeouts(float dtime); // dummy
u16 GetPeerID(){ return m_peer_id; }
Address GetPeerAddress(u16 peer_id);
- float GetPeerAvgRTT(u16 peer_id);
- void DeletePeer(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);
protected:
PeerHelper getPeer(u16 peer_id);
void putEvent(ConnectionEvent &e);
+ void TriggerSend()
+ { m_sendThread.Trigger(); }
private:
std::list<Peer*> getPeers();
int m_bc_receive_timeout;
bool m_shutting_down;
+
+ u16 m_next_remote_peer_id;
};
} // namespace
projects / oweals / minetest.git / blobdiff