Commit current work
This is a temporary branch because I'm missing a USB drive, huehue
This commit is contained in:
Jérôme Leclercq
parent
311e2a545d
commit
9e3341a32a
|
|
@ -0,0 +1,121 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#ifndef NAZARA_ENETHOST_HPP
|
||||||
|
#define NAZARA_ENETHOST_HPP
|
||||||
|
|
||||||
|
#include <Nazara/Prerequesites.hpp>
|
||||||
|
#include <Nazara/Core/Bitset.hpp>
|
||||||
|
#include <Nazara/Core/Clock.hpp>
|
||||||
|
#include <Nazara/Core/MemoryPool.hpp>
|
||||||
|
#include <Nazara/Network/ENetHost.hpp>
|
||||||
|
#include <Nazara/Network/ENetProtocol.hpp>
|
||||||
|
#include <Nazara/Network/IpAddress.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
#include <Nazara/Network/SocketPoller.hpp>
|
||||||
|
#include <Nazara/Network/UdpSocket.hpp>
|
||||||
|
#include <deque>
|
||||||
|
#include <queue>
|
||||||
|
#include <random>
|
||||||
|
#include <set>
|
||||||
|
#include <unordered_map>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
class ENetPeer;
|
||||||
|
|
||||||
|
class NAZARA_NETWORK_API ENetHost
|
||||||
|
{
|
||||||
|
friend ENetPeer;
|
||||||
|
friend class Network;
|
||||||
|
|
||||||
|
public:
|
||||||
|
inline ENetHost();
|
||||||
|
ENetHost(const ENetHost&) = delete;
|
||||||
|
ENetHost(ENetHost&&) = default;
|
||||||
|
inline ~ENetHost();
|
||||||
|
|
||||||
|
void Broadcast(UInt8 channelId, ENetPacketFlags flags, NetPacket&& packet);
|
||||||
|
|
||||||
|
bool Connect(const IpAddress& remoteAddress, std::size_t channelCount = 0, UInt32 data = 0);
|
||||||
|
bool Connect(const String& hostName, NetProtocol protocol = NetProtocol_Any, const String& service = "http", ResolveError* error = nullptr, std::size_t channelCount = 0, UInt32 data = 0);
|
||||||
|
|
||||||
|
inline bool Create(NetProtocol protocol, UInt16 port, std::size_t peerCount, std::size_t channelCount = 0);
|
||||||
|
bool Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount = 0);
|
||||||
|
bool Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount, UInt32 incomingBandwidth, UInt32 outgoingBandwidth);
|
||||||
|
void Destroy();
|
||||||
|
|
||||||
|
void Flush();
|
||||||
|
|
||||||
|
int Service(ENetEvent* event, UInt32 timeout);
|
||||||
|
|
||||||
|
ENetHost& operator=(const ENetHost&) = delete;
|
||||||
|
ENetHost& operator=(ENetHost&&) = default;
|
||||||
|
|
||||||
|
private:
|
||||||
|
bool InitSocket(const IpAddress& address);
|
||||||
|
|
||||||
|
inline void AddToDispatchQueue(ENetPeer* peer);
|
||||||
|
inline void RemoveFromDispatchQueue(ENetPeer* peer);
|
||||||
|
|
||||||
|
bool DispatchIncomingCommands(ENetEvent* event);
|
||||||
|
|
||||||
|
ENetPeer* HandleConnect(ENetProtocolHeader* header, ENetProtocol* command);
|
||||||
|
bool HandleIncomingCommands(ENetEvent* event);
|
||||||
|
bool HandleSendReliable(ENetPeer& peer, const ENetProtocol& command, UInt8** currentData);
|
||||||
|
|
||||||
|
int ReceiveIncomingCommands(ENetEvent* event);
|
||||||
|
|
||||||
|
void NotifyConnect(ENetPeer* peer, ENetEvent* event);
|
||||||
|
void NotifyDisconnect(ENetPeer*, ENetEvent* event);
|
||||||
|
|
||||||
|
void ThrottleBandwidth();
|
||||||
|
|
||||||
|
static bool Initialize();
|
||||||
|
static void Uninitialize();
|
||||||
|
|
||||||
|
std::array<ENetProtocol, ENetConstants::ENetProtocol_MaximumPacketCommands> m_commands;
|
||||||
|
std::array<UInt8, ENetConstants::ENetProtocol_MaximumMTU> m_packetData[2];
|
||||||
|
std::bernoulli_distribution m_packetLossProbability;
|
||||||
|
std::size_t m_bandwidthLimitedPeers;
|
||||||
|
std::size_t m_bufferCount;
|
||||||
|
std::size_t m_channelLimit;
|
||||||
|
std::size_t m_commandCount;
|
||||||
|
std::size_t m_duplicatePeers;
|
||||||
|
std::size_t m_maximumPacketSize;
|
||||||
|
std::size_t m_maximumWaitingData;
|
||||||
|
std::size_t m_receivedDataLength;
|
||||||
|
std::vector<ENetPeer> m_peers;
|
||||||
|
Bitset<UInt64> m_dispatchQueue;
|
||||||
|
MemoryPool m_packetPool;
|
||||||
|
IpAddress m_address;
|
||||||
|
IpAddress m_receivedAddress;
|
||||||
|
SocketPoller m_poller;
|
||||||
|
UdpSocket m_socket;
|
||||||
|
UInt32 m_bandwidthThrottleEpoch;
|
||||||
|
UInt32 m_connectedPeers;
|
||||||
|
UInt32 m_mtu;
|
||||||
|
UInt32 m_randomSeed;
|
||||||
|
UInt32 m_incomingBandwidth;
|
||||||
|
UInt32 m_outgoingBandwidth;
|
||||||
|
UInt32 m_serviceTime;
|
||||||
|
UInt32 m_totalSentData;
|
||||||
|
UInt32 m_totalSentPackets;
|
||||||
|
UInt32 m_totalReceivedData;
|
||||||
|
UInt32 m_totalReceivedPackets;
|
||||||
|
UInt8* m_receivedData;
|
||||||
|
bool m_isSimulationEnabled;
|
||||||
|
bool m_shouldAcceptConnections;
|
||||||
|
bool m_recalculateBandwidthLimits;
|
||||||
|
|
||||||
|
static std::mt19937 s_randomGenerator;
|
||||||
|
static std::mt19937_64 s_randomGenerator64;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
#include <Nazara/Network/ENetHost.inl>
|
||||||
|
|
||||||
|
#endif // NAZARA_RUDPSERVER_HPP
|
||||||
|
|
@ -0,0 +1,65 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#include <Nazara/Network/ENetHost.hpp>
|
||||||
|
#include <utility>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
inline ENetHost::ENetHost() :
|
||||||
|
m_packetPool(sizeof(ENetPacket))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
inline ENetHost::~ENetHost()
|
||||||
|
{
|
||||||
|
Destroy();
|
||||||
|
}
|
||||||
|
|
||||||
|
inline bool ENetHost::Create(NetProtocol protocol, UInt16 port, std::size_t peerCount, std::size_t channelCount)
|
||||||
|
{
|
||||||
|
NazaraAssert(protocol != NetProtocol_Any, "Any protocol not supported for Listen"); //< TODO
|
||||||
|
NazaraAssert(protocol != NetProtocol_Unknown, "Invalid protocol");
|
||||||
|
|
||||||
|
IpAddress any;
|
||||||
|
switch (protocol)
|
||||||
|
{
|
||||||
|
case NetProtocol_Any:
|
||||||
|
case NetProtocol_Unknown:
|
||||||
|
NazaraInternalError("Invalid protocol Any at this point");
|
||||||
|
return false;
|
||||||
|
|
||||||
|
case NetProtocol_IPv4:
|
||||||
|
any = IpAddress::AnyIpV4;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case NetProtocol_IPv6:
|
||||||
|
any = IpAddress::AnyIpV6;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
any.SetPort(port);
|
||||||
|
return Create(any, peerCount, channelCount);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void ENetHost::Destroy()
|
||||||
|
{
|
||||||
|
m_poller.Clear();
|
||||||
|
m_peers.clear();
|
||||||
|
m_socket.Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void ENetHost::AddToDispatchQueue(ENetPeer* peer)
|
||||||
|
{
|
||||||
|
m_dispatchQueue.UnboundedSet(peer->m_incomingPeerID);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void ENetHost::RemoveFromDispatchQueue(ENetPeer* peer)
|
||||||
|
{
|
||||||
|
m_dispatchQueue.UnboundedReset(peer->m_incomingPeerID);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#include <Nazara/Network/DebugOff.hpp>
|
||||||
|
|
@ -0,0 +1,78 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#ifndef NAZARA_ENETPACKET_HPP
|
||||||
|
#define NAZARA_ENETPACKET_HPP
|
||||||
|
|
||||||
|
#include <Nazara/Prerequesites.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
enum ENetPacketFlag
|
||||||
|
{
|
||||||
|
ENetPacketFlag_NoAllocate,
|
||||||
|
ENetPacketFlag_Reliable,
|
||||||
|
ENetPacketFlag_Unsequenced,
|
||||||
|
ENetPacketFlag_UnreliableFragment,
|
||||||
|
ENetPacketFlag_Sent
|
||||||
|
};
|
||||||
|
|
||||||
|
template<>
|
||||||
|
struct EnumAsFlags<ENetPacketFlag>
|
||||||
|
{
|
||||||
|
static constexpr bool value = true;
|
||||||
|
static constexpr int max = ENetPacketFlag_Sent;
|
||||||
|
};
|
||||||
|
|
||||||
|
using ENetPacketFlags = Flags<ENetPacketFlag>;
|
||||||
|
|
||||||
|
class MemoryPool;
|
||||||
|
|
||||||
|
struct ENetPacket
|
||||||
|
{
|
||||||
|
MemoryPool* owner;
|
||||||
|
ENetPacketFlags flags;
|
||||||
|
NetPacket data;
|
||||||
|
std::size_t referenceCount = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetPacketRef
|
||||||
|
{
|
||||||
|
ENetPacketRef() = default;
|
||||||
|
|
||||||
|
ENetPacketRef(ENetPacket* packet)
|
||||||
|
{
|
||||||
|
Reset(packet);
|
||||||
|
}
|
||||||
|
|
||||||
|
~ENetPacketRef()
|
||||||
|
{
|
||||||
|
Reset();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Reset(ENetPacket* packet = nullptr);
|
||||||
|
|
||||||
|
operator ENetPacket*() const
|
||||||
|
{
|
||||||
|
return m_packet;
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPacket* operator->() const
|
||||||
|
{
|
||||||
|
return m_packet;
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPacketRef& operator=(ENetPacket* packet)
|
||||||
|
{
|
||||||
|
Reset(packet);
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPacket* m_packet = nullptr;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // NAZARA_ENETPACKET_HPP
|
||||||
|
|
@ -0,0 +1,205 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#ifndef NAZARA_ENETPEER_HPP
|
||||||
|
#define NAZARA_ENETPEER_HPP
|
||||||
|
|
||||||
|
#include <Nazara/Prerequesites.hpp>
|
||||||
|
#include <Nazara/Core/Bitset.hpp>
|
||||||
|
#include <Nazara/Core/Clock.hpp>
|
||||||
|
#include <Nazara/Core/MemoryPool.hpp>
|
||||||
|
#include <Nazara/Network/ENetPacket.hpp>
|
||||||
|
#include <Nazara/Network/ENetProtocol.hpp>
|
||||||
|
#include <Nazara/Network/IpAddress.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
#include <Nazara/Network/UdpSocket.hpp>
|
||||||
|
#include <deque>
|
||||||
|
#include <queue>
|
||||||
|
#include <random>
|
||||||
|
#include <set>
|
||||||
|
#include <unordered_map>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
class ENetHost;
|
||||||
|
|
||||||
|
class NAZARA_NETWORK_API ENetPeer
|
||||||
|
{
|
||||||
|
friend ENetHost;
|
||||||
|
friend struct PacketRef;
|
||||||
|
|
||||||
|
public:
|
||||||
|
ENetPeer(const ENetPeer&) = delete;
|
||||||
|
ENetPeer(ENetPeer&&) = default;
|
||||||
|
~ENetPeer() = default;
|
||||||
|
|
||||||
|
void Disconnect(UInt32 data);
|
||||||
|
void DisconnectLater(UInt32 data);
|
||||||
|
void DisconnectNow(UInt32 data);
|
||||||
|
|
||||||
|
void Ping();
|
||||||
|
|
||||||
|
bool Receive(ENetPacketRef* packet, UInt8* channelId);
|
||||||
|
void Reset();
|
||||||
|
|
||||||
|
bool Send(UInt8 channelId, ENetPacketRef packetRef);
|
||||||
|
bool Send(UInt8 channelId, ENetPacketFlags flags, NetPacket&& packet);
|
||||||
|
|
||||||
|
void ThrottleConfigure(UInt32 interval, UInt32 acceleration, UInt32 deceleration);
|
||||||
|
|
||||||
|
ENetPeer& operator=(const ENetPeer&) = delete;
|
||||||
|
ENetPeer& operator=(ENetPeer&&) = default;
|
||||||
|
|
||||||
|
private:
|
||||||
|
ENetPeer(ENetHost* host, UInt16 peerId);
|
||||||
|
|
||||||
|
void InitIncoming(std::size_t channelCount, const IpAddress& address, ENetProtocolConnect& incomingCommand);
|
||||||
|
void InitOutgoing(std::size_t channelCount, const IpAddress& address, UInt32 connectId, UInt32 windowSize);
|
||||||
|
|
||||||
|
struct Acknowledgement;
|
||||||
|
struct Channel;
|
||||||
|
struct IncomingCommmand;
|
||||||
|
struct OutgoingCommand;
|
||||||
|
|
||||||
|
// Protocol functions
|
||||||
|
inline void ChangeState(ENetPeerState state);
|
||||||
|
inline void DispatchState(ENetPeerState state);
|
||||||
|
|
||||||
|
void DispatchIncomingReliableCommands(Channel& channel);
|
||||||
|
void DispatchIncomingUnreliableCommands(Channel& channel);
|
||||||
|
|
||||||
|
void OnConnect();
|
||||||
|
void OnDisconnect();
|
||||||
|
|
||||||
|
ENetProtocolCommand RemoveSentReliableCommands(UInt16 reliableSequenceNumber, UInt8 channelId);
|
||||||
|
void RemoveSentUnreliableCommands();
|
||||||
|
|
||||||
|
void ResetQueues();
|
||||||
|
|
||||||
|
bool QueueAcknowledgement(ENetProtocol& command, UInt16 sentTime);
|
||||||
|
IncomingCommmand* QueueIncomingCommand(ENetProtocol& command, const void* data, std::size_t dataLength, UInt32 flags, UInt32 fragmentCount);
|
||||||
|
void QueueOutgoingCommand(ENetProtocol& command, ENetPacketRef packet, UInt32 offset, UInt16 length);
|
||||||
|
|
||||||
|
void SetupOutgoingCommand(OutgoingCommand& outgoingCommand);
|
||||||
|
|
||||||
|
int Throttle(UInt32 rtt);
|
||||||
|
|
||||||
|
struct Acknowledgement
|
||||||
|
{
|
||||||
|
ENetProtocol command;
|
||||||
|
UInt32 sentTime;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct Channel
|
||||||
|
{
|
||||||
|
Channel()
|
||||||
|
{
|
||||||
|
incomingReliableSequenceNumber = 0;
|
||||||
|
incomingUnreliableSequenceNumber = 0;
|
||||||
|
outgoingReliableSequenceNumber = 0;
|
||||||
|
outgoingUnreliableSequenceNumber = 0;
|
||||||
|
usedReliableWindows = 0;
|
||||||
|
reliableWindows.fill(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::array<UInt16, ENetPeer_ReliableWindows> reliableWindows;
|
||||||
|
std::list<IncomingCommmand> incomingReliableCommands;
|
||||||
|
std::list<IncomingCommmand> incomingUnreliableCommands;
|
||||||
|
UInt16 incomingReliableSequenceNumber;
|
||||||
|
UInt16 incomingUnreliableSequenceNumber;
|
||||||
|
UInt16 outgoingReliableSequenceNumber;
|
||||||
|
UInt16 outgoingUnreliableSequenceNumber;
|
||||||
|
UInt16 usedReliableWindows;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct IncomingCommmand
|
||||||
|
{
|
||||||
|
ENetProtocol command;
|
||||||
|
UInt16 reliableSequenceNumber;
|
||||||
|
UInt16 unreliableSequenceNumber;
|
||||||
|
UInt32 fragmentsRemaining;
|
||||||
|
std::vector<UInt32> fragments;
|
||||||
|
ENetPacketRef packet;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct OutgoingCommand
|
||||||
|
{
|
||||||
|
ENetProtocol command;
|
||||||
|
ENetPacketRef packet;
|
||||||
|
UInt16 fragmentLength;
|
||||||
|
UInt16 reliableSequenceNumber;
|
||||||
|
UInt16 sendAttempts;
|
||||||
|
UInt16 unreliableSequenceNumber;
|
||||||
|
UInt32 fragmentOffset;
|
||||||
|
UInt32 roundTripTimeout;
|
||||||
|
UInt32 roundTripTimeoutLimit;
|
||||||
|
UInt32 sentTime;
|
||||||
|
};
|
||||||
|
|
||||||
|
ENetHost* m_host;
|
||||||
|
IpAddress m_address; /**< Internet address of the peer */
|
||||||
|
std::vector<Channel> m_channels;
|
||||||
|
std::list<Acknowledgement> m_acknowledgements;
|
||||||
|
std::list<IncomingCommmand> m_dispatchedCommands;
|
||||||
|
std::list<OutgoingCommand> m_outgoingReliableCommands;
|
||||||
|
std::list<OutgoingCommand> m_outgoingUnreliableCommands;
|
||||||
|
std::list<OutgoingCommand> m_sentReliableCommands;
|
||||||
|
std::list<OutgoingCommand> m_sentUnreliableCommands;
|
||||||
|
MemoryPool m_packetPool;
|
||||||
|
//ENetListNode m_dispatchList;
|
||||||
|
ENetPeerState m_state;
|
||||||
|
UInt8 m_incomingSessionID;
|
||||||
|
UInt8 m_outgoingSessionID;
|
||||||
|
UInt16 m_incomingPeerID;
|
||||||
|
UInt16 m_incomingUnsequencedGroup;
|
||||||
|
UInt16 m_outgoingPeerID;
|
||||||
|
UInt16 m_outgoingReliableSequenceNumber;
|
||||||
|
UInt16 m_outgoingUnsequencedGroup;
|
||||||
|
UInt32 m_connectID;
|
||||||
|
UInt32 m_earliestTimeout;
|
||||||
|
UInt32 m_eventData;
|
||||||
|
UInt32 m_highestRoundTripTimeVariance;
|
||||||
|
UInt32 m_incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
|
||||||
|
UInt32 m_incomingBandwidthThrottleEpoch;
|
||||||
|
UInt32 m_incomingDataTotal;
|
||||||
|
UInt32 m_lastReceiveTime;
|
||||||
|
UInt32 m_lastRoundTripTime;
|
||||||
|
UInt32 m_lastRoundTripTimeVariance;
|
||||||
|
UInt32 m_lastSendTime;
|
||||||
|
UInt32 m_lowestRoundTripTime;
|
||||||
|
UInt32 m_mtu;
|
||||||
|
UInt32 m_nextTimeout;
|
||||||
|
UInt32 m_outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
|
||||||
|
UInt32 m_outgoingBandwidthThrottleEpoch;
|
||||||
|
UInt32 m_outgoingDataTotal;
|
||||||
|
UInt32 m_packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
|
||||||
|
UInt32 m_packetLossEpoch;
|
||||||
|
UInt32 m_packetLossVariance;
|
||||||
|
UInt32 m_packetThrottle;
|
||||||
|
UInt32 m_packetThrottleAcceleration;
|
||||||
|
UInt32 m_packetThrottleCounter;
|
||||||
|
UInt32 m_packetThrottleDeceleration;
|
||||||
|
UInt32 m_packetThrottleEpoch;
|
||||||
|
UInt32 m_packetThrottleInterval;
|
||||||
|
UInt32 m_packetThrottleLimit;
|
||||||
|
UInt32 m_packetsLost;
|
||||||
|
UInt32 m_packetsSent;
|
||||||
|
UInt32 m_pingInterval;
|
||||||
|
UInt32 m_reliableDataInTransit;
|
||||||
|
UInt32 m_roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgment */
|
||||||
|
UInt32 m_roundTripTimeVariance;
|
||||||
|
UInt32 m_timeoutLimit;
|
||||||
|
UInt32 m_timeoutMaximum;
|
||||||
|
UInt32 m_timeoutMinimum;
|
||||||
|
UInt32 m_unsequencedWindow[ENetPeer_ReliableWindowSize / 32];
|
||||||
|
UInt32 m_windowSize;
|
||||||
|
std::size_t m_totalWaitingData;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
#include <Nazara/Network/ENetPeer.inl>
|
||||||
|
|
||||||
|
#endif // NAZARA_ENETPEER_HPP
|
||||||
|
|
@ -0,0 +1,29 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#include <Nazara/Network/ENetPeer.hpp>
|
||||||
|
#include <utility>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
inline void ENetPeer::ChangeState(ENetPeerState state)
|
||||||
|
{
|
||||||
|
if (state == ENetPeerState::Connected || state == ENetPeerState::DisconnectLater)
|
||||||
|
OnConnect();
|
||||||
|
else
|
||||||
|
OnDisconnect();
|
||||||
|
|
||||||
|
m_state = state;
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void ENetPeer::DispatchState(ENetPeerState state)
|
||||||
|
{
|
||||||
|
ChangeState(state);
|
||||||
|
|
||||||
|
m_host->AddToDispatchQueue(this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#include <Nazara/Network/DebugOff.hpp>
|
||||||
|
|
@ -0,0 +1,272 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Network module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#ifndef NAZARA_ENETPROTOCOL_HPP
|
||||||
|
#define NAZARA_ENETPROTOCOL_HPP
|
||||||
|
|
||||||
|
#include <Nazara/Prerequesites.hpp>
|
||||||
|
#include <Nazara/Network/ENetPacket.hpp>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
// Constants for the ENet implementation and protocol
|
||||||
|
enum ENetConstants
|
||||||
|
{
|
||||||
|
ENetHost_BandwidthThrottleInterval = 1000,
|
||||||
|
ENetHost_DefaultMaximumPacketSize = 32 * 1024 * 1024,
|
||||||
|
ENetHost_DefaultMaximumWaitingData = 32 * 1024 * 1024,
|
||||||
|
ENetHost_DefaultMTU = 1400,
|
||||||
|
ENetHost_ReceiveBufferSize = 256 * 1024,
|
||||||
|
ENetHost_SendBufferSize = 256 * 1024,
|
||||||
|
|
||||||
|
ENetPeer_DefaultPacketThrottle = 32,
|
||||||
|
ENetPeer_DefaultRoundTripTime = 500,
|
||||||
|
ENetPeer_FreeReliableWindows = 8,
|
||||||
|
ENetPeer_FreeUnsequencedWindows = 32,
|
||||||
|
ENetPeer_PacketLossInterval = 10000,
|
||||||
|
ENetPeer_PacketLossScale = (1 << 16),
|
||||||
|
ENetPeer_PacketThrottleAcceleration = 2,
|
||||||
|
ENetPeer_PacketThrottleCounter = 7,
|
||||||
|
ENetPeer_PacketThrottleDeceleration = 2,
|
||||||
|
ENetPeer_PacketThrottleInterval = 5000,
|
||||||
|
ENetPeer_PacketThrottleScale = 32,
|
||||||
|
ENetPeer_PingInterval = 500,
|
||||||
|
ENetPeer_ReliableWindows = 16,
|
||||||
|
ENetPeer_ReliableWindowSize = 0x1000,
|
||||||
|
ENetPeer_TimeoutLimit = 32,
|
||||||
|
ENetPeer_TimeoutMaximum = 30000,
|
||||||
|
ENetPeer_TimeoutMinimum = 5000,
|
||||||
|
ENetPeer_UnsequencedWindows = 64,
|
||||||
|
ENetPeer_UnsequencedWindowSize = 1024,
|
||||||
|
ENetPeer_WindowSizeScale = 64 * 1024,
|
||||||
|
|
||||||
|
ENetProtocol_MaximumChannelCount = 255,
|
||||||
|
ENetProtocol_MaximumFragmentCount = 1024 * 1024,
|
||||||
|
ENetProtocol_MaximumMTU = 4096,
|
||||||
|
ENetProtocol_MaximumPacketCommands = 32,
|
||||||
|
ENetProtocol_MaximumPeerId = 0xFFF,
|
||||||
|
ENetProtocol_MaximumWindowSize = 65536,
|
||||||
|
ENetProtocol_MinimumChannelCount = 1,
|
||||||
|
ENetProtocol_MinimumMTU = 576,
|
||||||
|
ENetProtocol_MinimumWindowSize = 4096
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ENetPeerState
|
||||||
|
{
|
||||||
|
AcknowledgingConnect = 2,
|
||||||
|
AcknowledgingDisconnect = 8,
|
||||||
|
Connecting = 1,
|
||||||
|
ConnectionPending = 3,
|
||||||
|
ConnectionSucceeded = 4,
|
||||||
|
Connected = 5,
|
||||||
|
Disconnected = 0,
|
||||||
|
Disconnecting = 7,
|
||||||
|
DisconnectLater = 6,
|
||||||
|
Zombie = 9
|
||||||
|
};
|
||||||
|
|
||||||
|
enum ENetProtocolCommand
|
||||||
|
{
|
||||||
|
// Keeping the values is important for compatibility with the native ENet protocol
|
||||||
|
ENetProtocolCommand_Acknowledge = 1,
|
||||||
|
ENetProtocolCommand_BandwidthLimit = 10,
|
||||||
|
ENetProtocolCommand_Connect = 2,
|
||||||
|
ENetProtocolCommand_Disconnect = 4,
|
||||||
|
ENetProtocolCommand_None = 0,
|
||||||
|
ENetProtocolCommand_Ping = 5,
|
||||||
|
ENetProtocolCommand_SendFragment = 8,
|
||||||
|
ENetProtocolCommand_SendReliable = 6,
|
||||||
|
ENetProtocolCommand_SendUnreliable = 7,
|
||||||
|
ENetProtocolCommand_SendUnreliableFragment = 12,
|
||||||
|
ENetProtocolCommand_SendUnsequenced = 9,
|
||||||
|
ENetProtocolCommand_ThrottleConfigure = 11,
|
||||||
|
ENetProtocolCommand_VerifyConnect = 3,
|
||||||
|
ENetProtocolCommand_Count = 13,
|
||||||
|
|
||||||
|
ENetProtocolCommand_Mask = 0x0F
|
||||||
|
};
|
||||||
|
|
||||||
|
enum ENetProtocolFlag
|
||||||
|
{
|
||||||
|
ENetProtocolFlag_Acknowledge = (1 << 7),
|
||||||
|
ENetProtocolFlag_Unsequenced = (1 << 6),
|
||||||
|
|
||||||
|
ENetProtocolHeaderFlag_Compressed = (1 << 14),
|
||||||
|
ENetProtocolHeaderFlag_SentTime = (1 << 15),
|
||||||
|
ENetProtocolHeaderFlag_Mask = ENetProtocolHeaderFlag_Compressed | ENetProtocolHeaderFlag_SentTime,
|
||||||
|
|
||||||
|
ENetProtocolHeaderSessionMask = (3 << 12),
|
||||||
|
ENetProtocolHeaderSessionShift = 12
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ENetEventType
|
||||||
|
{
|
||||||
|
/** no event occurred within the specified time limit */
|
||||||
|
None,
|
||||||
|
|
||||||
|
/** a connection request initiated by enet_host_connect has completed.
|
||||||
|
* The peer field contains the peer which successfully connected.
|
||||||
|
*/
|
||||||
|
Connect,
|
||||||
|
|
||||||
|
/** a peer has disconnected. This event is generated on a successful
|
||||||
|
* completion of a disconnect initiated by enet_peer_disconnect, if
|
||||||
|
* a peer has timed out, or if a connection request initialized by
|
||||||
|
* enet_host_connect has timed out. The peer field contains the peer
|
||||||
|
* which disconnected. The data field contains user supplied data
|
||||||
|
* describing the disconnection, or 0, if none is available.
|
||||||
|
*/
|
||||||
|
Disconnect,
|
||||||
|
|
||||||
|
/** a packet has been received from a peer. The peer field specifies the
|
||||||
|
* peer which sent the packet. The channelID field specifies the channel
|
||||||
|
* number upon which the packet was received. The packet field contains
|
||||||
|
* the packet that was received; this packet must be destroyed with
|
||||||
|
* enet_packet_destroy after use.
|
||||||
|
*/
|
||||||
|
Receive
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetEvent
|
||||||
|
{
|
||||||
|
ENetEventType type;
|
||||||
|
ENetPeer* peer;
|
||||||
|
UInt8 channelId;
|
||||||
|
UInt32 data;
|
||||||
|
ENetPacketRef packet;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolHeader
|
||||||
|
{
|
||||||
|
UInt16 peerID;
|
||||||
|
UInt16 sentTime;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolCommandHeader
|
||||||
|
{
|
||||||
|
UInt8 command;
|
||||||
|
UInt8 channelID;
|
||||||
|
UInt16 reliableSequenceNumber;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolAcknowledge
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 receivedReliableSequenceNumber;
|
||||||
|
UInt16 receivedSentTime;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolConnect
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 outgoingPeerID;
|
||||||
|
UInt8 incomingSessionID;
|
||||||
|
UInt8 outgoingSessionID;
|
||||||
|
UInt32 mtu;
|
||||||
|
UInt32 windowSize;
|
||||||
|
UInt32 channelCount;
|
||||||
|
UInt32 incomingBandwidth;
|
||||||
|
UInt32 outgoingBandwidth;
|
||||||
|
UInt32 packetThrottleInterval;
|
||||||
|
UInt32 packetThrottleAcceleration;
|
||||||
|
UInt32 packetThrottleDeceleration;
|
||||||
|
UInt32 connectID;
|
||||||
|
UInt32 data;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolBandwidthLimit
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt32 incomingBandwidth;
|
||||||
|
UInt32 outgoingBandwidth;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolDisconnect
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt32 data;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolPing
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolSendFragment
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 startSequenceNumber;
|
||||||
|
UInt16 dataLength;
|
||||||
|
UInt32 fragmentCount;
|
||||||
|
UInt32 fragmentNumber;
|
||||||
|
UInt32 totalLength;
|
||||||
|
UInt32 fragmentOffset;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolSendReliable
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 dataLength;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolSendUnreliable
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 unreliableSequenceNumber;
|
||||||
|
UInt16 dataLength;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolSendUnsequenced
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 unsequencedGroup;
|
||||||
|
UInt16 dataLength;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolThrottleConfigure
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt32 packetThrottleInterval;
|
||||||
|
UInt32 packetThrottleAcceleration;
|
||||||
|
UInt32 packetThrottleDeceleration;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ENetProtocolVerifyConnect
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
UInt16 outgoingPeerID;
|
||||||
|
UInt8 incomingSessionID;
|
||||||
|
UInt8 outgoingSessionID;
|
||||||
|
UInt32 mtu;
|
||||||
|
UInt32 windowSize;
|
||||||
|
UInt32 channelCount;
|
||||||
|
UInt32 incomingBandwidth;
|
||||||
|
UInt32 outgoingBandwidth;
|
||||||
|
UInt32 packetThrottleInterval;
|
||||||
|
UInt32 packetThrottleAcceleration;
|
||||||
|
UInt32 packetThrottleDeceleration;
|
||||||
|
UInt32 connectID;
|
||||||
|
};
|
||||||
|
|
||||||
|
union ENetProtocol
|
||||||
|
{
|
||||||
|
ENetProtocolCommandHeader header;
|
||||||
|
ENetProtocolAcknowledge acknowledge;
|
||||||
|
ENetProtocolBandwidthLimit bandwidthLimit;
|
||||||
|
ENetProtocolConnect connect;
|
||||||
|
ENetProtocolDisconnect disconnect;
|
||||||
|
ENetProtocolPing ping;
|
||||||
|
ENetProtocolSendReliable sendReliable;
|
||||||
|
ENetProtocolSendUnreliable sendUnreliable;
|
||||||
|
ENetProtocolSendUnsequenced sendUnsequenced;
|
||||||
|
ENetProtocolSendFragment sendFragment;
|
||||||
|
ENetProtocolThrottleConfigure throttleConfigure;
|
||||||
|
ENetProtocolVerifyConnect verifyConnect;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // NAZARA_ENETPROTOCOL_HPP
|
||||||
|
|
@ -0,0 +1,743 @@
|
||||||
|
#include <Nazara/Network/ENetHost.hpp>
|
||||||
|
#include <Nazara/Core/Clock.hpp>
|
||||||
|
#include <Nazara/Core/Endianness.hpp>
|
||||||
|
#include <Nazara/Core/OffsetOf.hpp>
|
||||||
|
#include <Nazara/Network/ENetPeer.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
#define ENET_TIME_OVERFLOW 86400000
|
||||||
|
|
||||||
|
#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
|
||||||
|
#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
|
||||||
|
#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
|
||||||
|
#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
|
||||||
|
|
||||||
|
#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
/// Temporary
|
||||||
|
template<typename T>
|
||||||
|
T HostToNet(T value)
|
||||||
|
{
|
||||||
|
#ifdef NAZARA_LITTLE_ENDIAN
|
||||||
|
return SwapBytes(value);
|
||||||
|
#else
|
||||||
|
return value;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Temporary
|
||||||
|
template<typename T>
|
||||||
|
T NetToHost(T value)
|
||||||
|
{
|
||||||
|
#ifdef NAZARA_LITTLE_ENDIAN
|
||||||
|
return SwapBytes(value);
|
||||||
|
#else
|
||||||
|
return value;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ENetHost::Broadcast(UInt8 channelId, ENetPacketFlags flags, NetPacket&& packet)
|
||||||
|
{
|
||||||
|
ENetPacket* enetPacket = m_packetPool.New<ENetPacket>();
|
||||||
|
enetPacket->flags = flags;
|
||||||
|
enetPacket->data = std::move(packet);
|
||||||
|
enetPacket->owner = &m_packetPool;
|
||||||
|
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if (peer.m_state != ENetPeerState::Connected)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
peer.Send(channelId, enetPacket);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::Connect(const IpAddress& remoteAddress, std::size_t channelCount, UInt32 data)
|
||||||
|
{
|
||||||
|
NazaraAssert(remoteAddress.IsValid(), "Invalid remote address");
|
||||||
|
NazaraAssert(remoteAddress.GetPort() != 0, "Remote address has no port");
|
||||||
|
|
||||||
|
std::size_t peerId;
|
||||||
|
for (peerId = 0; peerId < m_peers.size(); ++peerId)
|
||||||
|
{
|
||||||
|
if (m_peers[peerId].m_state == ENetPeerState::Disconnected)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (peerId >= m_peers.size())
|
||||||
|
{
|
||||||
|
NazaraError("Insufficient peers");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
m_channelLimit = Clamp<std::size_t>(channelCount, ENetConstants::ENetProtocol_MinimumChannelCount, ENetConstants::ENetProtocol_MaximumChannelCount);
|
||||||
|
|
||||||
|
UInt32 windowSize;
|
||||||
|
if (m_outgoingBandwidth == 0)
|
||||||
|
windowSize = ENetProtocol_MaximumWindowSize;
|
||||||
|
else
|
||||||
|
windowSize = (m_outgoingBandwidth / ENetConstants::ENetPeer_WindowSizeScale) * ENetProtocol_MinimumWindowSize;
|
||||||
|
|
||||||
|
ENetPeer& peer = m_peers[peerId];
|
||||||
|
peer.InitOutgoing(channelCount, remoteAddress, ++m_randomSeed, windowSize);
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_Connect | ENetProtocolFlag_Acknowledge;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
|
||||||
|
command.connect.channelCount = HostToNet(static_cast<UInt32>(channelCount));
|
||||||
|
command.connect.connectID = peer.m_connectID;
|
||||||
|
command.connect.data = HostToNet(data);
|
||||||
|
command.connect.incomingBandwidth = HostToNet(m_incomingBandwidth);
|
||||||
|
command.connect.incomingSessionID = peer.m_incomingSessionID;
|
||||||
|
command.connect.mtu = HostToNet(peer.m_mtu);
|
||||||
|
command.connect.outgoingBandwidth = HostToNet(m_outgoingBandwidth);
|
||||||
|
command.connect.outgoingPeerID = HostToNet(peer.m_incomingPeerID);
|
||||||
|
command.connect.outgoingSessionID = peer.m_outgoingSessionID;
|
||||||
|
command.connect.packetThrottleAcceleration = HostToNet(peer.m_packetThrottleAcceleration);
|
||||||
|
command.connect.packetThrottleDeceleration = HostToNet(peer.m_packetThrottleDeceleration);
|
||||||
|
command.connect.packetThrottleInterval = HostToNet(peer.m_packetThrottleInterval);
|
||||||
|
command.connect.windowSize = HostToNet(peer.m_windowSize);
|
||||||
|
|
||||||
|
peer.QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::Connect(const String& hostName, NetProtocol protocol, const String& service, ResolveError* error, std::size_t channelCount, UInt32 data)
|
||||||
|
{
|
||||||
|
std::vector<HostnameInfo> results = IpAddress::ResolveHostname(protocol, hostName, service, error);
|
||||||
|
if (results.empty())
|
||||||
|
return false;
|
||||||
|
|
||||||
|
IpAddress hostnameAddress;
|
||||||
|
for (const HostnameInfo& result : results)
|
||||||
|
{
|
||||||
|
if (!result.address)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (result.socketType != SocketType_UDP)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
hostnameAddress = result.address;
|
||||||
|
break; //< Take first valid address
|
||||||
|
}
|
||||||
|
|
||||||
|
return Connect(hostnameAddress, channelCount, data);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount)
|
||||||
|
{
|
||||||
|
return Create(address, peerCount, channelCount, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount, UInt32 incomingBandwidth, UInt32 outgoingBandwidth)
|
||||||
|
{
|
||||||
|
NazaraAssert(address.IsValid(), "Invalid listening address");
|
||||||
|
|
||||||
|
if (peerCount > ENetConstants::ENetProtocol_MaximumPeerId)
|
||||||
|
{
|
||||||
|
NazaraError("Peer count exceeds maximum peer count supported by protocol (" + String::Number(ENetConstants::ENetProtocol_MaximumPeerId) + ")");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!InitSocket(address))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
m_peers.resize(peerCount);
|
||||||
|
|
||||||
|
m_address = address;
|
||||||
|
m_randomSeed = *reinterpret_cast<UInt32*>(this);
|
||||||
|
m_randomSeed += s_randomGenerator();
|
||||||
|
m_randomSeed = (m_randomSeed << 16) | (m_randomSeed >> 16);
|
||||||
|
m_channelLimit = Clamp<std::size_t>(channelCount, ENetConstants::ENetProtocol_MinimumChannelCount, ENetConstants::ENetProtocol_MaximumChannelCount);
|
||||||
|
m_incomingBandwidth = incomingBandwidth;
|
||||||
|
m_outgoingBandwidth = outgoingBandwidth;
|
||||||
|
m_bandwidthThrottleEpoch = 0;
|
||||||
|
m_recalculateBandwidthLimits = false;
|
||||||
|
m_mtu = ENetConstants::ENetHost_DefaultMTU;
|
||||||
|
m_commandCount = 0;
|
||||||
|
m_bufferCount = 0;
|
||||||
|
m_receivedAddress = IpAddress::AnyIpV4;
|
||||||
|
m_receivedData = nullptr;
|
||||||
|
m_receivedDataLength = 0;
|
||||||
|
|
||||||
|
m_totalSentData = 0;
|
||||||
|
m_totalSentPackets = 0;
|
||||||
|
m_totalReceivedData = 0;
|
||||||
|
m_totalReceivedPackets = 0;
|
||||||
|
|
||||||
|
m_bandwidthLimitedPeers = 0;
|
||||||
|
m_connectedPeers = 0;
|
||||||
|
m_duplicatePeers = ENetConstants::ENetProtocol_MaximumPeerId;
|
||||||
|
m_maximumPacketSize = ENetConstants::ENetHost_DefaultMaximumPacketSize;
|
||||||
|
m_maximumWaitingData = ENetConstants::ENetHost_DefaultMaximumWaitingData;
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetHost::Flush()
|
||||||
|
{
|
||||||
|
m_serviceTime = GetElapsedMilliseconds();
|
||||||
|
|
||||||
|
SendOutgoingCommands(nullptr, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
int ENetHost::Service(ENetEvent* event, UInt32 timeout)
|
||||||
|
{
|
||||||
|
UInt32 waitCondition;
|
||||||
|
|
||||||
|
if (event)
|
||||||
|
{
|
||||||
|
event->type = ENetEventType::None;
|
||||||
|
event->peer = nullptr;
|
||||||
|
event->packet = nullptr;
|
||||||
|
|
||||||
|
if (DispatchIncomingCommands(event))
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
m_serviceTime = GetElapsedMilliseconds();
|
||||||
|
timeout += m_serviceTime;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
if (ENET_TIME_DIFFERENCE(m_serviceTime, m_bandwidthThrottleEpoch) >= ENetConstants::ENetHost_BandwidthThrottleInterval)
|
||||||
|
ThrottleBandwidth();
|
||||||
|
|
||||||
|
switch (SendOutgoingCommands(event, true))
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
case -1:
|
||||||
|
#ifdef ENET_DEBUG
|
||||||
|
perror("Error sending outgoing packets");
|
||||||
|
#endif
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (ReceiveIncomingCommands(event))
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
case -1:
|
||||||
|
#ifdef ENET_DEBUG
|
||||||
|
perror("Error receiving incoming packets");
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (SendOutgoingCommands(event, 1))
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
case -1:
|
||||||
|
#ifdef ENET_DEBUG
|
||||||
|
perror("Error sending outgoing packets");
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (event)
|
||||||
|
{
|
||||||
|
switch (DispatchIncomingCommands(event))
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
case -1:
|
||||||
|
#ifdef ENET_DEBUG
|
||||||
|
perror("Error dispatching incoming packets");
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ENET_TIME_GREATER_EQUAL(m_serviceTime, timeout))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
m_serviceTime = GetElapsedMilliseconds();
|
||||||
|
|
||||||
|
if (ENET_TIME_GREATER_EQUAL(m_serviceTime, timeout))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
SocketError error;
|
||||||
|
if (m_poller.Wait(ENET_TIME_DIFFERENCE(timeout, m_serviceTime), &error))
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (error != SocketError_NoError)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
m_serviceTime = GetElapsedMilliseconds();
|
||||||
|
}
|
||||||
|
while (m_poller.IsReady(m_socket));
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::InitSocket(const IpAddress& address)
|
||||||
|
{
|
||||||
|
if (!m_socket.Create(address.GetProtocol()))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
m_socket.EnableBlocking(false);
|
||||||
|
m_socket.EnableBroadcasting(true);
|
||||||
|
m_socket.SetReceiveBufferSize(ENetConstants::ENetHost_ReceiveBufferSize);
|
||||||
|
m_socket.SetSendBufferSize(ENetConstants::ENetHost_SendBufferSize);
|
||||||
|
|
||||||
|
if (!address.IsLoopback())
|
||||||
|
{
|
||||||
|
if (m_socket.Bind(address) != SocketState_Bound)
|
||||||
|
{
|
||||||
|
NazaraError("Failed to bind address " + address.ToString());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
m_poller.RegisterSocket(m_socket);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::DispatchIncomingCommands(ENetEvent* event)
|
||||||
|
{
|
||||||
|
for (std::size_t bit = m_dispatchQueue.FindFirst(); bit != m_dispatchQueue.npos; bit = m_dispatchQueue.FindNext(bit))
|
||||||
|
{
|
||||||
|
m_dispatchQueue.Reset(bit);
|
||||||
|
|
||||||
|
ENetPeer& peer = m_peers[bit];
|
||||||
|
switch (peer.m_state)
|
||||||
|
{
|
||||||
|
case ENetPeerState::ConnectionPending:
|
||||||
|
case ENetPeerState::ConnectionSucceeded:
|
||||||
|
peer.ChangeState(ENetPeerState::Connected);
|
||||||
|
|
||||||
|
event->type = ENetEventType::Connect;
|
||||||
|
event->peer = &peer;
|
||||||
|
event->data = peer.m_eventData;
|
||||||
|
return true;
|
||||||
|
|
||||||
|
case ENetPeerState::Zombie:
|
||||||
|
m_recalculateBandwidthLimits = true;
|
||||||
|
|
||||||
|
event->type = ENetEventType::Disconnect;
|
||||||
|
event->peer = &peer;
|
||||||
|
event->data = peer.m_eventData;
|
||||||
|
|
||||||
|
peer.Reset();
|
||||||
|
return true;
|
||||||
|
|
||||||
|
case ENetPeerState::Connected:
|
||||||
|
if (peer.m_dispatchedCommands.empty())
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (!peer.Receive(&event->packet, &event->channelId))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
event->type = ENetEventType::Receive;
|
||||||
|
event->peer = &peer;
|
||||||
|
|
||||||
|
if (!peer.m_dispatchedCommands.empty())
|
||||||
|
AddToDispatchQueue(&peer);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPeer* ENetHost::HandleConnect(ENetProtocolHeader* header, ENetProtocol* command)
|
||||||
|
{
|
||||||
|
UInt32 channelCount = NetToHost(command->connect.channelCount);
|
||||||
|
|
||||||
|
if (channelCount < ENetProtocol_MinimumChannelCount || channelCount > ENetProtocol_MaximumChannelCount)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
|
std::size_t duplicatePeers = 0;
|
||||||
|
ENetPeer* peer = nullptr;
|
||||||
|
for (ENetPeer& currentPeer : m_peers)
|
||||||
|
{
|
||||||
|
if (currentPeer.m_state == ENetPeerState::Disconnected)
|
||||||
|
{
|
||||||
|
if (!peer)
|
||||||
|
peer = ¤tPeer;
|
||||||
|
}
|
||||||
|
else if (currentPeer.m_state != ENetPeerState::Connecting)
|
||||||
|
{
|
||||||
|
// Compare users without comparing their port
|
||||||
|
IpAddress first(currentPeer.m_address);
|
||||||
|
first.SetPort(0);
|
||||||
|
|
||||||
|
IpAddress second(m_receivedAddress);
|
||||||
|
second.SetPort(0);
|
||||||
|
|
||||||
|
if (first == second)
|
||||||
|
{
|
||||||
|
if (currentPeer.m_address.GetPort() == m_receivedAddress.GetPort() && currentPeer.m_connectID == command->connect.connectID)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
|
++duplicatePeers;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!peer || duplicatePeers >= m_duplicatePeers)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
|
channelCount = std::min(channelCount, m_channelLimit);
|
||||||
|
|
||||||
|
peer->InitIncoming(channelCount, m_receivedAddress, command->connect);
|
||||||
|
|
||||||
|
UInt32 windowSize;
|
||||||
|
if (m_incomingBandwidth == 0)
|
||||||
|
windowSize = ENetConstants::ENetProtocol_MaximumWindowSize;
|
||||||
|
else
|
||||||
|
windowSize = (m_incomingBandwidth / ENetConstants::ENetPeer_WindowSizeScale) * ENetConstants::ENetProtocol_MinimumWindowSize;
|
||||||
|
|
||||||
|
windowSize = std::max(windowSize, NetToHost(command->connect.windowSize));
|
||||||
|
windowSize = Clamp<UInt32>(windowSize, ENetConstants::ENetProtocol_MinimumWindowSize, ENetConstants::ENetProtocol_MaximumWindowSize);
|
||||||
|
|
||||||
|
ENetProtocol verifyCommand;
|
||||||
|
verifyCommand.header.command = ENetProtocolCommand_VerifyConnect | ENetProtocolFlag_Acknowledge;
|
||||||
|
verifyCommand.header.channelID = 0xFF;
|
||||||
|
verifyCommand.verifyConnect.outgoingPeerID = HostToNet(peer->m_incomingPeerID);
|
||||||
|
verifyCommand.verifyConnect.incomingSessionID = peer->m_outgoingSessionID;
|
||||||
|
verifyCommand.verifyConnect.outgoingSessionID = peer->m_incomingSessionID;
|
||||||
|
verifyCommand.verifyConnect.mtu = HostToNet(peer->m_mtu);
|
||||||
|
verifyCommand.verifyConnect.windowSize = HostToNet(windowSize);
|
||||||
|
verifyCommand.verifyConnect.channelCount = HostToNet(channelCount);
|
||||||
|
verifyCommand.verifyConnect.incomingBandwidth = HostToNet(m_incomingBandwidth);
|
||||||
|
verifyCommand.verifyConnect.outgoingBandwidth = HostToNet(m_outgoingBandwidth);
|
||||||
|
verifyCommand.verifyConnect.packetThrottleInterval = HostToNet(peer->m_packetThrottleInterval);
|
||||||
|
verifyCommand.verifyConnect.packetThrottleAcceleration = HostToNet(peer->m_packetThrottleAcceleration);
|
||||||
|
verifyCommand.verifyConnect.packetThrottleDeceleration = HostToNet(peer->m_packetThrottleDeceleration);
|
||||||
|
verifyCommand.verifyConnect.connectID = peer->m_connectID;
|
||||||
|
|
||||||
|
peer->QueueOutgoingCommand(verifyCommand, nullptr, 0, 0);
|
||||||
|
|
||||||
|
return peer;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::HandleIncomingCommands(ENetEvent* event)
|
||||||
|
{
|
||||||
|
if (m_receivedDataLength < NazaraOffsetOf(ENetProtocolHeader, sentTime))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
ENetProtocolHeader* header = reinterpret_cast<ENetProtocolHeader*>(m_receivedData);
|
||||||
|
|
||||||
|
peerID = NetToHost(header->peerID);
|
||||||
|
sessionID = (peerID & ENET_PROTOCOL_HEADER_SESSION_MASK) >> ENET_PROTOCOL_HEADER_SESSION_SHIFT;
|
||||||
|
flags = peerID & ENET_PROTOCOL_HEADER_FLAG_MASK;
|
||||||
|
peerID &= ~(ENET_PROTOCOL_HEADER_FLAG_MASK | ENET_PROTOCOL_HEADER_SESSION_MASK);
|
||||||
|
|
||||||
|
headerSize = (flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME ? sizeof(ENetProtocolHeader) : (size_t) & ((ENetProtocolHeader *)0)->sentTime);
|
||||||
|
if (host->checksum != NULL)
|
||||||
|
headerSize += sizeof(enet_uint32);
|
||||||
|
|
||||||
|
if (peerID == ENET_PROTOCOL_MAXIMUM_PEER_ID)
|
||||||
|
peer = NULL;
|
||||||
|
else
|
||||||
|
if (peerID >= host->peerCount)
|
||||||
|
return 0;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
peer = &host->peers[peerID];
|
||||||
|
|
||||||
|
if (peer->state == ENET_PEER_STATE_DISCONNECTED ||
|
||||||
|
peer->state == ENET_PEER_STATE_ZOMBIE ||
|
||||||
|
((host->receivedAddress.host != peer->address.host ||
|
||||||
|
host->receivedAddress.port != peer->address.port) &&
|
||||||
|
peer->address.host != ENET_HOST_BROADCAST) ||
|
||||||
|
(peer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID &&
|
||||||
|
sessionID != peer->incomingSessionID))
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::HandleSendReliable(ENetPeer& peer, const ENetProtocol& command, UInt8** currentData)
|
||||||
|
{
|
||||||
|
if (command.header.channelID >= peer.m_channels.size() || (peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
UInt16 dataLength = NetToHost(command.sendReliable.dataLength);
|
||||||
|
*currentData += dataLength;
|
||||||
|
if (dataLength >= m_maximumPacketSize || *currentData < m_receivedData || *currentData > &m_receivedData[m_receivedDataLength])
|
||||||
|
return false;
|
||||||
|
|
||||||
|
if (!peer.QueueIncomingCommand(command, co))
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ENetHost::ReceiveIncomingCommands(ENetEvent* event)
|
||||||
|
{
|
||||||
|
for (unsigned int i = 0; i < 256; ++i)
|
||||||
|
{
|
||||||
|
NetPacket packet;
|
||||||
|
|
||||||
|
std::size_t receivedLength;
|
||||||
|
if (!m_socket.Receive(m_packetData[0].data(), m_packetData[0].size(), &m_receivedAddress, &receivedLength))
|
||||||
|
return -1; //< Error
|
||||||
|
|
||||||
|
if (receivedLength == 0)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
m_receivedData = m_packetData[0].data();
|
||||||
|
m_receivedDataLength = receivedLength;
|
||||||
|
|
||||||
|
m_totalReceivedData += receivedLength;
|
||||||
|
m_totalReceivedPackets++;
|
||||||
|
|
||||||
|
// Intercept
|
||||||
|
|
||||||
|
switch (HandleIncomingCommands(event))
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
case -1:
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetHost::NotifyConnect(ENetPeer* peer, ENetEvent* event)
|
||||||
|
{
|
||||||
|
m_recalculateBandwidthLimits = true;
|
||||||
|
|
||||||
|
if (event)
|
||||||
|
{
|
||||||
|
peer->ChangeState(ENetPeerState::Connected);
|
||||||
|
|
||||||
|
event->type = ENetEventType::Connect;
|
||||||
|
event->peer = peer;
|
||||||
|
event->data = peer->m_eventData;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
peer->DispatchState(peer->m_state == ENetPeerState::Connecting ? ENetPeerState::ConnectionSucceeded : ENetPeerState::ConnectionPending);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetHost::NotifyDisconnect(ENetPeer* peer, ENetEvent* event)
|
||||||
|
{
|
||||||
|
if (peer->m_state >= ENetPeerState::ConnectionPending)
|
||||||
|
m_recalculateBandwidthLimits = true;
|
||||||
|
|
||||||
|
if (peer->m_state != ENetPeerState::Connecting && (peer->m_state < ENetPeerState::ConnectionSucceeded))
|
||||||
|
peer->Reset();
|
||||||
|
else if (event)
|
||||||
|
{
|
||||||
|
event->type = ENetEventType::Disconnect;
|
||||||
|
event->peer = peer;
|
||||||
|
event->data = peer->m_eventData;
|
||||||
|
|
||||||
|
peer->Reset();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
peer->m_eventData = 0;
|
||||||
|
|
||||||
|
peer->DispatchState(ENetPeerState::Zombie);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetHost::ThrottleBandwidth()
|
||||||
|
{
|
||||||
|
UInt32 currentTime = GetElapsedMilliseconds();
|
||||||
|
UInt32 elapsedTime = currentTime - m_bandwidthThrottleEpoch;
|
||||||
|
|
||||||
|
if (elapsedTime < ENetConstants::ENetHost_BandwidthThrottleInterval)
|
||||||
|
return;
|
||||||
|
|
||||||
|
m_bandwidthThrottleEpoch = currentTime;
|
||||||
|
|
||||||
|
if (m_connectedPeers == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
UInt32 dataTotal = ~0;
|
||||||
|
UInt32 bandwidth = ~0;
|
||||||
|
|
||||||
|
if (m_outgoingBandwidth != 0)
|
||||||
|
{
|
||||||
|
bandwidth = (m_outgoingBandwidth * elapsedTime) / 1000;
|
||||||
|
|
||||||
|
dataTotal = 0;
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if (peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
dataTotal += peer.m_outgoingDataTotal;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32 peersRemaining = m_connectedPeers;
|
||||||
|
UInt32 bandwidthLimit = ~0;
|
||||||
|
UInt32 throttle = ~0;
|
||||||
|
bool needsAdjustment = m_bandwidthLimitedPeers > 0;
|
||||||
|
|
||||||
|
while (peersRemaining > 0 && needsAdjustment)
|
||||||
|
{
|
||||||
|
needsAdjustment = false;
|
||||||
|
|
||||||
|
if (dataTotal <= bandwidth)
|
||||||
|
throttle = ENetConstants::ENetPeer_PacketThrottleScale;
|
||||||
|
else
|
||||||
|
throttle = (bandwidth * ENetConstants::ENetPeer_PacketThrottleScale) / dataTotal;
|
||||||
|
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if ((peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater) ||
|
||||||
|
peer.m_incomingBandwidth == 0 || peer.m_outgoingBandwidthThrottleEpoch == currentTime)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
UInt32 peerBandwidth = (peer.m_incomingBandwidth * elapsedTime) / 1000;
|
||||||
|
if ((throttle * peer.m_outgoingDataTotal) / ENetConstants::ENetPeer_PacketThrottleScale <= peerBandwidth)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
peer.m_packetThrottleLimit = (peerBandwidth * ENetConstants::ENetPeer_PacketThrottleScale) / peer.m_outgoingDataTotal;
|
||||||
|
|
||||||
|
if (peer.m_packetThrottleLimit == 0)
|
||||||
|
peer.m_packetThrottleLimit = 1;
|
||||||
|
|
||||||
|
if (peer.m_packetThrottle > peer.m_packetThrottleLimit)
|
||||||
|
peer.m_packetThrottle = peer.m_packetThrottleLimit;
|
||||||
|
|
||||||
|
peer.m_outgoingBandwidthThrottleEpoch = currentTime;
|
||||||
|
|
||||||
|
peer.m_incomingDataTotal = 0;
|
||||||
|
peer.m_outgoingDataTotal = 0;
|
||||||
|
|
||||||
|
needsAdjustment = true;
|
||||||
|
--peersRemaining;
|
||||||
|
bandwidth -= peerBandwidth;
|
||||||
|
dataTotal -= peerBandwidth;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (peersRemaining > 0)
|
||||||
|
{
|
||||||
|
if (dataTotal <= bandwidth)
|
||||||
|
throttle = ENetConstants::ENetPeer_PacketThrottleScale;
|
||||||
|
else
|
||||||
|
throttle = (bandwidth * ENetConstants::ENetPeer_PacketThrottleScale) / dataTotal;
|
||||||
|
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if ((peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater) ||
|
||||||
|
peer.m_outgoingBandwidthThrottleEpoch == currentTime)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
peer.m_packetThrottleLimit = throttle;
|
||||||
|
|
||||||
|
if (peer.m_packetThrottle > peer.m_packetThrottleLimit)
|
||||||
|
peer.m_packetThrottle = peer.m_packetThrottleLimit;
|
||||||
|
|
||||||
|
peer.m_incomingDataTotal = 0;
|
||||||
|
peer.m_outgoingDataTotal = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (m_recalculateBandwidthLimits)
|
||||||
|
{
|
||||||
|
m_recalculateBandwidthLimits = false;
|
||||||
|
|
||||||
|
peersRemaining = m_connectedPeers;
|
||||||
|
bandwidth = m_incomingBandwidth;
|
||||||
|
needsAdjustment = true;
|
||||||
|
|
||||||
|
if (bandwidth == 0)
|
||||||
|
bandwidthLimit = 0;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
while (peersRemaining > 0 && needsAdjustment)
|
||||||
|
{
|
||||||
|
needsAdjustment = false;
|
||||||
|
bandwidthLimit = bandwidth / peersRemaining;
|
||||||
|
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if ((peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater) ||
|
||||||
|
peer.m_incomingBandwidthThrottleEpoch == currentTime)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (peer.m_outgoingBandwidth > 0 && peer.m_outgoingBandwidth >= bandwidthLimit)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
peer.m_incomingBandwidthThrottleEpoch = currentTime;
|
||||||
|
|
||||||
|
needsAdjustment = true;
|
||||||
|
--peersRemaining;
|
||||||
|
bandwidth -= peer.m_outgoingBandwidth;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (ENetPeer& peer : m_peers)
|
||||||
|
{
|
||||||
|
if (peer.m_state != ENetPeerState::Connected && peer.m_state != ENetPeerState::DisconnectLater)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_BandwidthLimit | ENetProtocolFlag_Acknowledge;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
command.bandwidthLimit.outgoingBandwidth = HostToNet(m_outgoingBandwidth);
|
||||||
|
|
||||||
|
if (peer.m_incomingBandwidthThrottleEpoch == currentTime)
|
||||||
|
command.bandwidthLimit.incomingBandwidth = HostToNet(peer.m_outgoingBandwidth);
|
||||||
|
else
|
||||||
|
command.bandwidthLimit.incomingBandwidth = HostToNet(bandwidthLimit);
|
||||||
|
|
||||||
|
peer.QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetHost::Initialize()
|
||||||
|
{
|
||||||
|
std::random_device device;
|
||||||
|
s_randomGenerator.seed(device());
|
||||||
|
s_randomGenerator64.seed(device());
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetHost::Uninitialize()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
std::mt19937 ENetHost::s_randomGenerator;
|
||||||
|
std::mt19937_64 ENetHost::s_randomGenerator64;
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,23 @@
|
||||||
|
#include <Nazara/Network/ENetPacket.hpp>
|
||||||
|
#include <Nazara/Core/MemoryPool.hpp>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
/// Temporary
|
||||||
|
void ENetPacketRef::Reset(ENetPacket* packet = nullptr)
|
||||||
|
{
|
||||||
|
if (m_packet)
|
||||||
|
{
|
||||||
|
if (--m_packet->referenceCount == 0)
|
||||||
|
{
|
||||||
|
m_packet->owner->Delete(m_packet);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
m_packet = packet;
|
||||||
|
if (m_packet)
|
||||||
|
m_packet->referenceCount++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,885 @@
|
||||||
|
#include <Nazara/Network/ENetPeer.hpp>
|
||||||
|
#include <Nazara/Core/Endianness.hpp>
|
||||||
|
#include <Nazara/Network/ENetHost.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
/// Temporary
|
||||||
|
template<typename T>
|
||||||
|
T HostToNet(T value)
|
||||||
|
{
|
||||||
|
#ifdef NAZARA_LITTLE_ENDIAN
|
||||||
|
return SwapBytes(value);
|
||||||
|
#else
|
||||||
|
return value;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Temporary
|
||||||
|
template<typename T>
|
||||||
|
T NetToHost(T value)
|
||||||
|
{
|
||||||
|
#ifdef NAZARA_LITTLE_ENDIAN
|
||||||
|
return SwapBytes(value);
|
||||||
|
#else
|
||||||
|
return value;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace
|
||||||
|
{
|
||||||
|
static std::size_t commandSizes[ENetProtocolCommand_Count] =
|
||||||
|
{
|
||||||
|
0,
|
||||||
|
sizeof(ENetProtocolAcknowledge),
|
||||||
|
sizeof(ENetProtocolConnect),
|
||||||
|
sizeof(ENetProtocolVerifyConnect),
|
||||||
|
sizeof(ENetProtocolDisconnect),
|
||||||
|
sizeof(ENetProtocolPing),
|
||||||
|
sizeof(ENetProtocolSendReliable),
|
||||||
|
sizeof(ENetProtocolSendUnreliable),
|
||||||
|
sizeof(ENetProtocolSendFragment),
|
||||||
|
sizeof(ENetProtocolSendUnsequenced),
|
||||||
|
sizeof(ENetProtocolBandwidthLimit),
|
||||||
|
sizeof(ENetProtocolThrottleConfigure),
|
||||||
|
sizeof(ENetProtocolSendFragment)
|
||||||
|
};
|
||||||
|
|
||||||
|
std::size_t enet_protocol_command_size(UInt8 commandNumber)
|
||||||
|
{
|
||||||
|
return commandSizes[commandNumber & ENetProtocolCommand_Mask];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPeer::ENetPeer(ENetHost* host, UInt16 peerId) :
|
||||||
|
m_packetPool(sizeof(ENetPacket)),
|
||||||
|
m_host(host),
|
||||||
|
m_incomingPeerID(peerId),
|
||||||
|
m_incomingSessionID(0xFF),
|
||||||
|
m_outgoingSessionID(0xFF)
|
||||||
|
{
|
||||||
|
Reset();
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::Disconnect(UInt32 data)
|
||||||
|
{
|
||||||
|
if (m_state == ENetPeerState::Disconnecting ||
|
||||||
|
m_state == ENetPeerState::Disconnected ||
|
||||||
|
m_state == ENetPeerState::AcknowledgingDisconnect ||
|
||||||
|
m_state == ENetPeerState::Zombie)
|
||||||
|
return;
|
||||||
|
|
||||||
|
ResetQueues();
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_Disconnect;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
command.disconnect.data = HostToNet(data);
|
||||||
|
|
||||||
|
if (m_state == ENetPeerState::Connected || m_state == ENetPeerState::DisconnectLater)
|
||||||
|
command.header.command |= ENetProtocolFlag_Acknowledge;
|
||||||
|
else
|
||||||
|
command.header.command |= ENetProtocolFlag_Unsequenced;
|
||||||
|
|
||||||
|
QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
|
||||||
|
if (m_state == ENetPeerState::Connected || m_state == ENetPeerState::DisconnectLater)
|
||||||
|
{
|
||||||
|
OnDisconnect();
|
||||||
|
|
||||||
|
m_state = ENetPeerState::Disconnecting;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
m_host->Flush();
|
||||||
|
|
||||||
|
Reset();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::DisconnectLater(UInt32 data)
|
||||||
|
{
|
||||||
|
if ((m_state == ENetPeerState::Connected || m_state == ENetPeerState::DisconnectLater) &&
|
||||||
|
!m_outgoingReliableCommands.empty() &&
|
||||||
|
!m_outgoingUnreliableCommands.empty() &&
|
||||||
|
!m_sentReliableCommands.empty())
|
||||||
|
{
|
||||||
|
m_state = ENetPeerState::DisconnectLater;
|
||||||
|
m_eventData = data;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
Disconnect(data);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::DisconnectNow(UInt32 data)
|
||||||
|
{
|
||||||
|
if (m_state == ENetPeerState::Disconnected)
|
||||||
|
return;
|
||||||
|
|
||||||
|
if (m_state != ENetPeerState::Zombie && m_state != ENetPeerState::Disconnecting)
|
||||||
|
{
|
||||||
|
ResetQueues();
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_Disconnect | ENetProtocolFlag_Unsequenced;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
command.disconnect.data = HostToNet(data);
|
||||||
|
|
||||||
|
QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
|
||||||
|
m_host->Flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
Reset();
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::Ping()
|
||||||
|
{
|
||||||
|
if (m_state != ENetPeerState::Connected)
|
||||||
|
return;
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_Ping | ENetProtocolFlag_Acknowledge;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
|
||||||
|
QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetPeer::Receive(ENetPacketRef* packet, UInt8* channelId)
|
||||||
|
{
|
||||||
|
if (m_dispatchedCommands.empty())
|
||||||
|
return false;
|
||||||
|
|
||||||
|
IncomingCommmand& incomingCommand = m_dispatchedCommands.front();
|
||||||
|
|
||||||
|
m_totalWaitingData -= incomingCommand.packet->data.GetSize();
|
||||||
|
|
||||||
|
if (packet)
|
||||||
|
*packet = std::move(incomingCommand.packet);
|
||||||
|
|
||||||
|
if (channelId)
|
||||||
|
*channelId = incomingCommand.command.header.channelID;
|
||||||
|
|
||||||
|
m_dispatchedCommands.pop_front();
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::Reset()
|
||||||
|
{
|
||||||
|
OnDisconnect();
|
||||||
|
|
||||||
|
m_outgoingPeerID = ENetConstants::ENetProtocol_MaximumPeerId;
|
||||||
|
m_connectID = 0;
|
||||||
|
|
||||||
|
m_state = ENetPeerState::Disconnected;
|
||||||
|
|
||||||
|
m_incomingBandwidth = 0;
|
||||||
|
m_outgoingBandwidth = 0;
|
||||||
|
m_incomingBandwidthThrottleEpoch = 0;
|
||||||
|
m_outgoingBandwidthThrottleEpoch = 0;
|
||||||
|
m_incomingDataTotal = 0;
|
||||||
|
m_outgoingDataTotal = 0;
|
||||||
|
m_lastSendTime = 0;
|
||||||
|
m_lastReceiveTime = 0;
|
||||||
|
m_nextTimeout = 0;
|
||||||
|
m_earliestTimeout = 0;
|
||||||
|
m_packetLossEpoch = 0;
|
||||||
|
m_packetsSent = 0;
|
||||||
|
m_packetsLost = 0;
|
||||||
|
m_packetLoss = 0;
|
||||||
|
m_packetLossVariance = 0;
|
||||||
|
m_packetThrottle = ENetConstants::ENetProtocol_MaximumWindowSize;
|
||||||
|
m_packetThrottleLimit = ENetConstants::ENetPeer_PacketThrottleScale;
|
||||||
|
m_packetThrottleCounter = 0;
|
||||||
|
m_packetThrottleEpoch = 0;
|
||||||
|
m_packetThrottleAcceleration = ENetConstants::ENetPeer_PacketThrottleAcceleration;
|
||||||
|
m_packetThrottleDeceleration = ENetConstants::ENetPeer_PacketThrottleDeceleration;
|
||||||
|
m_packetThrottleInterval = ENetConstants::ENetPeer_PacketThrottleInterval;
|
||||||
|
m_pingInterval = ENetConstants::ENetPeer_PingInterval;
|
||||||
|
m_timeoutLimit = ENetConstants::ENetPeer_TimeoutLimit;
|
||||||
|
m_timeoutMinimum = ENetConstants::ENetPeer_TimeoutMinimum;
|
||||||
|
m_timeoutMaximum = ENetConstants::ENetPeer_TimeoutMaximum;
|
||||||
|
m_lastRoundTripTime = ENetConstants::ENetPeer_DefaultRoundTripTime;
|
||||||
|
m_lowestRoundTripTime = ENetConstants::ENetPeer_DefaultRoundTripTime;
|
||||||
|
m_lastRoundTripTimeVariance = 0;
|
||||||
|
m_highestRoundTripTimeVariance = 0;
|
||||||
|
m_roundTripTime = ENetConstants::ENetPeer_DefaultRoundTripTime;
|
||||||
|
m_roundTripTimeVariance = 0;
|
||||||
|
m_mtu = m_host->m_mtu;
|
||||||
|
m_reliableDataInTransit = 0;
|
||||||
|
m_outgoingReliableSequenceNumber = 0;
|
||||||
|
m_windowSize = ENetConstants::ENetProtocol_MaximumWindowSize;
|
||||||
|
m_incomingUnsequencedGroup = 0;
|
||||||
|
m_outgoingUnsequencedGroup = 0;
|
||||||
|
m_eventData = 0;
|
||||||
|
m_totalWaitingData = 0;
|
||||||
|
|
||||||
|
std::memset(m_unsequencedWindow, 0, sizeof(m_unsequencedWindow));
|
||||||
|
|
||||||
|
ResetQueues();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetPeer::Send(UInt8 channelId, ENetPacketFlags flags, NetPacket&& packet)
|
||||||
|
{
|
||||||
|
ENetPacket* enetPacket = m_packetPool.New<ENetPacket>();
|
||||||
|
enetPacket->flags = flags;
|
||||||
|
enetPacket->data = std::move(packet);
|
||||||
|
enetPacket->owner = &m_packetPool;
|
||||||
|
|
||||||
|
return Send(channelId, enetPacket);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetPeer::Send(UInt8 channelId, ENetPacketRef packetRef)
|
||||||
|
{
|
||||||
|
if (m_state != ENetPeerState::Connected || channelId >= m_channels.size() || packetRef->data.GetSize() > m_host->m_maximumPacketSize)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
Channel& channel = m_channels[channelId];
|
||||||
|
|
||||||
|
std::size_t fragmentLength = m_mtu - sizeof(ENetProtocolHeader) - sizeof(ENetProtocolSendFragment);
|
||||||
|
//if (m_host->m_checksum != nullptr)
|
||||||
|
// fragmentLength -= sizeof(UInt32);
|
||||||
|
|
||||||
|
UInt32 packetSize = static_cast<UInt32>(packetRef->data.GetSize());
|
||||||
|
if (packetSize > fragmentLength)
|
||||||
|
{
|
||||||
|
UInt32 fragmentCount = (packetSize + fragmentLength - 1) / fragmentLength;
|
||||||
|
UInt32 fragmentNumber;
|
||||||
|
UInt32 fragmentOffset;
|
||||||
|
|
||||||
|
UInt8 commandNumber;
|
||||||
|
UInt16 startSequenceNumber;
|
||||||
|
|
||||||
|
if (fragmentCount > ENetConstants::ENetProtocol_MaximumFragmentCount)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
if ((packetRef->flags & (ENetPacketFlag_Reliable | ENetPacketFlag_UnreliableFragment)) == ENetPacketFlag_UnreliableFragment &&
|
||||||
|
channel.outgoingUnreliableSequenceNumber < 0xFFFF)
|
||||||
|
{
|
||||||
|
commandNumber = ENetProtocolCommand_SendUnreliable;
|
||||||
|
startSequenceNumber = HostToNet(channel.outgoingUnreliableSequenceNumber + 1);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
commandNumber = ENetProtocolCommand_SendFragment | ENetProtocolFlag_Acknowledge;
|
||||||
|
startSequenceNumber = HostToNet(channel.outgoingReliableSequenceNumber + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (fragmentNumber = 0,
|
||||||
|
fragmentOffset = 0;
|
||||||
|
fragmentOffset < packetSize;
|
||||||
|
++fragmentNumber,
|
||||||
|
fragmentOffset += fragmentLength)
|
||||||
|
{
|
||||||
|
if (packetSize - fragmentOffset < fragmentLength)
|
||||||
|
fragmentLength = packetSize - fragmentOffset;
|
||||||
|
|
||||||
|
OutgoingCommand outgoingCommand;
|
||||||
|
outgoingCommand.fragmentOffset = fragmentOffset;
|
||||||
|
outgoingCommand.fragmentLength = fragmentLength;
|
||||||
|
outgoingCommand.packet = packetRef;
|
||||||
|
outgoingCommand.command.header.command = commandNumber;
|
||||||
|
outgoingCommand.command.header.channelID = channelId;
|
||||||
|
outgoingCommand.command.sendFragment.startSequenceNumber = startSequenceNumber;
|
||||||
|
outgoingCommand.command.sendFragment.dataLength = HostToNet(fragmentLength);
|
||||||
|
outgoingCommand.command.sendFragment.fragmentCount = HostToNet(fragmentCount);
|
||||||
|
outgoingCommand.command.sendFragment.fragmentNumber = HostToNet(fragmentNumber);
|
||||||
|
outgoingCommand.command.sendFragment.totalLength = HostToNet(packetSize);
|
||||||
|
outgoingCommand.command.sendFragment.fragmentOffset = HostToNet(fragmentOffset);
|
||||||
|
|
||||||
|
SetupOutgoingCommand(outgoingCommand);
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.channelID = channelId;
|
||||||
|
|
||||||
|
if ((packetRef->flags & (ENetPacketFlag_Reliable | ENetPacketFlag_Unsequenced)) == ENetPacketFlag_Unsequenced)
|
||||||
|
command.header.command = ENetProtocolCommand_SendUnsequenced | ENetProtocolFlag_Unsequenced;
|
||||||
|
else if (packetRef->flags & ENetPacketFlag_Reliable || channel.outgoingUnreliableSequenceNumber >= 0xFFFF)
|
||||||
|
command.header.command = ENetProtocolCommand_SendReliable | ENetProtocolFlag_Acknowledge;
|
||||||
|
else
|
||||||
|
command.header.command = ENetProtocolCommand_SendUnreliable;
|
||||||
|
|
||||||
|
QueueOutgoingCommand(command, packetRef, 0, packetSize);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::ThrottleConfigure(UInt32 interval, UInt32 acceleration, UInt32 deceleration)
|
||||||
|
{
|
||||||
|
m_packetThrottleInterval = interval;
|
||||||
|
m_packetThrottleAcceleration = acceleration;
|
||||||
|
m_packetThrottleDeceleration = deceleration;
|
||||||
|
|
||||||
|
ENetProtocol command;
|
||||||
|
command.header.command = ENetProtocolCommand_ThrottleConfigure | ENetProtocolFlag_Acknowledge;
|
||||||
|
command.header.channelID = 0xFF;
|
||||||
|
|
||||||
|
command.throttleConfigure.packetThrottleInterval = HostToNet(interval);
|
||||||
|
command.throttleConfigure.packetThrottleAcceleration = HostToNet(acceleration);
|
||||||
|
command.throttleConfigure.packetThrottleDeceleration = HostToNet(deceleration);
|
||||||
|
|
||||||
|
QueueOutgoingCommand(command, nullptr, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::InitIncoming(std::size_t channelCount, const IpAddress& address, ENetProtocolConnect& incomingCommand)
|
||||||
|
{
|
||||||
|
m_channels.resize(channelCount);
|
||||||
|
m_address = address;
|
||||||
|
|
||||||
|
m_connectID = incomingCommand.connectID;
|
||||||
|
m_eventData = NetToHost(incomingCommand.data);
|
||||||
|
m_incomingBandwidth = NetToHost(incomingCommand.incomingBandwidth);
|
||||||
|
m_outgoingBandwidth = NetToHost(incomingCommand.outgoingBandwidth);
|
||||||
|
m_packetThrottleInterval = NetToHost(incomingCommand.packetThrottleInterval);
|
||||||
|
m_packetThrottleAcceleration = NetToHost(incomingCommand.packetThrottleAcceleration);
|
||||||
|
m_packetThrottleDeceleration = NetToHost(incomingCommand.packetThrottleDeceleration);
|
||||||
|
m_outgoingPeerID = NetToHost(incomingCommand.outgoingPeerID);
|
||||||
|
m_state = ENetPeerState::AcknowledgingConnect;
|
||||||
|
|
||||||
|
UInt8 incomingSessionId, outgoingSessionId;
|
||||||
|
|
||||||
|
incomingSessionId = incomingCommand.incomingSessionID == 0xFF ? m_outgoingSessionID : incomingCommand.incomingSessionID;
|
||||||
|
incomingSessionId = (incomingSessionId + 1) & (ENetProtocolHeaderSessionMask >> ENetProtocolHeaderSessionShift);
|
||||||
|
if (incomingSessionId == m_outgoingSessionID)
|
||||||
|
incomingSessionId = (incomingSessionId + 1) & (ENetProtocolHeaderSessionMask >> ENetProtocolHeaderSessionShift);
|
||||||
|
m_outgoingSessionID = incomingSessionId;
|
||||||
|
|
||||||
|
outgoingSessionId = incomingCommand.outgoingSessionID == 0xFF ? m_incomingSessionID : incomingCommand.outgoingSessionID;
|
||||||
|
outgoingSessionId = (outgoingSessionId + 1) & (ENetProtocolHeaderSessionMask >> ENetProtocolHeaderSessionShift);
|
||||||
|
if (outgoingSessionId == m_incomingSessionID)
|
||||||
|
outgoingSessionId = (outgoingSessionId + 1) & (ENetProtocolHeaderSessionMask >> ENetProtocolHeaderSessionShift);
|
||||||
|
m_incomingSessionID = outgoingSessionId;
|
||||||
|
|
||||||
|
m_mtu = Clamp<UInt32>(NetToHost(incomingCommand.mtu), ENetConstants::ENetProtocol_MinimumMTU, ENetConstants::ENetProtocol_MaximumMTU);
|
||||||
|
|
||||||
|
if (m_host->m_outgoingBandwidth == 0 && m_incomingBandwidth == 0)
|
||||||
|
m_windowSize = ENetConstants::ENetProtocol_MaximumWindowSize;
|
||||||
|
else if (m_host->m_outgoingBandwidth == 0 || m_incomingBandwidth == 0)
|
||||||
|
m_windowSize = (std::max(m_host->m_outgoingBandwidth, m_incomingBandwidth) / ENetConstants::ENetPeer_WindowSizeScale) * ENetConstants::ENetProtocol_MinimumWindowSize;
|
||||||
|
else
|
||||||
|
m_windowSize = (std::min(m_host->m_outgoingBandwidth, m_incomingBandwidth) / ENetConstants::ENetPeer_WindowSizeScale) * ENetConstants::ENetProtocol_MinimumWindowSize;
|
||||||
|
|
||||||
|
m_windowSize = Clamp<UInt32>(m_windowSize, ENetConstants::ENetProtocol_MinimumWindowSize, ENetConstants::ENetProtocol_MaximumWindowSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::InitOutgoing(std::size_t channelCount, const IpAddress& address, UInt32 connectId, UInt32 windowSize)
|
||||||
|
{
|
||||||
|
m_channels.resize(channelCount);
|
||||||
|
|
||||||
|
m_address = address;
|
||||||
|
m_connectID = connectId;
|
||||||
|
m_state = ENetPeerState::Connecting;
|
||||||
|
m_windowSize = Clamp<UInt32>(windowSize, ENetConstants::ENetProtocol_MinimumWindowSize, ENetConstants::ENetProtocol_MaximumWindowSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::DispatchIncomingReliableCommands(Channel& channel)
|
||||||
|
{
|
||||||
|
auto currentCommand = channel.incomingReliableCommands.begin();
|
||||||
|
for (; currentCommand != channel.incomingReliableCommands.end(); ++currentCommand)
|
||||||
|
{
|
||||||
|
IncomingCommmand& incomingCommand = *currentCommand;
|
||||||
|
|
||||||
|
if (incomingCommand.fragmentsRemaining > 0 || incomingCommand.reliableSequenceNumber != (channel.incomingReliableSequenceNumber + 1))
|
||||||
|
break;
|
||||||
|
|
||||||
|
channel.incomingReliableSequenceNumber = incomingCommand.reliableSequenceNumber;
|
||||||
|
|
||||||
|
if (!incomingCommand.fragments.empty())
|
||||||
|
channel.incomingReliableSequenceNumber += incomingCommand.fragments.size() - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (currentCommand == channel.incomingReliableCommands.begin())
|
||||||
|
return;
|
||||||
|
|
||||||
|
channel.incomingUnreliableSequenceNumber = 0;
|
||||||
|
|
||||||
|
m_dispatchedCommands.splice(m_dispatchedCommands.end(), m_dispatchedCommands, channel.incomingReliableCommands.begin(), currentCommand);
|
||||||
|
|
||||||
|
m_host->AddToDispatchQueue(this);
|
||||||
|
|
||||||
|
if (!channel.incomingUnreliableCommands.empty())
|
||||||
|
DispatchIncomingUnreliableCommands(channel);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::DispatchIncomingUnreliableCommands(Channel& channel)
|
||||||
|
{
|
||||||
|
std::list<IncomingCommmand>::iterator currentCommand;
|
||||||
|
std::list<IncomingCommmand>::iterator droppedCommand;
|
||||||
|
std::list<IncomingCommmand>::iterator startCommand;
|
||||||
|
|
||||||
|
for (droppedCommand = startCommand = currentCommand = channel.incomingUnreliableCommands.begin();
|
||||||
|
currentCommand != channel.incomingUnreliableCommands.end();
|
||||||
|
++currentCommand)
|
||||||
|
{
|
||||||
|
IncomingCommmand& incomingCommand = *currentCommand;
|
||||||
|
|
||||||
|
if ((incomingCommand.command.header.command & ENetProtocolCommand_Mask) == ENetProtocolCommand_SendUnsequenced)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (incomingCommand.reliableSequenceNumber == channel.incomingReliableSequenceNumber)
|
||||||
|
{
|
||||||
|
if (incomingCommand.fragmentsRemaining <= 0)
|
||||||
|
{
|
||||||
|
channel.incomingUnreliableSequenceNumber = incomingCommand.unreliableSequenceNumber;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (startCommand != currentCommand)
|
||||||
|
{
|
||||||
|
m_dispatchedCommands.splice(m_dispatchedCommands.end(), m_dispatchedCommands, startCommand, currentCommand);
|
||||||
|
|
||||||
|
m_host->AddToDispatchQueue(this);
|
||||||
|
|
||||||
|
droppedCommand = currentCommand;
|
||||||
|
}
|
||||||
|
else if (droppedCommand != currentCommand)
|
||||||
|
{
|
||||||
|
droppedCommand = currentCommand;
|
||||||
|
--droppedCommand;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
UInt16 reliableWindow = incomingCommand.reliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
UInt16 currentWindow = channel.incomingReliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
|
||||||
|
if (incomingCommand.reliableSequenceNumber < channel.incomingReliableSequenceNumber)
|
||||||
|
reliableWindow += ENetConstants::ENetPeer_ReliableWindows;
|
||||||
|
|
||||||
|
if (reliableWindow >= currentWindow && reliableWindow < currentWindow + ENetConstants::ENetPeer_ReliableWindowSize - 1)
|
||||||
|
break;
|
||||||
|
|
||||||
|
droppedCommand = currentCommand;
|
||||||
|
++droppedCommand;
|
||||||
|
|
||||||
|
if (startCommand != currentCommand)
|
||||||
|
{
|
||||||
|
m_dispatchedCommands.splice(m_dispatchedCommands.end(), m_dispatchedCommands, startCommand, currentCommand);
|
||||||
|
|
||||||
|
m_host->AddToDispatchQueue(this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
startCommand = currentCommand;
|
||||||
|
++startCommand;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (startCommand != currentCommand)
|
||||||
|
{
|
||||||
|
m_dispatchedCommands.splice(m_dispatchedCommands.end(), m_dispatchedCommands, startCommand, currentCommand);
|
||||||
|
|
||||||
|
m_host->AddToDispatchQueue(this);
|
||||||
|
|
||||||
|
droppedCommand = currentCommand;
|
||||||
|
}
|
||||||
|
|
||||||
|
channel.incomingUnreliableCommands.erase(channel.incomingUnreliableCommands.begin(), droppedCommand);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::OnConnect()
|
||||||
|
{
|
||||||
|
if (m_state != ENetPeerState::Connected && m_state != ENetPeerState::DisconnectLater)
|
||||||
|
{
|
||||||
|
if (m_incomingBandwidth != 0)
|
||||||
|
++m_host->m_bandwidthLimitedPeers;
|
||||||
|
|
||||||
|
++m_host->m_connectedPeers;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::OnDisconnect()
|
||||||
|
{
|
||||||
|
if (m_state == ENetPeerState::Connected || m_state == ENetPeerState::DisconnectLater)
|
||||||
|
{
|
||||||
|
if (m_incomingBandwidth != 0)
|
||||||
|
--m_host->m_bandwidthLimitedPeers;
|
||||||
|
|
||||||
|
--m_host->m_connectedPeers;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetProtocolCommand ENetPeer::RemoveSentReliableCommands(UInt16 reliableSequenceNumber, UInt8 channelId)
|
||||||
|
{
|
||||||
|
std::list<OutgoingCommand>* commandList = nullptr;
|
||||||
|
|
||||||
|
bool found = true;
|
||||||
|
auto currentCommand = m_sentReliableCommands.begin();
|
||||||
|
commandList = &m_sentReliableCommands;
|
||||||
|
for (; currentCommand != m_sentReliableCommands.end(); ++currentCommand)
|
||||||
|
{
|
||||||
|
found = true;
|
||||||
|
|
||||||
|
if (currentCommand->reliableSequenceNumber == reliableSequenceNumber &&
|
||||||
|
currentCommand->command.header.channelID == channelId)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool wasSent = true;
|
||||||
|
if (currentCommand == m_sentReliableCommands.end())
|
||||||
|
{
|
||||||
|
currentCommand = m_outgoingReliableCommands.begin();
|
||||||
|
commandList = &m_sentReliableCommands;
|
||||||
|
for (; currentCommand != m_outgoingReliableCommands.end(); ++currentCommand)
|
||||||
|
{
|
||||||
|
found = true;
|
||||||
|
|
||||||
|
if (currentCommand->sendAttempts < 1)
|
||||||
|
return ENetProtocolCommand_None;
|
||||||
|
|
||||||
|
if (currentCommand->reliableSequenceNumber == reliableSequenceNumber &&
|
||||||
|
currentCommand->command.header.channelID == channelId)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (currentCommand == m_outgoingReliableCommands.end())
|
||||||
|
return ENetProtocolCommand_None;
|
||||||
|
|
||||||
|
wasSent = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!found) //< Really useful?
|
||||||
|
return ENetProtocolCommand_None;
|
||||||
|
|
||||||
|
if (channelId < m_channels.size())
|
||||||
|
{
|
||||||
|
Channel& channel = m_channels[channelId];
|
||||||
|
|
||||||
|
UInt16 reliableWindow = reliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
if (channel.reliableWindows[reliableWindow] > 0)
|
||||||
|
{
|
||||||
|
--channel.reliableWindows[reliableWindow];
|
||||||
|
if (!channel.reliableWindows[reliableWindow])
|
||||||
|
channel.usedReliableWindows &= ~(1 << reliableWindow);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetProtocolCommand commandNumber = static_cast<ENetProtocolCommand>(currentCommand->command.header.command & ENetProtocolCommand_Mask);
|
||||||
|
|
||||||
|
if (currentCommand->packet && wasSent)
|
||||||
|
m_reliableDataInTransit -= currentCommand->fragmentLength;
|
||||||
|
|
||||||
|
commandList->erase(currentCommand);
|
||||||
|
|
||||||
|
if (m_sentReliableCommands.empty())
|
||||||
|
return commandNumber;
|
||||||
|
|
||||||
|
currentCommand = m_sentReliableCommands.begin();
|
||||||
|
m_nextTimeout = currentCommand->sentTime + currentCommand->roundTripTimeout;
|
||||||
|
|
||||||
|
return commandNumber;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::RemoveSentUnreliableCommands()
|
||||||
|
{
|
||||||
|
m_sentUnreliableCommands.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::ResetQueues()
|
||||||
|
{
|
||||||
|
m_host->RemoveFromDispatchQueue(this);
|
||||||
|
|
||||||
|
m_acknowledgements.clear();
|
||||||
|
m_dispatchedCommands.clear();
|
||||||
|
m_outgoingReliableCommands.clear();
|
||||||
|
m_outgoingUnreliableCommands.clear();
|
||||||
|
m_sentReliableCommands.clear();
|
||||||
|
m_sentUnreliableCommands.clear();
|
||||||
|
|
||||||
|
m_channels.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool ENetPeer::QueueAcknowledgement(ENetProtocol& command, UInt16 sentTime)
|
||||||
|
{
|
||||||
|
if (command.header.channelID < m_channels.size())
|
||||||
|
{
|
||||||
|
Channel& channel = m_channels[command.header.channelID];
|
||||||
|
|
||||||
|
UInt16 reliableWindow = command.header.reliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
UInt16 currentWindow = channel.incomingReliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
|
||||||
|
if (command.header.reliableSequenceNumber < channel.incomingReliableSequenceNumber)
|
||||||
|
reliableWindow += ENetConstants::ENetPeer_ReliableWindows;
|
||||||
|
|
||||||
|
if (reliableWindow >= currentWindow + ENetConstants::ENetPeer_FreeReliableWindows - 1 && reliableWindow <= currentWindow + ENetConstants::ENetPeer_FreeReliableWindows)
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
Acknowledgement acknowledgment;
|
||||||
|
acknowledgment.command = command;
|
||||||
|
acknowledgment.sentTime = sentTime;
|
||||||
|
|
||||||
|
m_outgoingDataTotal += sizeof(Acknowledgement);
|
||||||
|
|
||||||
|
m_acknowledgements.emplace_back(acknowledgment);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
ENetPeer::IncomingCommmand* ENetPeer::QueueIncomingCommand(ENetProtocol& command, const void* data, std::size_t dataLength, UInt32 flags, UInt32 fragmentCount)
|
||||||
|
{
|
||||||
|
static IncomingCommmand dummyCommand;
|
||||||
|
|
||||||
|
UInt32 reliableSequenceNumber = 0;
|
||||||
|
UInt32 unreliableSequenceNumber = 0;
|
||||||
|
UInt16 reliableWindow;
|
||||||
|
UInt16 currentWindow;
|
||||||
|
|
||||||
|
auto discardCommand = [&]() -> IncomingCommmand*
|
||||||
|
{
|
||||||
|
if (fragmentCount > 0)
|
||||||
|
return nullptr; //< Error
|
||||||
|
|
||||||
|
return &dummyCommand;
|
||||||
|
};
|
||||||
|
|
||||||
|
if (m_state == ENetPeerState::DisconnectLater)
|
||||||
|
return discardCommand();
|
||||||
|
|
||||||
|
Channel& channel = m_channels[command.header.channelID];
|
||||||
|
|
||||||
|
if ((command.header.command & ENetProtocolCommand_Mask) != ENetProtocolCommand_SendUnsequenced)
|
||||||
|
{
|
||||||
|
reliableSequenceNumber = command.header.reliableSequenceNumber;
|
||||||
|
reliableWindow = reliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
currentWindow = channel.incomingReliableSequenceNumber / ENetConstants::ENetPeer_ReliableWindowSize;
|
||||||
|
|
||||||
|
if (reliableSequenceNumber < channel.incomingReliableSequenceNumber)
|
||||||
|
reliableWindow += ENetConstants::ENetPeer_ReliableWindows;
|
||||||
|
|
||||||
|
if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENetConstants::ENetPeer_FreeReliableWindows - 1)
|
||||||
|
return discardCommand();
|
||||||
|
}
|
||||||
|
|
||||||
|
std::list<IncomingCommmand>* commandList = nullptr;
|
||||||
|
std::list<IncomingCommmand>::reverse_iterator currentCommand;
|
||||||
|
|
||||||
|
switch (command.header.command & ENetProtocolCommand_Mask)
|
||||||
|
{
|
||||||
|
case ENetProtocolCommand_SendFragment:
|
||||||
|
case ENetProtocolCommand_SendReliable:
|
||||||
|
{
|
||||||
|
if (reliableSequenceNumber == channel.incomingReliableSequenceNumber)
|
||||||
|
return discardCommand();
|
||||||
|
|
||||||
|
commandList = &channel.incomingReliableCommands;
|
||||||
|
|
||||||
|
for (currentCommand = channel.incomingReliableCommands.rbegin(); currentCommand != channel.incomingReliableCommands.rend(); ++currentCommand)
|
||||||
|
{
|
||||||
|
IncomingCommmand& incomingCommand = *currentCommand;
|
||||||
|
|
||||||
|
if (reliableSequenceNumber >= channel.incomingReliableSequenceNumber)
|
||||||
|
{
|
||||||
|
if (incomingCommand.reliableSequenceNumber < channel.incomingReliableSequenceNumber)
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (incomingCommand.reliableSequenceNumber >= channel.incomingReliableSequenceNumber)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (incomingCommand.reliableSequenceNumber <= reliableSequenceNumber)
|
||||||
|
{
|
||||||
|
if (incomingCommand.reliableSequenceNumber < reliableSequenceNumber)
|
||||||
|
break;
|
||||||
|
|
||||||
|
return discardCommand();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
case ENetProtocolCommand_SendUnreliable:
|
||||||
|
case ENetProtocolCommand_SendUnreliableFragment:
|
||||||
|
{
|
||||||
|
unreliableSequenceNumber = NetToHost(command.sendUnreliable.unreliableSequenceNumber);
|
||||||
|
|
||||||
|
if (reliableSequenceNumber == channel.incomingReliableSequenceNumber && unreliableSequenceNumber <= channel.incomingUnreliableSequenceNumber)
|
||||||
|
return discardCommand();
|
||||||
|
|
||||||
|
commandList = &channel.incomingUnreliableCommands;
|
||||||
|
|
||||||
|
for (currentCommand = channel.incomingUnreliableCommands.rbegin(); currentCommand != channel.incomingUnreliableCommands.rend(); ++currentCommand)
|
||||||
|
{
|
||||||
|
IncomingCommmand& incomingCommand = *currentCommand;
|
||||||
|
|
||||||
|
if ((command.header.command & ENetProtocolCommand_Mask) == ENetProtocolCommand_SendUnsequenced) //< wtf
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (reliableSequenceNumber >= channel.incomingReliableSequenceNumber)
|
||||||
|
{
|
||||||
|
if (incomingCommand.reliableSequenceNumber < channel.incomingReliableSequenceNumber)
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
if (incomingCommand.reliableSequenceNumber >= channel.incomingReliableSequenceNumber)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (incomingCommand.reliableSequenceNumber < reliableSequenceNumber)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if (incomingCommand.reliableSequenceNumber > reliableSequenceNumber)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (incomingCommand.unreliableSequenceNumber <= unreliableSequenceNumber)
|
||||||
|
{
|
||||||
|
if (incomingCommand.unreliableSequenceNumber < unreliableSequenceNumber)
|
||||||
|
break;
|
||||||
|
|
||||||
|
return discardCommand();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
case ENetProtocolCommand_SendUnsequenced:
|
||||||
|
{
|
||||||
|
commandList = &channel.incomingUnreliableCommands;
|
||||||
|
|
||||||
|
currentCommand = channel.incomingUnreliableCommands.rend();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
default:
|
||||||
|
return discardCommand();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (m_totalWaitingData >= m_host->m_maximumWaitingData)
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
|
ENetPacket* packet = m_packetPool.New<ENetPacket>();
|
||||||
|
packet->flags = flags;
|
||||||
|
packet->data.Reset(0, data, dataLength);
|
||||||
|
packet->owner = &m_packetPool;
|
||||||
|
|
||||||
|
IncomingCommmand incomingCommand;
|
||||||
|
incomingCommand.reliableSequenceNumber = command.header.reliableSequenceNumber;
|
||||||
|
incomingCommand.unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF;
|
||||||
|
incomingCommand.command = command;
|
||||||
|
incomingCommand.packet = packet;
|
||||||
|
incomingCommand.fragments.resize(fragmentCount, 0);
|
||||||
|
incomingCommand.fragmentsRemaining = fragmentCount;
|
||||||
|
|
||||||
|
auto it = commandList->insert(currentCommand.base(), incomingCommand);
|
||||||
|
|
||||||
|
switch (command.header.command & ENetProtocolCommand_Mask)
|
||||||
|
{
|
||||||
|
case ENetProtocolCommand_SendFragment:
|
||||||
|
case ENetProtocolCommand_SendReliable:
|
||||||
|
DispatchIncomingReliableCommands(channel);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
DispatchIncomingUnreliableCommands(channel);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return &(*it);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::QueueOutgoingCommand(ENetProtocol& command, ENetPacketRef packet, UInt32 offset, UInt16 length)
|
||||||
|
{
|
||||||
|
OutgoingCommand outgoingCommand;
|
||||||
|
outgoingCommand.command = command;
|
||||||
|
outgoingCommand.fragmentLength = length;
|
||||||
|
outgoingCommand.fragmentOffset = length;
|
||||||
|
outgoingCommand.packet = packet;
|
||||||
|
|
||||||
|
SetupOutgoingCommand(outgoingCommand);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ENetPeer::SetupOutgoingCommand(OutgoingCommand& outgoingCommand)
|
||||||
|
{
|
||||||
|
m_outgoingDataTotal += enet_protocol_command_size(outgoingCommand.command.header.command) + outgoingCommand.fragmentLength;
|
||||||
|
|
||||||
|
if (outgoingCommand.command.header.channelID == 0xFF)
|
||||||
|
{
|
||||||
|
++m_outgoingReliableSequenceNumber;
|
||||||
|
|
||||||
|
outgoingCommand.reliableSequenceNumber = m_outgoingReliableSequenceNumber;
|
||||||
|
outgoingCommand.unreliableSequenceNumber = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Channel* channel = &m_channels[outgoingCommand.command.header.channelID];
|
||||||
|
if (outgoingCommand.command.header.command & ENetProtocolFlag_Acknowledge)
|
||||||
|
{
|
||||||
|
++channel->outgoingReliableSequenceNumber;
|
||||||
|
channel->outgoingUnreliableSequenceNumber = 0;
|
||||||
|
|
||||||
|
outgoingCommand.reliableSequenceNumber = channel->outgoingReliableSequenceNumber;
|
||||||
|
outgoingCommand.unreliableSequenceNumber = 0;
|
||||||
|
}
|
||||||
|
else if (outgoingCommand.command.header.command & ENetProtocolFlag_Unsequenced)
|
||||||
|
{
|
||||||
|
++m_outgoingUnsequencedGroup;
|
||||||
|
|
||||||
|
outgoingCommand.reliableSequenceNumber = 0;
|
||||||
|
outgoingCommand.unreliableSequenceNumber = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (outgoingCommand.fragmentOffset == 0)
|
||||||
|
++channel->outgoingUnreliableSequenceNumber;
|
||||||
|
|
||||||
|
outgoingCommand.reliableSequenceNumber = channel->outgoingReliableSequenceNumber;
|
||||||
|
outgoingCommand.unreliableSequenceNumber = channel->outgoingUnreliableSequenceNumber;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
outgoingCommand.sendAttempts = 0;
|
||||||
|
outgoingCommand.sentTime = 0;
|
||||||
|
outgoingCommand.roundTripTimeout = 0;
|
||||||
|
outgoingCommand.roundTripTimeoutLimit = 0;
|
||||||
|
outgoingCommand.command.header.reliableSequenceNumber = HostToNet(outgoingCommand.reliableSequenceNumber);
|
||||||
|
|
||||||
|
switch (outgoingCommand.command.header.command & ENetProtocolCommand_Mask)
|
||||||
|
{
|
||||||
|
case ENetProtocolCommand_SendUnreliable:
|
||||||
|
outgoingCommand.command.sendUnreliable.unreliableSequenceNumber = HostToNet(outgoingCommand.unreliableSequenceNumber);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case ENetProtocolCommand_SendUnsequenced:
|
||||||
|
outgoingCommand.command.sendUnsequenced.unsequencedGroup = HostToNet(m_outgoingUnsequencedGroup);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (outgoingCommand.command.header.command & ENetProtocolCommand_Acknowledge)
|
||||||
|
m_outgoingReliableCommands.emplace_back(outgoingCommand);
|
||||||
|
else
|
||||||
|
m_outgoingUnreliableCommands.emplace_back(outgoingCommand);
|
||||||
|
}
|
||||||
|
|
||||||
|
int ENetPeer::Throttle(UInt32 rtt)
|
||||||
|
{
|
||||||
|
if (m_lastRoundTripTime <= m_lastRoundTripTimeVariance)
|
||||||
|
m_packetThrottle = m_packetThrottleLimit;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (rtt < m_lastRoundTripTime)
|
||||||
|
{
|
||||||
|
m_packetThrottle = std::max(m_packetThrottle + m_packetThrottleAcceleration, m_packetThrottleLimit);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else if (rtt > m_lastRoundTripTime + 2 * m_lastRoundTripTimeVariance)
|
||||||
|
{
|
||||||
|
if (m_packetThrottle > m_packetThrottleDeceleration)
|
||||||
|
m_packetThrottle -= m_packetThrottleDeceleration;
|
||||||
|
else
|
||||||
|
m_packetThrottle = 0;
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,642 @@
|
||||||
|
// Copyright (C) 2017 Jérôme Leclercq
|
||||||
|
// This file is part of the "Nazara Engine - Utility module"
|
||||||
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
||||||
|
|
||||||
|
#include <Nazara/Network/ENetHost.hpp>
|
||||||
|
#include <Nazara/Core/CallOnExit.hpp>
|
||||||
|
#include <Nazara/Core/Log.hpp>
|
||||||
|
#include <Nazara/Network/NetPacket.hpp>
|
||||||
|
#include <Nazara/Network/Debug.hpp>
|
||||||
|
|
||||||
|
namespace Nz
|
||||||
|
{
|
||||||
|
/*!
|
||||||
|
* \ingroup network
|
||||||
|
* \class Nz::ENetConnection
|
||||||
|
* \brief Network class that represents a reliable UDP connection, based on ENet library
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Constructs a RUdpConnection object by default
|
||||||
|
*/
|
||||||
|
|
||||||
|
ENetSocket::ENetSocket() :
|
||||||
|
m_bandwidthThrottleEpoch(0),
|
||||||
|
m_mtu(ENetConstants::DefaultMTU),
|
||||||
|
m_isSimulationEnabled(false),
|
||||||
|
m_shouldAcceptConnections(true)
|
||||||
|
{
|
||||||
|
m_randomSeed = *reinterpret_cast<UInt32*>(this);
|
||||||
|
m_randomSeed += s_randomGenerator();
|
||||||
|
m_randomSeed = (m_randomSeed << 16) | (m_randomSeed >> 16);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Connects to the IpAddress
|
||||||
|
* \return true
|
||||||
|
*
|
||||||
|
* \param remoteAddress Address to connect to
|
||||||
|
*
|
||||||
|
* \remark Produces a NazaraAssert if socket is not bound
|
||||||
|
* \remark Produces a NazaraAssert if remote is invalid
|
||||||
|
* \remark Produces a NazaraAssert if port is not specified
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::Connect(const IpAddress& remoteAddress)
|
||||||
|
{
|
||||||
|
NazaraAssert(m_socket.GetState() == SocketState_Bound, "Socket must be bound first");
|
||||||
|
NazaraAssert(remoteAddress.IsValid(), "Invalid remote address");
|
||||||
|
NazaraAssert(remoteAddress.GetPort() != 0, "Remote address has no port");
|
||||||
|
|
||||||
|
PeerData& client = RegisterPeer(remoteAddress, PeerState_Connecting);
|
||||||
|
client.stateData1 = s_randomGenerator();
|
||||||
|
|
||||||
|
NetPacket connectionRequestPacket(NetCode_RequestConnection);
|
||||||
|
connectionRequestPacket << client.stateData1;
|
||||||
|
|
||||||
|
EnqueuePacket(client, PacketPriority_Immediate, PacketReliability_Reliable, connectionRequestPacket);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Connects to the hostname
|
||||||
|
* \return true If successful
|
||||||
|
*
|
||||||
|
* \param hostName Hostname of the remote
|
||||||
|
* \param protocol Net protocol to use
|
||||||
|
* \param service Specify the protocol used
|
||||||
|
* \param error Optional argument to get the error
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::Connect(const String& hostName, NetProtocol protocol, const String& service, ResolveError* error)
|
||||||
|
{
|
||||||
|
std::vector<HostnameInfo> results = IpAddress::ResolveHostname(protocol, hostName, service, error);
|
||||||
|
if (results.empty())
|
||||||
|
{
|
||||||
|
m_lastError = SocketError_ResolveError;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
IpAddress hostnameAddress;
|
||||||
|
for (const HostnameInfo& result : results)
|
||||||
|
{
|
||||||
|
if (!result.address)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (result.socketType != SocketType_UDP)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
hostnameAddress = result.address;
|
||||||
|
break; //< Take first valid address
|
||||||
|
}
|
||||||
|
|
||||||
|
return Connect(hostnameAddress);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Listens to a socket
|
||||||
|
* \return true If successfully bound
|
||||||
|
*
|
||||||
|
* \param remoteAddress Address to listen to
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::Listen(const IpAddress& address)
|
||||||
|
{
|
||||||
|
if (!InitSocket(address.GetProtocol()))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return m_socket.Bind(address) == SocketState_Bound;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Polls the message
|
||||||
|
* \return true If there is a message
|
||||||
|
*
|
||||||
|
* \param message Message to poll
|
||||||
|
*
|
||||||
|
* \remark Produces a NazaraAssert if message is invalid
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::PollMessage(RUdpMessage* message)
|
||||||
|
{
|
||||||
|
NazaraAssert(message, "Invalid message");
|
||||||
|
|
||||||
|
if (m_receivedMessages.empty())
|
||||||
|
return false;
|
||||||
|
|
||||||
|
*message = std::move(m_receivedMessages.front());
|
||||||
|
m_receivedMessages.pop();
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Sends the packet to a peer
|
||||||
|
* \return true If peer exists (false may result from disconnected client)
|
||||||
|
*
|
||||||
|
* \param peerIp IpAddress of the peer
|
||||||
|
* \param priority Priority of the packet
|
||||||
|
* \param reliability Policy of reliability of the packet
|
||||||
|
* \param packet Packet to send
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::Send(const IpAddress& peerIp, PacketPriority priority, PacketReliability reliability, const NetPacket& packet)
|
||||||
|
{
|
||||||
|
auto it = m_peerByIP.find(peerIp);
|
||||||
|
if (it == m_peerByIP.end())
|
||||||
|
return false; /// Silently fail (probably a disconnected client)
|
||||||
|
|
||||||
|
EnqueuePacket(m_peers[it->second], priority, reliability, packet);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Updates the reliable connection
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::Update()
|
||||||
|
{
|
||||||
|
m_currentTime = m_clock.GetMicroseconds();
|
||||||
|
|
||||||
|
NetPacket receivedPacket;
|
||||||
|
IpAddress senderIp;
|
||||||
|
while (m_socket.ReceivePacket(&receivedPacket, &senderIp))
|
||||||
|
OnPacketReceived(senderIp, std::move(receivedPacket));
|
||||||
|
|
||||||
|
//for (unsigned int i = m_activeClients.FindFirst(); i != m_activeClients.npos; i = m_activeClients.FindNext(i))
|
||||||
|
//{
|
||||||
|
// PeerData& clientData = m_peers[i];
|
||||||
|
|
||||||
|
CallOnExit resetIterator([this] () { m_peerIterator = m_peers.size(); });
|
||||||
|
|
||||||
|
for (m_peerIterator = 0; m_peerIterator < m_peers.size(); ++m_peerIterator)
|
||||||
|
{
|
||||||
|
PeerData& peer = m_peers[m_peerIterator];
|
||||||
|
|
||||||
|
UInt32 timeSinceLastPacket = static_cast<UInt32>(m_currentTime - peer.lastPacketTime);
|
||||||
|
if (timeSinceLastPacket > m_timeBeforeTimeOut)
|
||||||
|
{
|
||||||
|
DisconnectPeer(peer.index);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else if (timeSinceLastPacket > m_timeBeforePing)
|
||||||
|
{
|
||||||
|
if (m_currentTime - peer.lastPingTime > m_pingInterval)
|
||||||
|
{
|
||||||
|
NetPacket pingPacket(NetCode_Ping);
|
||||||
|
EnqueuePacket(peer, PacketPriority_Low, PacketReliability_Unreliable, pingPacket);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (peer.state == PeerState_WillAck && m_currentTime - peer.stateData1 > m_forceAckSendTime)
|
||||||
|
{
|
||||||
|
NetPacket acknowledgePacket(NetCode_Acknowledge);
|
||||||
|
EnqueuePacket(peer, PacketPriority_Low, PacketReliability_Reliable, acknowledgePacket);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (unsigned int priority = PacketPriority_Highest; priority <= PacketPriority_Lowest; ++priority)
|
||||||
|
{
|
||||||
|
std::vector<PendingPacket>& pendingPackets = peer.pendingPackets[priority];
|
||||||
|
for (PendingPacket& packetData : pendingPackets)
|
||||||
|
SendPacket(peer, std::move(packetData));
|
||||||
|
|
||||||
|
pendingPackets.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
auto it = peer.pendingAckQueue.begin();
|
||||||
|
while (it != peer.pendingAckQueue.end())
|
||||||
|
{
|
||||||
|
if (m_currentTime - it->timeSent > 2 * peer.roundTripTime)
|
||||||
|
{
|
||||||
|
OnPacketLost(peer, std::move(*it));
|
||||||
|
it = peer.pendingAckQueue.erase(it);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
++it;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//m_activeClients.Reset();
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Disconnects a peer
|
||||||
|
*
|
||||||
|
* \param peerIndex Index of the peer
|
||||||
|
*
|
||||||
|
* \remark Produces a NazaraNotice
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::DisconnectPeer(std::size_t peerIndex)
|
||||||
|
{
|
||||||
|
PeerData& peer = m_peers[peerIndex];
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": " + peer.address.ToString() + " has been disconnected due to time-out");
|
||||||
|
|
||||||
|
OnPeerDisconnected(this, peer.address);
|
||||||
|
|
||||||
|
// Remove from IP lookup table
|
||||||
|
m_peerByIP.erase(peer.address);
|
||||||
|
|
||||||
|
// Can we safely "remove" this slot?
|
||||||
|
if (m_peerIterator >= m_peers.size() - 1 || peerIndex > m_peerIterator)
|
||||||
|
{
|
||||||
|
// Yes we can
|
||||||
|
PeerData& newSlot = m_peers[peerIndex];
|
||||||
|
newSlot = std::move(m_peers.back());
|
||||||
|
newSlot.index = peerIndex; //< Update the moved slot index before resizing (in case it's the last one)
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Nope, let's be tricky
|
||||||
|
PeerData& current = m_peers[m_peerIterator];
|
||||||
|
PeerData& newSlot = m_peers[peerIndex];
|
||||||
|
|
||||||
|
newSlot = std::move(current);
|
||||||
|
newSlot.index = peerIndex; //< Update the moved slot index
|
||||||
|
|
||||||
|
current = std::move(m_peers.back());
|
||||||
|
current.index = m_peerIterator; //< Update the moved slot index
|
||||||
|
|
||||||
|
--m_peerIterator;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pop the last entry (from where we moved our slot)
|
||||||
|
m_peers.pop_back();
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Enqueues a packet in the sending list
|
||||||
|
*
|
||||||
|
* \param peer Data relative to the peer
|
||||||
|
* \param priority Priority of the packet
|
||||||
|
* \param reliability Policy of reliability of the packet
|
||||||
|
* \param packet Packet to send
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::EnqueuePacket(PeerData& peer, PacketPriority priority, PacketReliability reliability, const NetPacket& packet)
|
||||||
|
{
|
||||||
|
UInt16 protocolBegin = static_cast<UInt16>(m_protocol & 0xFFFF);
|
||||||
|
UInt16 protocolEnd = static_cast<UInt16>((m_protocol & 0xFFFF0000) >> 16);
|
||||||
|
|
||||||
|
NetPacket data(packet.GetNetCode(), MessageHeader + packet.GetDataSize() + MessageFooter);
|
||||||
|
data << protocolBegin;
|
||||||
|
|
||||||
|
data.GetStream()->SetCursorPos(NetPacket::HeaderSize + MessageHeader);
|
||||||
|
data.Write(packet.GetConstData() + NetPacket::HeaderSize, packet.GetDataSize());
|
||||||
|
|
||||||
|
data << protocolEnd;
|
||||||
|
EnqueuePacketInternal(peer, priority, reliability, std::move(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Enqueues internally a packet in the sending list
|
||||||
|
*
|
||||||
|
* \param peer Data relative to the peer
|
||||||
|
* \param priority Priority of the packet
|
||||||
|
* \param reliability Policy of reliability of the packet
|
||||||
|
* \param packet Packet to send
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::EnqueuePacketInternal(PeerData& peer, PacketPriority priority, PacketReliability reliability, NetPacket&& data)
|
||||||
|
{
|
||||||
|
PendingPacket pendingPacket;
|
||||||
|
pendingPacket.data = std::move(data);
|
||||||
|
pendingPacket.priority = priority;
|
||||||
|
pendingPacket.reliability = reliability;
|
||||||
|
|
||||||
|
peer.pendingPackets[priority].emplace_back(std::move(pendingPacket));
|
||||||
|
m_activeClients.UnboundedSet(peer.index);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Inits the internal socket
|
||||||
|
* \return true If successful
|
||||||
|
*
|
||||||
|
* \param protocol Net protocol to use
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool ENetSocket::InitSocket(NetProtocol protocol)
|
||||||
|
{
|
||||||
|
CallOnExit updateLastError([this]
|
||||||
|
{
|
||||||
|
m_lastError = m_socket.GetLastError();
|
||||||
|
});
|
||||||
|
|
||||||
|
if (!m_socket.Create(protocol))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
m_socket.EnableBlocking(false);
|
||||||
|
m_socket.SetReceiveBufferSize(ENetConstants::ReceiveBufferSize);
|
||||||
|
m_socket.SetSendBufferSize(ENetConstants::SendBufferSize);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Processes the acks
|
||||||
|
*
|
||||||
|
* \param peer Data relative to the peer
|
||||||
|
* \param lastAck Last index of the ack
|
||||||
|
* \param ackBits Bits for acking
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::ProcessAcks(PeerData& peer, SequenceIndex lastAck, UInt32 ackBits)
|
||||||
|
{
|
||||||
|
auto it = peer.pendingAckQueue.begin();
|
||||||
|
while (it != peer.pendingAckQueue.end())
|
||||||
|
{
|
||||||
|
bool acked = false;
|
||||||
|
if (lastAck == it->sequenceId)
|
||||||
|
acked = true;
|
||||||
|
else if (!IsAckMoreRecent(it->sequenceId, lastAck))
|
||||||
|
{
|
||||||
|
unsigned int difference = ComputeSequenceDifference(lastAck, it->sequenceId);
|
||||||
|
if (difference <= 32)
|
||||||
|
acked = (ackBits >> (difference - 1)) & 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (acked)
|
||||||
|
{
|
||||||
|
it = peer.pendingAckQueue.erase(it);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
++it;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Registers a peer
|
||||||
|
* \return Data relative to the peer
|
||||||
|
*
|
||||||
|
* \param address Address of the peer
|
||||||
|
* \param state Status of the peer
|
||||||
|
*/
|
||||||
|
|
||||||
|
RUdpConnection::PeerData& RUdpConnection::RegisterPeer(const IpAddress& address, PeerState state)
|
||||||
|
{
|
||||||
|
PeerData data;
|
||||||
|
data.address = address;
|
||||||
|
data.localSequence = 0;
|
||||||
|
data.remoteSequence = 0;
|
||||||
|
data.index = m_peers.size();
|
||||||
|
data.lastPacketTime = m_currentTime;
|
||||||
|
data.lastPingTime = m_currentTime;
|
||||||
|
data.roundTripTime = 1'000'000; ///< Okay that's quite a lot
|
||||||
|
data.state = state;
|
||||||
|
|
||||||
|
m_activeClients.UnboundedSet(data.index);
|
||||||
|
m_peerByIP[address] = data.index;
|
||||||
|
|
||||||
|
m_peers.emplace_back(std::move(data));
|
||||||
|
return m_peers.back();
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Operation to do when client requests a connection
|
||||||
|
*
|
||||||
|
* \param address Address of the peer
|
||||||
|
* \param sequenceId Sequence index for the ack
|
||||||
|
* \param token Token for connection
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::OnClientRequestingConnection(const IpAddress& address, SequenceIndex sequenceId, UInt64 token)
|
||||||
|
{
|
||||||
|
// Call hook to check if client should be accepted or not
|
||||||
|
OnPeerConnection(this, address);
|
||||||
|
|
||||||
|
PeerData& client = RegisterPeer(address, PeerState_Aknowledged);
|
||||||
|
client.remoteSequence = sequenceId;
|
||||||
|
|
||||||
|
/// Acknowledge connection
|
||||||
|
NetPacket connectionAcceptedPacket(NetCode_AcknowledgeConnection);
|
||||||
|
//connectionAcceptedPacket << address;
|
||||||
|
connectionAcceptedPacket << ~token;
|
||||||
|
|
||||||
|
EnqueuePacket(client, PacketPriority_Immediate, PacketReliability_Reliable, connectionAcceptedPacket);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Operation to do when a packet is lost
|
||||||
|
*
|
||||||
|
* \param peer Data relative to the peer
|
||||||
|
* \param packet Pending packet
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::OnPacketLost(PeerData& peer, PendingAckPacket&& packet)
|
||||||
|
{
|
||||||
|
//NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + String::Number(packet.sequenceId));
|
||||||
|
|
||||||
|
if (IsReliable(packet.reliability))
|
||||||
|
EnqueuePacketInternal(peer, packet.priority, packet.reliability, std::move(packet.data));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Operation to do when receiving a packet
|
||||||
|
*
|
||||||
|
* \param peerIndex Index of the peer
|
||||||
|
*
|
||||||
|
* \remark Produces a NazaraNotice
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::OnPacketReceived(const IpAddress& peerIp, NetPacket&& packet)
|
||||||
|
{
|
||||||
|
UInt16 protocolBegin;
|
||||||
|
UInt16 protocolEnd;
|
||||||
|
SequenceIndex sequenceId;
|
||||||
|
SequenceIndex lastAck;
|
||||||
|
UInt32 ackBits;
|
||||||
|
|
||||||
|
packet.GetStream()->SetCursorPos(packet.GetSize() - MessageFooter);
|
||||||
|
packet >> protocolEnd;
|
||||||
|
|
||||||
|
packet.GetStream()->SetCursorPos(NetPacket::HeaderSize);
|
||||||
|
packet >> protocolBegin;
|
||||||
|
|
||||||
|
UInt32 protocolId = static_cast<UInt32>(protocolEnd) << 16 | protocolBegin;
|
||||||
|
if (protocolId != m_protocol)
|
||||||
|
return; ///< Ignore
|
||||||
|
|
||||||
|
packet >> sequenceId >> lastAck >> ackBits;
|
||||||
|
|
||||||
|
auto it = m_peerByIP.find(peerIp);
|
||||||
|
if (it == m_peerByIP.end())
|
||||||
|
{
|
||||||
|
switch (packet.GetNetCode())
|
||||||
|
{
|
||||||
|
case NetCode_RequestConnection:
|
||||||
|
{
|
||||||
|
UInt64 token;
|
||||||
|
packet >> token;
|
||||||
|
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_RequestConnection from " + peerIp.ToString() + ": " + String::Number(token));
|
||||||
|
if (!m_shouldAcceptConnections)
|
||||||
|
return; //< Ignore
|
||||||
|
|
||||||
|
OnClientRequestingConnection(peerIp, sequenceId, token);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
default:
|
||||||
|
return; //< Ignore
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
PeerData& peer = m_peers[it->second];
|
||||||
|
peer.lastPacketTime = m_currentTime;
|
||||||
|
|
||||||
|
if (peer.receivedQueue.find(sequenceId) != peer.receivedQueue.end())
|
||||||
|
return; //< Ignore
|
||||||
|
|
||||||
|
if (m_isSimulationEnabled && m_packetLossProbability(s_randomGenerator))
|
||||||
|
{
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + String::Number(sequenceId) + " from " + peerIp.ToString() + " for simulation purpose");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
///< Receiving a packet from an acknowledged client means the connection works in both ways
|
||||||
|
if (peer.state == PeerState_Aknowledged && packet.GetNetCode() != NetCode_RequestConnection)
|
||||||
|
{
|
||||||
|
peer.state = PeerState_Connected;
|
||||||
|
OnPeerAcknowledged(this, peerIp);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (IsAckMoreRecent(sequenceId, peer.remoteSequence))
|
||||||
|
peer.remoteSequence = sequenceId;
|
||||||
|
|
||||||
|
ProcessAcks(peer, lastAck, ackBits);
|
||||||
|
|
||||||
|
peer.receivedQueue.insert(sequenceId);
|
||||||
|
|
||||||
|
switch (packet.GetNetCode())
|
||||||
|
{
|
||||||
|
case NetCode_Acknowledge:
|
||||||
|
return; //< Do not switch to will ack mode (to prevent infinite replies, just let's ping/pong do that)
|
||||||
|
|
||||||
|
case NetCode_AcknowledgeConnection:
|
||||||
|
{
|
||||||
|
if (peer.state == PeerState_Connected)
|
||||||
|
break;
|
||||||
|
|
||||||
|
IpAddress externalAddress;
|
||||||
|
UInt64 token;
|
||||||
|
packet /*>> externalAddress*/ >> token;
|
||||||
|
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_AcknowledgeConnection from " + peerIp.ToString() + ": " + String::Number(token));
|
||||||
|
if (token == ~peer.stateData1)
|
||||||
|
{
|
||||||
|
peer.state = PeerState_Connected;
|
||||||
|
OnConnectedToPeer(this);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
NazaraNotice("Received wrong token (" + String::Number(token) + " instead of " + String::Number(~peer.stateData1) + ") from client " + peer.address);
|
||||||
|
return; //< Ignore
|
||||||
|
}
|
||||||
|
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
case NetCode_RequestConnection:
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_RequestConnection from " + peerIp.ToString());
|
||||||
|
return; //< Ignore
|
||||||
|
|
||||||
|
case NetCode_Ping:
|
||||||
|
{
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_Ping from " + peerIp.ToString());
|
||||||
|
|
||||||
|
NetPacket pongPacket(NetCode_Pong);
|
||||||
|
EnqueuePacket(peer, PacketPriority_Low, PacketReliability_Unreliable, pongPacket);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
case NetCode_Pong:
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_Pong from " + peerIp.ToString());
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
{
|
||||||
|
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received 0x" + String::Number(packet.GetNetCode(), 16) + " from " + peerIp.ToString());
|
||||||
|
RUdpMessage receivedMessage;
|
||||||
|
receivedMessage.from = peerIp;
|
||||||
|
receivedMessage.data = std::move(packet);
|
||||||
|
|
||||||
|
m_receivedMessages.emplace(std::move(receivedMessage));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!HasPendingPackets(peer))
|
||||||
|
{
|
||||||
|
peer.state = PeerState_WillAck;
|
||||||
|
peer.stateData1 = m_currentTime;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Sends a packet to a peer
|
||||||
|
*
|
||||||
|
* \param peer Data relative to the peer
|
||||||
|
* \param packet Pending packet
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::SendPacket(PeerData& peer, PendingPacket&& packet)
|
||||||
|
{
|
||||||
|
if (peer.state == PeerState_WillAck)
|
||||||
|
peer.state = PeerState_Connected;
|
||||||
|
|
||||||
|
SequenceIndex remoteSequence = peer.remoteSequence;
|
||||||
|
|
||||||
|
UInt32 previousAcks = 0;
|
||||||
|
for (SequenceIndex ack : peer.receivedQueue)
|
||||||
|
{
|
||||||
|
if (ack == remoteSequence)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
unsigned int difference = ComputeSequenceDifference(remoteSequence, ack);
|
||||||
|
if (difference <= 32U)
|
||||||
|
previousAcks |= (1U << (difference - 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
SequenceIndex sequenceId = ++peer.localSequence;
|
||||||
|
|
||||||
|
packet.data.GetStream()->SetCursorPos(NetPacket::HeaderSize + sizeof(UInt16)); ///< Protocol begin has already been filled
|
||||||
|
packet.data << sequenceId;
|
||||||
|
packet.data << remoteSequence;
|
||||||
|
packet.data << previousAcks;
|
||||||
|
|
||||||
|
m_socket.SendPacket(peer.address, packet.data);
|
||||||
|
|
||||||
|
PendingAckPacket pendingAckPacket;
|
||||||
|
pendingAckPacket.data = std::move(packet.data);
|
||||||
|
pendingAckPacket.priority = packet.priority;
|
||||||
|
pendingAckPacket.reliability = packet.reliability;
|
||||||
|
pendingAckPacket.sequenceId = sequenceId;
|
||||||
|
pendingAckPacket.timeSent = m_currentTime;
|
||||||
|
|
||||||
|
peer.pendingAckQueue.emplace_back(std::move(pendingAckPacket));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Initializes the RUdpConnection class
|
||||||
|
* \return true
|
||||||
|
*/
|
||||||
|
|
||||||
|
bool RUdpConnection::Initialize()
|
||||||
|
{
|
||||||
|
std::random_device device;
|
||||||
|
s_randomGenerator.seed(device());
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Uninitializes the RUdpConnection class
|
||||||
|
*/
|
||||||
|
|
||||||
|
void RUdpConnection::Uninitialize()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
std::mt19937_64 RUdpConnection::s_randomGenerator;
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue