tests/enet/host.c - external/github.com/kripken/emscripten - Git at Google

 /*
  * Copyright 2012 The Emscripten Authors.  All rights reserved.
  * Emscripten is available under two separate licenses, the MIT license and the
  * University of Illinois/NCSA Open Source License.  Both these licenses can be
  * found in the LICENSE file.
  */

 /**
  @file host.c
  @brief ENet host management functions
 */
 #define ENET_BUILDING_LIB 1
 #include <string.h>
 #include <time.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 channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
     @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, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
 {
     ENetHost * host;
     ENetPeer * currentPeer;

     if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID)
       return NULL;

     host = (ENetHost *) enet_malloc (sizeof (ENetHost));
     if (host == NULL)
       return NULL;
     memset (host, 0, sizeof (ENetHost));

     host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));
     if (host -> peers == NULL)
     {
        enet_free (host);

        return NULL;
     }
     memset (host -> peers, 0, peerCount * sizeof (ENetPeer));

     host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
     if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0))
     {
        if (host -> socket != ENET_SOCKET_NULL)
          enet_socket_destroy (host -> socket);

        enet_free (host -> peers);
        enet_free (host);

        return NULL;
     }

     enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
     enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
     enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
     enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);

     if (address != NULL)
       host -> address = * address;

     if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
       channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
     else
     if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
       channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;

     host -> randomSeed = (enet_uint32) time(NULL) + (enet_uint32) (size_t) host;
     host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16);
     host -> channelLimit = channelLimit;
     host -> incomingBandwidth = incomingBandwidth;
     host -> outgoingBandwidth = outgoingBandwidth;
     host -> bandwidthThrottleEpoch = 0;
     host -> recalculateBandwidthLimits = 0;
     host -> mtu = ENET_HOST_DEFAULT_MTU;
     host -> peerCount = peerCount;
     host -> commandCount = 0;
     host -> bufferCount = 0;
     host -> checksum = NULL;
     host -> receivedAddress.host = ENET_HOST_ANY;
     host -> receivedAddress.port = 0;
     host -> receivedData = NULL;
     host -> receivedDataLength = 0;

     host -> totalSentData = 0;
     host -> totalSentPackets = 0;
     host -> totalReceivedData = 0;
     host -> totalReceivedPackets = 0;

     host -> compressor.context = NULL;
     host -> compressor.compress = NULL;
     host -> compressor.decompress = NULL;
     host -> compressor.destroy = NULL;

     enet_list_clear (& host -> dispatchQueue);

     for (currentPeer = host -> peers;
          currentPeer < & host -> peers [host -> peerCount];
          ++ currentPeer)
     {
        currentPeer -> host = host;
        currentPeer -> incomingPeerID = currentPeer - host -> peers;
        currentPeer -> outgoingSessionID = currentPeer -> incomingSessionID = 0xFF;
        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_list_clear (& currentPeer -> dispatchedCommands);

        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);
     }

     if (host -> compressor.context != NULL && host -> compressor.destroy)
       (* host -> compressor.destroy) (host -> compressor.context);

     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
     @param data user data supplied to the receiving host
     @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, enet_uint32 data)
 {
     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 -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
     if (currentPeer -> channels == NULL)
       return NULL;
     currentPeer -> channelCount = channelCount;
     currentPeer -> state = ENET_PEER_STATE_CONNECTING;
     currentPeer -> address = * address;
     currentPeer -> connectID = ++ host -> randomSeed;

     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);

         channel -> usedReliableWindows = 0;
         memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows));
     }

     command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
     command.header.channelID = 0xFF;
     command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
     command.connect.incomingSessionID = currentPeer -> incomingSessionID;
     command.connect.outgoingSessionID = currentPeer -> outgoingSessionID;
     command.connect.mtu = ENET_HOST_TO_NET_32 (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);
     command.connect.connectID = currentPeer -> connectID;
     command.connect.data = ENET_HOST_TO_NET_32 (data);

     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);
 }

 /** Sets the packet compressor the host should use to compress and decompress packets.
     @param host host to enable or disable compression for
     @param compressor callbacks for for the packet compressor; if NULL, then compression is disabled
 */
 void
 enet_host_compress (ENetHost * host, const ENetCompressor * compressor)
 {
     if (host -> compressor.context != NULL && host -> compressor.destroy)
       (* host -> compressor.destroy) (host -> compressor.context);

     if (compressor)
       host -> compressor = * compressor;
     else
       host -> compressor.context = NULL;
 }

 /** Limits the maximum allowed channels of future incoming connections.
     @param host host to limit
     @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
 */
 void
 enet_host_channel_limit (ENetHost * host, size_t channelLimit)
 {
     if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
       channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
     else
     if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
       channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;

     host -> channelLimit = channelLimit;
 }


 /** 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 && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
           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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
                 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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
             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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
                    peer -> incomingBandwidthThrottleEpoch == timeCurrent)
                  continue;

                if (peer -> outgoingBandwidth > 0 &&
                    peer -> outgoingBandwidth >= bandwidthLimit)
                  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 && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
              continue;

            command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
            command.header.channelID = 0xFF;
            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;
     }
 }

 /** @} */
	/*
	* Copyright 2012 The Emscripten Authors. All rights reserved.
	* Emscripten is available under two separate licenses, the MIT license and the
	* University of Illinois/NCSA Open Source License. Both these licenses can be
	* found in the LICENSE file.
	*/

	/**
	@file host.c
	@brief ENet host management functions
	*/
	#define ENET_BUILDING_LIB 1
	#include <string.h>
	#include <time.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 channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
	@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, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
	{
	ENetHost * host;
	ENetPeer * currentPeer;

	if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID)
	return NULL;

	host = (ENetHost *) enet_malloc (sizeof (ENetHost));
	if (host == NULL)
	return NULL;
	memset (host, 0, sizeof (ENetHost));

	host -> peers = (ENetPeer ) enet_malloc (peerCount sizeof (ENetPeer));
	if (host -> peers == NULL)
	{
	enet_free (host);

	return NULL;
	}
	memset (host -> peers, 0, peerCount * sizeof (ENetPeer));

	host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
	if (host -> socket == ENET_SOCKET_NULL \|\| (address != NULL && enet_socket_bind (host -> socket, address) < 0))
	{
	if (host -> socket != ENET_SOCKET_NULL)
	enet_socket_destroy (host -> socket);

	enet_free (host -> peers);
	enet_free (host);

	return NULL;
	}

	enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
	enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
	enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
	enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);

	if (address != NULL)
	host -> address = * address;

	if (! channelLimit \|\| channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
	channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
	else
	if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
	channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;

	host -> randomSeed = (enet_uint32) time(NULL) + (enet_uint32) (size_t) host;
	host -> randomSeed = (host -> randomSeed << 16) \| (host -> randomSeed >> 16);
	host -> channelLimit = channelLimit;
	host -> incomingBandwidth = incomingBandwidth;
	host -> outgoingBandwidth = outgoingBandwidth;
	host -> bandwidthThrottleEpoch = 0;
	host -> recalculateBandwidthLimits = 0;
	host -> mtu = ENET_HOST_DEFAULT_MTU;
	host -> peerCount = peerCount;
	host -> commandCount = 0;
	host -> bufferCount = 0;
	host -> checksum = NULL;
	host -> receivedAddress.host = ENET_HOST_ANY;
	host -> receivedAddress.port = 0;
	host -> receivedData = NULL;
	host -> receivedDataLength = 0;

	host -> totalSentData = 0;
	host -> totalSentPackets = 0;
	host -> totalReceivedData = 0;
	host -> totalReceivedPackets = 0;

	host -> compressor.context = NULL;
	host -> compressor.compress = NULL;
	host -> compressor.decompress = NULL;
	host -> compressor.destroy = NULL;

	enet_list_clear (& host -> dispatchQueue);

	for (currentPeer = host -> peers;
	currentPeer < & host -> peers [host -> peerCount];
	++ currentPeer)
	{
	currentPeer -> host = host;
	currentPeer -> incomingPeerID = currentPeer - host -> peers;
	currentPeer -> outgoingSessionID = currentPeer -> incomingSessionID = 0xFF;
	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_list_clear (& currentPeer -> dispatchedCommands);

	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);
	}

	if (host -> compressor.context != NULL && host -> compressor.destroy)
	(* host -> compressor.destroy) (host -> compressor.context);

	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
	@param data user data supplied to the receiving host
	@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, enet_uint32 data)
	{
	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 -> channels = (ENetChannel ) enet_malloc (channelCount sizeof (ENetChannel));
	if (currentPeer -> channels == NULL)
	return NULL;
	currentPeer -> channelCount = channelCount;
	currentPeer -> state = ENET_PEER_STATE_CONNECTING;
	currentPeer -> address = * address;
	currentPeer -> connectID = ++ host -> randomSeed;

	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);

	channel -> usedReliableWindows = 0;
	memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows));
	}

	command.header.command = ENET_PROTOCOL_COMMAND_CONNECT \| ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
	command.header.channelID = 0xFF;
	command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
	command.connect.incomingSessionID = currentPeer -> incomingSessionID;
	command.connect.outgoingSessionID = currentPeer -> outgoingSessionID;
	command.connect.mtu = ENET_HOST_TO_NET_32 (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);
	command.connect.connectID = currentPeer -> connectID;
	command.connect.data = ENET_HOST_TO_NET_32 (data);

	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);
	}

	/** Sets the packet compressor the host should use to compress and decompress packets.
	@param host host to enable or disable compression for
	@param compressor callbacks for for the packet compressor; if NULL, then compression is disabled
	*/
	void
	enet_host_compress (ENetHost * host, const ENetCompressor * compressor)
	{
	if (host -> compressor.context != NULL && host -> compressor.destroy)
	(* host -> compressor.destroy) (host -> compressor.context);

	if (compressor)
	host -> compressor = * compressor;
	else
	host -> compressor.context = NULL;
	}

	/** Limits the maximum allowed channels of future incoming connections.
	@param host host to limit
	@param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
	*/
	void
	enet_host_channel_limit (ENetHost * host, size_t channelLimit)
	{
	if (! channelLimit \|\| channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
	channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
	else
	if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
	channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;

	host -> channelLimit = channelLimit;
	}


	/** 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 && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
	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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) \|\|
	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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) \|\|
	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 -> state != ENET_PEER_STATE_DISCONNECT_LATER) \|\|
	peer -> incomingBandwidthThrottleEpoch == timeCurrent)
	continue;

	if (peer -> outgoingBandwidth > 0 &&
	peer -> outgoingBandwidth >= bandwidthLimit)
	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 && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
	continue;

	command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT \| ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
	command.header.channelID = 0xFF;
	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;
	}
	}

	/** @} */