mirror of
https://github.com/lsalzman/enet
synced 2024-11-21 14:29:05 -07:00
391 lines
13 KiB
C
391 lines
13 KiB
C
/**
|
|
@file host.c
|
|
@brief ENet host management functions
|
|
*/
|
|
#define ENET_BUILDING_LIB 1
|
|
#include <string.h>
|
|
#include "enet/enet.h"
|
|
|
|
/** @defgroup host ENet host functions
|
|
@{
|
|
*/
|
|
|
|
/** Creates a host for communicating to peers.
|
|
|
|
@param address the address at which other peers may connect to this host. If NULL, then no peers may connect to the host.
|
|
@param peerCount the maximum number of peers that should be allocated for the host.
|
|
@param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
|
|
@param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
|
|
|
|
@returns the host on success and NULL on failure
|
|
|
|
@remarks ENet will strategically drop packets on specific sides of a connection between hosts
|
|
to ensure the host's bandwidth is not overwhelmed. The bandwidth parameters also determine
|
|
the window size of a connection which limits the amount of reliable packets that may be in transit
|
|
at any given time.
|
|
*/
|
|
ENetHost *
|
|
enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
|
|
{
|
|
ENetHost * host = (ENetHost *) enet_malloc (sizeof (ENetHost));
|
|
ENetPeer * currentPeer;
|
|
|
|
host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));
|
|
memset (host -> peers, 0, peerCount * sizeof (ENetPeer));
|
|
|
|
host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM, address);
|
|
if (host -> socket == ENET_SOCKET_NULL)
|
|
{
|
|
enet_free (host -> peers);
|
|
enet_free (host);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if (address != NULL)
|
|
host -> address = * address;
|
|
|
|
host -> incomingBandwidth = incomingBandwidth;
|
|
host -> outgoingBandwidth = outgoingBandwidth;
|
|
host -> bandwidthThrottleEpoch = 0;
|
|
host -> recalculateBandwidthLimits = 0;
|
|
host -> mtu = ENET_HOST_DEFAULT_MTU;
|
|
host -> peerCount = peerCount;
|
|
host -> lastServicedPeer = host -> peers;
|
|
host -> commandCount = 0;
|
|
host -> bufferCount = 0;
|
|
host -> receivedAddress.host = ENET_HOST_ANY;
|
|
host -> receivedAddress.port = 0;
|
|
host -> receivedDataLength = 0;
|
|
|
|
for (currentPeer = host -> peers;
|
|
currentPeer < & host -> peers [host -> peerCount];
|
|
++ currentPeer)
|
|
{
|
|
currentPeer -> host = host;
|
|
currentPeer -> incomingPeerID = currentPeer - host -> peers;
|
|
currentPeer -> data = NULL;
|
|
|
|
enet_list_clear (& currentPeer -> acknowledgements);
|
|
enet_list_clear (& currentPeer -> sentReliableCommands);
|
|
enet_list_clear (& currentPeer -> sentUnreliableCommands);
|
|
enet_list_clear (& currentPeer -> outgoingReliableCommands);
|
|
enet_list_clear (& currentPeer -> outgoingUnreliableCommands);
|
|
|
|
enet_peer_reset (currentPeer);
|
|
}
|
|
|
|
return host;
|
|
}
|
|
|
|
/** Destroys the host and all resources associated with it.
|
|
@param host pointer to the host to destroy
|
|
*/
|
|
void
|
|
enet_host_destroy (ENetHost * host)
|
|
{
|
|
ENetPeer * currentPeer;
|
|
|
|
enet_socket_destroy (host -> socket);
|
|
|
|
for (currentPeer = host -> peers;
|
|
currentPeer < & host -> peers [host -> peerCount];
|
|
++ currentPeer)
|
|
{
|
|
enet_peer_reset (currentPeer);
|
|
}
|
|
|
|
enet_free (host -> peers);
|
|
enet_free (host);
|
|
}
|
|
|
|
/** Initiates a connection to a foreign host.
|
|
@param host host seeking the connection
|
|
@param address destination for the connection
|
|
@param channelCount number of channels to allocate
|
|
@returns a peer representing the foreign host on success, NULL on failure
|
|
@remarks The peer returned will have not completed the connection until enet_host_service()
|
|
notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
|
|
*/
|
|
ENetPeer *
|
|
enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount)
|
|
{
|
|
ENetPeer * currentPeer;
|
|
ENetChannel * channel;
|
|
ENetProtocol command;
|
|
|
|
if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
|
|
channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
|
|
else
|
|
if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
|
|
channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
|
|
|
|
for (currentPeer = host -> peers;
|
|
currentPeer < & host -> peers [host -> peerCount];
|
|
++ currentPeer)
|
|
{
|
|
if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
|
|
break;
|
|
}
|
|
|
|
if (currentPeer >= & host -> peers [host -> peerCount])
|
|
return NULL;
|
|
|
|
currentPeer -> state = ENET_PEER_STATE_CONNECTING;
|
|
currentPeer -> address = * address;
|
|
currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
|
|
currentPeer -> channelCount = channelCount;
|
|
currentPeer -> challenge = (enet_uint32) enet_rand ();
|
|
|
|
if (host -> outgoingBandwidth == 0)
|
|
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
|
else
|
|
currentPeer -> windowSize = (host -> outgoingBandwidth /
|
|
ENET_PEER_WINDOW_SIZE_SCALE) *
|
|
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
|
|
|
if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
|
|
currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
|
else
|
|
if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
|
|
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
|
|
|
for (channel = currentPeer -> channels;
|
|
channel < & currentPeer -> channels [channelCount];
|
|
++ channel)
|
|
{
|
|
channel -> outgoingReliableSequenceNumber = 0;
|
|
channel -> outgoingUnreliableSequenceNumber = 0;
|
|
channel -> incomingReliableSequenceNumber = 0;
|
|
channel -> incomingUnreliableSequenceNumber = 0;
|
|
|
|
enet_list_clear (& channel -> incomingReliableCommands);
|
|
enet_list_clear (& channel -> incomingUnreliableCommands);
|
|
}
|
|
|
|
command.header.command = ENET_PROTOCOL_COMMAND_CONNECT;
|
|
command.header.channelID = 0xFF;
|
|
command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
|
|
command.header.commandLength = sizeof (ENetProtocolConnect);
|
|
command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
|
|
command.connect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu);
|
|
command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize);
|
|
command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
|
|
command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
|
|
command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
|
|
command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
|
|
command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
|
|
command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
|
|
|
|
enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0);
|
|
|
|
return currentPeer;
|
|
}
|
|
|
|
/** Queues a packet to be sent to all peers associated with the host.
|
|
@param host host on which to broadcast the packet
|
|
@param channelID channel on which to broadcast
|
|
@param packet packet to broadcast
|
|
*/
|
|
void
|
|
enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
|
|
{
|
|
ENetPeer * currentPeer;
|
|
|
|
for (currentPeer = host -> peers;
|
|
currentPeer < & host -> peers [host -> peerCount];
|
|
++ currentPeer)
|
|
{
|
|
if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
|
|
continue;
|
|
|
|
enet_peer_send (currentPeer, channelID, packet);
|
|
}
|
|
|
|
if (packet -> referenceCount == 0)
|
|
enet_packet_destroy (packet);
|
|
}
|
|
|
|
/** Adjusts the bandwidth limits of a host.
|
|
@param host host to adjust
|
|
@param incomingBandwidth new incoming bandwidth
|
|
@param outgoingBandwidth new outgoing bandwidth
|
|
@remarks the incoming and outgoing bandwidth parameters are identical in function to those
|
|
specified in enet_host_create().
|
|
*/
|
|
void
|
|
enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
|
|
{
|
|
host -> incomingBandwidth = incomingBandwidth;
|
|
host -> outgoingBandwidth = outgoingBandwidth;
|
|
host -> recalculateBandwidthLimits = 1;
|
|
}
|
|
|
|
void
|
|
enet_host_bandwidth_throttle (ENetHost * host)
|
|
{
|
|
enet_uint32 timeCurrent = enet_time_get (),
|
|
elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
|
|
peersTotal = 0,
|
|
dataTotal = 0,
|
|
peersRemaining,
|
|
bandwidth,
|
|
throttle = 0,
|
|
bandwidthLimit = 0;
|
|
int needsAdjustment;
|
|
ENetPeer * peer;
|
|
ENetProtocol command;
|
|
|
|
if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
|
|
return;
|
|
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
if (peer -> state != ENET_PEER_STATE_CONNECTED)
|
|
continue;
|
|
|
|
++ peersTotal;
|
|
dataTotal += peer -> outgoingDataTotal;
|
|
}
|
|
|
|
if (peersTotal == 0)
|
|
return;
|
|
|
|
peersRemaining = peersTotal;
|
|
needsAdjustment = 1;
|
|
|
|
if (host -> outgoingBandwidth == 0)
|
|
bandwidth = ~0;
|
|
else
|
|
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
|
|
|
|
while (peersRemaining > 0 && needsAdjustment != 0)
|
|
{
|
|
needsAdjustment = 0;
|
|
|
|
if (dataTotal < bandwidth)
|
|
throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
|
|
else
|
|
throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
|
|
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
enet_uint32 peerBandwidth;
|
|
|
|
if (peer -> state != ENET_PEER_STATE_CONNECTED ||
|
|
peer -> incomingBandwidth == 0 ||
|
|
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
|
|
continue;
|
|
|
|
peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000;
|
|
if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth)
|
|
continue;
|
|
|
|
peer -> packetThrottleLimit = (peerBandwidth *
|
|
ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal;
|
|
|
|
if (peer -> packetThrottleLimit == 0)
|
|
peer -> packetThrottleLimit = 1;
|
|
|
|
if (peer -> packetThrottle > peer -> packetThrottleLimit)
|
|
peer -> packetThrottle = peer -> packetThrottleLimit;
|
|
|
|
peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
|
|
|
|
|
|
needsAdjustment = 1;
|
|
-- peersRemaining;
|
|
bandwidth -= peerBandwidth;
|
|
dataTotal -= peerBandwidth;
|
|
}
|
|
}
|
|
|
|
if (peersRemaining > 0)
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
if (peer -> state != ENET_PEER_STATE_CONNECTED ||
|
|
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
|
|
continue;
|
|
|
|
peer -> packetThrottleLimit = throttle;
|
|
|
|
if (peer -> packetThrottle > peer -> packetThrottleLimit)
|
|
peer -> packetThrottle = peer -> packetThrottleLimit;
|
|
}
|
|
|
|
if (host -> recalculateBandwidthLimits)
|
|
{
|
|
host -> recalculateBandwidthLimits = 0;
|
|
|
|
peersRemaining = peersTotal;
|
|
bandwidth = host -> incomingBandwidth;
|
|
needsAdjustment = 1;
|
|
|
|
if (bandwidth == 0)
|
|
bandwidthLimit = 0;
|
|
else
|
|
while (peersRemaining > 0 && needsAdjustment != 0)
|
|
{
|
|
needsAdjustment = 0;
|
|
bandwidthLimit = bandwidth / peersRemaining;
|
|
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
if (peer -> state != ENET_PEER_STATE_CONNECTED ||
|
|
peer -> incomingBandwidthThrottleEpoch == timeCurrent)
|
|
continue;
|
|
|
|
if (peer -> outgoingBandwidth > 0 &&
|
|
bandwidthLimit > peer -> outgoingBandwidth)
|
|
continue;
|
|
|
|
peer -> incomingBandwidthThrottleEpoch = timeCurrent;
|
|
|
|
needsAdjustment = 1;
|
|
-- peersRemaining;
|
|
bandwidth -= peer -> outgoingBandwidth;
|
|
}
|
|
}
|
|
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
if (peer -> state != ENET_PEER_STATE_CONNECTED)
|
|
continue;
|
|
|
|
command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT;
|
|
command.header.channelID = 0xFF;
|
|
command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
|
|
command.header.commandLength = sizeof (ENetProtocolBandwidthLimit);
|
|
command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
|
|
|
|
if (peer -> incomingBandwidthThrottleEpoch == timeCurrent)
|
|
command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth);
|
|
else
|
|
command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit);
|
|
|
|
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
|
|
}
|
|
}
|
|
|
|
host -> bandwidthThrottleEpoch = timeCurrent;
|
|
|
|
for (peer = host -> peers;
|
|
peer < & host -> peers [host -> peerCount];
|
|
++ peer)
|
|
{
|
|
peer -> incomingDataTotal = 0;
|
|
peer -> outgoingDataTotal = 0;
|
|
}
|
|
}
|
|
|
|
/** @} */
|