cleaned up old code

include/enet.h.us.c

@@ -1,6460 +0,0 @@
-/**
- * include/enet.h - a Single-Header auto-generated variant of enet.h library.
- *
- * Usage:
- * #define ENET_IMPLEMENTATION exactly in ONE source file right BEFORE including the library, like:
- *
- * #define ENET_IMPLEMENTATION
- * #include <enet.h>
- *
- */
-
-#ifdef ENET_IMPLEMENTATION
-# define ENET_BUILDING_LIB 1
-#endif
-
-/**
- * @file  enet.h
- * @brief ENet public header file
- */
-#ifndef __ENET_ENET_H__
-# define __ENET_ENET_H__
-
-# ifdef __cplusplus
-extern "C"
-{
-# endif
-
-# include <stdlib.h>
-
-# ifdef _WIN32
-
-/**
- * @file  win32.h
- * @brief ENet Win32 header
- */
-#  ifndef __ENET_WIN32_H__
-#   define __ENET_WIN32_H__
-
-#   ifdef _MSC_VER
-#    ifdef ENET_BUILDING_LIB
-#     pragma warning (disable: 4267)// size_t to int conversion
-#     pragma warning (disable: 4244)// 64bit to 32bit int
-#     pragma warning (disable: 4018)// signed/unsigned mismatch
-#     pragma warning (disable: 4146)// unary minus operator applied to unsigned type
-#    endif
-#   endif
-
-
-#   include <winsock2.h>
-
-typedef SOCKET ENetSocket;
-
-#   define ENET_SOCKET_NULL INVALID_SOCKET
-
-#   define ENET_HOST_TO_NET_16(value) (htons(value))
-#   define ENET_HOST_TO_NET_32(value) (htonl(value))
-
-#   define ENET_NET_TO_HOST_16(value) (ntohs(value))
-#   define ENET_NET_TO_HOST_32(value) (ntohl(value))
-
-typedef struct {
-    size_t dataLength;
-    void * data;
-} ENetBuffer;
-
-#   define ENET_CALLBACK __cdecl
-
-#   ifdef ENET_DLL
-#    ifdef ENET_BUILDING_LIB
-#     define ENET_API __declspec(dllexport)
-#    else
-#     define ENET_API __declspec(dllimport)
-#    endif /* ENET_BUILDING_LIB */
-#   else /* !ENET_DLL */
-#    define ENET_API extern
-#   endif /* ENET_DLL */
-
-typedef fd_set ENetSocketSet;
-
-#   define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
-#   define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
-#   define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
-#   define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
-
-#  endif /* __ENET_WIN32_H__ */
-# else // ifdef _WIN32
-
-/**
- * @file  unix.h
- * @brief ENet Unix header
- */
-#  ifndef __ENET_UNIX_H__
-#   define __ENET_UNIX_H__
-
-
-#   include <sys/time.h>
-#   include <sys/types.h>
-#   include <sys/socket.h>
-#   include <netinet/in.h>
-#   include <unistd.h>
-
-#   ifdef MSG_MAXIOVLEN
-#    define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
-#   endif
-
-typedef int ENetSocket;
-
-#   define ENET_SOCKET_NULL -1
-
-#   define ENET_HOST_TO_NET_16(value) (htons(value)) /**< macro that converts host to net byte-order of a 16-bit value */
-#   define ENET_HOST_TO_NET_32(value) (htonl(value)) /**< macro that converts host to net byte-order of a 32-bit value */
-
-#   define ENET_NET_TO_HOST_16(value) (ntohs(value)) /**< macro that converts net to host byte-order of a 16-bit value */
-#   define ENET_NET_TO_HOST_32(value) (ntohl(value)) /**< macro that converts net to host byte-order of a 32-bit value */
-
-typedef struct {
-    void * data;
-    size_t dataLength;
-} ENetBuffer;
-
-#   define ENET_CALLBACK
-
-#   define ENET_API extern
-
-typedef fd_set ENetSocketSet;
-
-#   define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
-#   define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
-#   define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
-#   define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
-
-#  endif /* __ENET_UNIX_H__ */
-# endif // ifdef _WIN32
-
-/**
- * @file  types.h
- * @brief type definitions for ENet
- */
-# ifndef __ENET_TYPES_H__
-#  define __ENET_TYPES_H__
-
-#  include <stdint.h>
-
-typedef unsigned char enet_uint8;   /**< unsigned 8-bit type  */
-typedef unsigned short enet_uint16; /**< unsigned 16-bit type */
-typedef unsigned int enet_uint32;   /**< unsigned 32-bit type */
-typedef uint64_t enet_uint64;
-
-# endif /* __ENET_TYPES_H__ */
-
-/**
- * @file  protocol.h
- * @brief ENet protocol
- */
-# ifndef __ENET_PROTOCOL_H__
-#  define __ENET_PROTOCOL_H__
-
-
-enum {
-    ENET_PROTOCOL_MINIMUM_MTU             = 576,
-    ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-    ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-    ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-    ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-    ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-    ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-    ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-    ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-};
-
-typedef enum _ENetProtocolCommand {
-    ENET_PROTOCOL_COMMAND_NONE                     = 0,
-    ENET_PROTOCOL_COMMAND_ACKNOWLEDGE              = 1,
-    ENET_PROTOCOL_COMMAND_CONNECT                  = 2,
-    ENET_PROTOCOL_COMMAND_VERIFY_CONNECT           = 3,
-    ENET_PROTOCOL_COMMAND_DISCONNECT               = 4,
-    ENET_PROTOCOL_COMMAND_PING                     = 5,
-    ENET_PROTOCOL_COMMAND_SEND_RELIABLE            = 6,
-    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE          = 7,
-    ENET_PROTOCOL_COMMAND_SEND_FRAGMENT            = 8,
-    ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED         = 9,
-    ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT          = 10,
-    ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE       = 11,
-    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-    ENET_PROTOCOL_COMMAND_COUNT                    = 13,
-
-    ENET_PROTOCOL_COMMAND_MASK                     = 0x0F
-} ENetProtocolCommand;
-
-typedef enum _ENetProtocolFlag {
-    ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-    ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-
-    ENET_PROTOCOL_HEADER_FLAG_COMPRESSED   = (1 << 14),
-    ENET_PROTOCOL_HEADER_FLAG_SENT_TIME    = (1 << 15),
-    ENET_PROTOCOL_HEADER_FLAG_MASK         = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-
-    ENET_PROTOCOL_HEADER_SESSION_MASK      = (3 << 12),
-    ENET_PROTOCOL_HEADER_SESSION_SHIFT     = 12
-} ENetProtocolFlag;
-
-#  ifdef _MSC_VER
-#   pragma pack(push, 1)
-#   define ENET_PACKED
-#  elif defined(__GNUC__) || defined(__clang__)
-#   define ENET_PACKED __attribute__((packed))
-#  else
-#   define ENET_PACKED
-#  endif
-
-typedef struct _ENetProtocolHeader {
-    enet_uint16 peerID;
-    enet_uint16 sentTime;
-} ENET_PACKED ENetProtocolHeader;
-
-typedef struct _ENetProtocolCommandHeader {
-    enet_uint8  command;
-    enet_uint8  channelID;
-    enet_uint16 reliableSequenceNumber;
-} ENET_PACKED ENetProtocolCommandHeader;
-
-typedef struct _ENetProtocolAcknowledge {
-    ENetProtocolCommandHeader header;
-    enet_uint16               receivedReliableSequenceNumber;
-    enet_uint16               receivedSentTime;
-} ENET_PACKED ENetProtocolAcknowledge;
-
-typedef struct _ENetProtocolConnect {
-    ENetProtocolCommandHeader header;
-    enet_uint16               outgoingPeerID;
-    enet_uint8                incomingSessionID;
-    enet_uint8                outgoingSessionID;
-    enet_uint32               mtu;
-    enet_uint32               windowSize;
-    enet_uint32               channelCount;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-    enet_uint32               connectID;
-    enet_uint32               data;
-} ENET_PACKED ENetProtocolConnect;
-
-typedef struct _ENetProtocolVerifyConnect {
-    ENetProtocolCommandHeader header;
-    enet_uint16               outgoingPeerID;
-    enet_uint8                incomingSessionID;
-    enet_uint8                outgoingSessionID;
-    enet_uint32               mtu;
-    enet_uint32               windowSize;
-    enet_uint32               channelCount;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-    enet_uint32               connectID;
-} ENET_PACKED ENetProtocolVerifyConnect;
-
-typedef struct _ENetProtocolBandwidthLimit {
-    ENetProtocolCommandHeader header;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-} ENET_PACKED ENetProtocolBandwidthLimit;
-
-typedef struct _ENetProtocolThrottleConfigure {
-    ENetProtocolCommandHeader header;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-} ENET_PACKED ENetProtocolThrottleConfigure;
-
-typedef struct _ENetProtocolDisconnect {
-    ENetProtocolCommandHeader header;
-    enet_uint32               data;
-} ENET_PACKED ENetProtocolDisconnect;
-
-typedef struct _ENetProtocolPing {
-    ENetProtocolCommandHeader header;
-} ENET_PACKED ENetProtocolPing;
-
-typedef struct _ENetProtocolSendReliable {
-    ENetProtocolCommandHeader header;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendReliable;
-
-typedef struct _ENetProtocolSendUnreliable {
-    ENetProtocolCommandHeader header;
-    enet_uint16               unreliableSequenceNumber;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendUnreliable;
-
-typedef struct _ENetProtocolSendUnsequenced {
-    ENetProtocolCommandHeader header;
-    enet_uint16               unsequencedGroup;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendUnsequenced;
-
-typedef struct _ENetProtocolSendFragment {
-    ENetProtocolCommandHeader header;
-    enet_uint16               startSequenceNumber;
-    enet_uint16               dataLength;
-    enet_uint32               fragmentCount;
-    enet_uint32               fragmentNumber;
-    enet_uint32               totalLength;
-    enet_uint32               fragmentOffset;
-} ENET_PACKED ENetProtocolSendFragment;
-
-typedef union _ENetProtocol {
-    ENetProtocolCommandHeader     header;
-    ENetProtocolAcknowledge       acknowledge;
-    ENetProtocolConnect           connect;
-    ENetProtocolVerifyConnect     verifyConnect;
-    ENetProtocolDisconnect        disconnect;
-    ENetProtocolPing              ping;
-    ENetProtocolSendReliable      sendReliable;
-    ENetProtocolSendUnreliable    sendUnreliable;
-    ENetProtocolSendUnsequenced   sendUnsequenced;
-    ENetProtocolSendFragment      sendFragment;
-    ENetProtocolBandwidthLimit    bandwidthLimit;
-    ENetProtocolThrottleConfigure throttleConfigure;
-} ENET_PACKED ENetProtocol;
-
-#  ifdef _MSC_VER
-#   pragma pack(pop)
-#  endif
-
-# endif /* __ENET_PROTOCOL_H__ */
-
-/**
- * @file  list.h
- * @brief ENet list management
- */
-# ifndef __ENET_LIST_H__
-#  define __ENET_LIST_H__
-
-
-typedef struct _ENetListNode {
-    struct _ENetListNode *next;
-    struct _ENetListNode *previous;
-} ENetListNode;
-
-typedef ENetListNode *ENetListIterator;
-
-typedef struct _ENetList {
-    ENetListNode sentinel;
-} ENetList;
-
-extern void
-enet_list_clear(ENetList *);
-
-extern ENetListIterator enet_list_insert(ENetListIterator, void *);
-extern void *enet_list_remove(ENetListIterator);
-extern ENetListIterator enet_list_move(ENetListIterator, void *, void *);
-
-extern size_t
-enet_list_size(ENetList *);
-
-#  define enet_list_begin(list)        ((list)->sentinel.next)
-#  define enet_list_end(list)          (&(list)->sentinel)
-
-#  define enet_list_empty(list)        (enet_list_begin(list) == enet_list_end(list))
-
-#  define enet_list_next(iterator)     ((iterator)->next)
-#  define enet_list_previous(iterator) ((iterator)->previous)
-
-#  define enet_list_front(list)        ((void *) (list)->sentinel.next)
-#  define enet_list_back(list)         ((void *) (list)->sentinel.previous)
-
-# endif /* __ENET_LIST_H__ */
-
-/**
- * @file  time.h
- * @brief ENet time constants and macros
- */
-# ifndef __ENET_TIME_H__
-#  define __ENET_TIME_H__
-
-#  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))
-
-# endif /* __ENET_TIME_H__ */
-
-/**
- * @file  utility.h
- * @brief ENet utility header
- */
-# ifndef __ENET_UTILITY_H__
-#  define __ENET_UTILITY_H__
-
-#  define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
-#  define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-
-# endif /* __ENET_UTILITY_H__ */
-
-/**
- * @file  callbacks.h
- * @brief ENet callbacks
- */
-# ifndef __ENET_CALLBACKS_H__
-#  define __ENET_CALLBACKS_H__
-
-
-typedef struct _ENetCallbacks {
-    void * (ENET_CALLBACK * malloc)(size_t size);
-    void (ENET_CALLBACK * free)(void *memory);
-    void (ENET_CALLBACK * no_memory)(void);
-} ENetCallbacks;
-
-/** @defgroup callbacks ENet internal callbacks
- *  @{
- *  @ingroup private
- */
-extern void *enet_malloc(size_t);
-extern void
-enet_free(void *);
-
-/** @} */
-
-# endif /* __ENET_CALLBACKS_H__ */
-
-# define ENET_VERSION_MAJOR 1
-# define ENET_VERSION_MINOR 4
-# define ENET_VERSION_PATCH 4
-# define ENET_VERSION_CREATE(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
-# define ENET_VERSION_GET_MAJOR(version)          (((version) >> 16) & 0xFF)
-# define ENET_VERSION_GET_MINOR(version)          (((version) >> 8) & 0xFF)
-# define ENET_VERSION_GET_PATCH(version)          ((version) & 0xFF)
-# define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-typedef enet_uint32 ENetVersion;
-
-struct _ENetHost;
-struct _ENetEvent;
-struct _ENetPacket;
-
-typedef enum _ENetSocketType {
-    ENET_SOCKET_TYPE_STREAM   = 1,
-    ENET_SOCKET_TYPE_DATAGRAM = 2
-} ENetSocketType;
-
-typedef enum _ENetSocketWait {
-    ENET_SOCKET_WAIT_NONE      = 0,
-    ENET_SOCKET_WAIT_SEND      = (1 << 0),
-    ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-    ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-} ENetSocketWait;
-
-typedef enum _ENetSocketOption {
-    ENET_SOCKOPT_NONBLOCK  = 1,
-    ENET_SOCKOPT_BROADCAST = 2,
-    ENET_SOCKOPT_RCVBUF    = 3,
-    ENET_SOCKOPT_SNDBUF    = 4,
-    ENET_SOCKOPT_REUSEADDR = 5,
-    ENET_SOCKOPT_RCVTIMEO  = 6,
-    ENET_SOCKOPT_SNDTIMEO  = 7,
-    ENET_SOCKOPT_ERROR     = 8,
-    ENET_SOCKOPT_NODELAY   = 9
-} ENetSocketOption;
-
-typedef enum _ENetSocketShutdown {
-    ENET_SOCKET_SHUTDOWN_READ       = 0,
-    ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-} ENetSocketShutdown;
-
-# define ENET_HOST_ANY       0
-# define ENET_HOST_BROADCAST 0xFFFFFFFFU
-# define ENET_PORT_ANY       0
-
-/**
- * Portable internet address structure.
- *
- * The host must be specified in network byte-order, and the port must be in host
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
- */
-typedef struct _ENetAddress {
-    enet_uint32 host;
-    enet_uint16 port;
-} ENetAddress;
-
-/**
- * Packet flag bit constants.
- *
- * The host must be specified in network byte-order, and the port must be in
- * host byte-order. The constant ENET_HOST_ANY may be used to specify the
- * default server host.
- *
- * @sa ENetPacket
- */
-typedef enum _ENetPacketFlag {
-    /** packet must be received by the target peer and resend attempts should be
-     * made until the packet is delivered */
-    ENET_PACKET_FLAG_RELIABLE            = (1 << 0),
-
-    /** packet will not be sequenced with other packets
-     * not supported for reliable packets
-     */
-    ENET_PACKET_FLAG_UNSEQUENCED         = (1 << 1),
-    /** packet will not allocate data, and user must supply it instead */
-    ENET_PACKET_FLAG_NO_ALLOCATE         = (1 << 2),
-
-    /** packet will be fragmented using unreliable (instead of reliable) sends
-     * if it exceeds the MTU */
-    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-
-    /** whether the packet has been sent from all queues it has been entered into */
-    ENET_PACKET_FLAG_SENT                = (1 << 8)
-} ENetPacketFlag;
-
-typedef void (ENET_CALLBACK * ENetPacketFreeCallback)(struct _ENetPacket *);
-
-/**
- * ENet packet structure.
- *
- * An ENet data packet that may be sent to or received from a peer. The shown
- * fields should only be read and never modified. The data field contains the
- * allocated data for the packet. The dataLength fields specifies the length
- * of the allocated data.  The flags field is either 0 (specifying no flags),
- * or a bitwise-or of any combination of the following flags:
- *
- *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
- *    and resend attempts should be made until the packet is delivered
- *
- *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets
- *    (not supported for reliable packets)
- *
- *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
- *
- *    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable
- *    (instead of reliable) sends if it exceeds the MTU
- *
- *    ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into
- * @sa ENetPacketFlag
- */
-typedef struct _ENetPacket {
-    size_t                 referenceCount; /**< internal use only */
-    enet_uint32            flags;          /**< bitwise-or of ENetPacketFlag constants */
-    enet_uint8 *           data;           /**< allocated data for packet */
-    size_t                 dataLength;     /**< length of data */
-    ENetPacketFreeCallback freeCallback;   /**< function to be called when the packet is no longer in use */
-    void *                 userData;       /**< application private data, may be freely modified */
-} ENetPacket;
-
-typedef struct _ENetAcknowledgement {
-    ENetListNode acknowledgementList;
-    enet_uint32  sentTime;
-    ENetProtocol command;
-} ENetAcknowledgement;
-
-typedef struct _ENetOutgoingCommand {
-    ENetListNode outgoingCommandList;
-    enet_uint16  reliableSequenceNumber;
-    enet_uint16  unreliableSequenceNumber;
-    enet_uint32  sentTime;
-    enet_uint32  roundTripTimeout;
-    enet_uint32  roundTripTimeoutLimit;
-    enet_uint32  fragmentOffset;
-    enet_uint16  fragmentLength;
-    enet_uint16  sendAttempts;
-    ENetProtocol command;
-    ENetPacket * packet;
-} ENetOutgoingCommand;
-
-typedef struct _ENetIncomingCommand {
-    ENetListNode incomingCommandList;
-    enet_uint16  reliableSequenceNumber;
-    enet_uint16  unreliableSequenceNumber;
-    ENetProtocol command;
-    enet_uint32  fragmentCount;
-    enet_uint32  fragmentsRemaining;
-    enet_uint32 *fragments;
-    ENetPacket * packet;
-} ENetIncomingCommand;
-
-typedef enum _ENetPeerState {
-    ENET_PEER_STATE_DISCONNECTED             = 0,
-    ENET_PEER_STATE_CONNECTING               = 1,
-    ENET_PEER_STATE_ACKNOWLEDGING_CONNECT    = 2,
-    ENET_PEER_STATE_CONNECTION_PENDING       = 3,
-    ENET_PEER_STATE_CONNECTION_SUCCEEDED     = 4,
-    ENET_PEER_STATE_CONNECTED                = 5,
-    ENET_PEER_STATE_DISCONNECT_LATER         = 6,
-    ENET_PEER_STATE_DISCONNECTING            = 7,
-    ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
-    ENET_PEER_STATE_ZOMBIE                   = 9
-} ENetPeerState;
-
-# ifndef ENET_BUFFER_MAXIMUM
-#  define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-# endif
-
-enum {
-    ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-    ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-    ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-    ENET_HOST_DEFAULT_MTU                  = 1400,
-    ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-    ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-
-    ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-    ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-    ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-    ENET_PEER_PACKET_THROTTLE_COUNTER      = 7,
-    ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-    ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-    ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-    ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-    ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-    ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-    ENET_PEER_TIMEOUT_LIMIT                = 32,
-    ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-    ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-    ENET_PEER_PING_INTERVAL                = 500,
-    ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-    ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-    ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-    ENET_PEER_RELIABLE_WINDOWS             = 16,
-    ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-    ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-};
-
-typedef struct _ENetChannel {
-    enet_uint16 outgoingReliableSequenceNumber;
-    enet_uint16 outgoingUnreliableSequenceNumber;
-    enet_uint16 usedReliableWindows;
-    enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
-    enet_uint16 incomingReliableSequenceNumber;
-    enet_uint16 incomingUnreliableSequenceNumber;
-    ENetList    incomingReliableCommands;
-    ENetList    incomingUnreliableCommands;
-} ENetChannel;
-
-/**
- * An ENet peer which data packets may be sent or received from.
- *
- * No fields should be modified unless otherwise specified.
- */
-typedef struct _ENetPeer {
-    ENetListNode      dispatchList;
-    struct _ENetHost *host;
-    enet_uint16       outgoingPeerID;
-    enet_uint16       incomingPeerID;
-    enet_uint32       connectID;
-    enet_uint8        outgoingSessionID;
-    enet_uint8        incomingSessionID;
-    ENetAddress       address; /**< Internet address of the peer */
-    void *            data;    /**< Application private data, may be freely modified */
-    ENetPeerState     state;
-    ENetChannel *     channels;
-    size_t            channelCount;      /**< Number of channels allocated for communication with peer */
-    enet_uint32       incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
-    enet_uint32       outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
-    enet_uint32       incomingBandwidthThrottleEpoch;
-    enet_uint32       outgoingBandwidthThrottleEpoch;
-    enet_uint32       incomingDataTotal;
-    enet_uint32       outgoingDataTotal;
-    enet_uint32       lastSendTime;
-    enet_uint32       lastReceiveTime;
-    enet_uint32       nextTimeout;
-    enet_uint32       earliestTimeout;
-    enet_uint32       packetLossEpoch;
-    enet_uint32       packetsSent;
-    enet_uint32       packetsLost;
-    enet_uint32       packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
-    enet_uint32       packetLossVariance;
-    enet_uint32       packetThrottle;
-    enet_uint32       packetThrottleLimit;
-    enet_uint32       packetThrottleCounter;
-    enet_uint32       packetThrottleEpoch;
-    enet_uint32       packetThrottleAcceleration;
-    enet_uint32       packetThrottleDeceleration;
-    enet_uint32       packetThrottleInterval;
-    enet_uint32       pingInterval;
-    enet_uint32       timeoutLimit;
-    enet_uint32       timeoutMinimum;
-    enet_uint32       timeoutMaximum;
-    enet_uint32       lastRoundTripTime;
-    enet_uint32       lowestRoundTripTime;
-    enet_uint32       lastRoundTripTimeVariance;
-    enet_uint32       highestRoundTripTimeVariance;
-    enet_uint32       roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
-    enet_uint32       roundTripTimeVariance;
-    enet_uint32       mtu;
-    enet_uint32       windowSize;
-    enet_uint32       reliableDataInTransit;
-    enet_uint16       outgoingReliableSequenceNumber;
-    ENetList          acknowledgements;
-    ENetList          sentReliableCommands;
-    ENetList          sentUnreliableCommands;
-    ENetList          outgoingReliableCommands;
-    ENetList          outgoingUnreliableCommands;
-    ENetList          dispatchedCommands;
-    int               needsDispatch;
-    enet_uint16       incomingUnsequencedGroup;
-    enet_uint16       outgoingUnsequencedGroup;
-    enet_uint32       unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
-    enet_uint32       eventData;
-    size_t            totalWaitingData;
-} ENetPeer;
-
-/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
- */
-typedef struct _ENetCompressor {
-    /** Context data for the compressor. Must be non-NULL. */
-    void *context;
-    /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-    size_t(ENET_CALLBACK * compress) (void *context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit,
-    enet_uint8 * outData, size_t outLimit);
-    /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-    size_t(ENET_CALLBACK * decompress) (void *context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData,
-    size_t outLimit);
-    /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
-    void (ENET_CALLBACK * destroy)(void *context);
-} ENetCompressor;
-
-/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
-typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback)(const ENetBuffer *buffers, size_t bufferCount);
-
-/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
-typedef int (ENET_CALLBACK * ENetInterceptCallback)(struct _ENetHost *host, struct _ENetEvent *event);
-
-/** An ENet host for communicating with peers.
- *
- * No fields should be modified unless otherwise stated.
- *
- *  @sa enet_host_create()
- *  @sa enet_host_destroy()
- *  @sa enet_host_connect()
- *  @sa enet_host_service()
- *  @sa enet_host_flush()
- *  @sa enet_host_broadcast()
- *  @sa enet_host_compress()
- *  @sa enet_host_compress_with_range_coder()
- *  @sa enet_host_channel_limit()
- *  @sa enet_host_bandwidth_limit()
- *  @sa enet_host_bandwidth_throttle()
- */
-typedef struct _ENetHost {
-    ENetSocket            socket;
-    ENetAddress           address;           /**< Internet address of the host */
-    enet_uint32           incomingBandwidth; /**< downstream bandwidth of the host */
-    enet_uint32           outgoingBandwidth; /**< upstream bandwidth of the host */
-    enet_uint32           bandwidthThrottleEpoch;
-    enet_uint32           mtu;
-    enet_uint32           randomSeed;
-    int                   recalculateBandwidthLimits;
-    ENetPeer *            peers;        /**< array of peers allocated for this host */
-    size_t                peerCount;    /**< number of peers allocated for this host */
-    size_t                channelLimit; /**< maximum number of channels allowed for connected peers */
-    enet_uint32           serviceTime;
-    ENetList              dispatchQueue;
-    int                   continueSending;
-    size_t                packetSize;
-    enet_uint16           headerFlags;
-    ENetProtocol          commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-    size_t                commandCount;
-    ENetBuffer            buffers [ENET_BUFFER_MAXIMUM];
-    size_t                bufferCount;
-    ENetChecksumCallback  checksum; /**< callback the user can set to enable packet checksums for this host */
-    ENetCompressor        compressor;
-    enet_uint8            packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
-    ENetAddress           receivedAddress;
-    enet_uint8 *          receivedData;
-    size_t                receivedDataLength;
-    enet_uint32           totalSentData;        /**< total data sent, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalSentPackets;     /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalReceivedData;    /**< total data received, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
-    ENetInterceptCallback intercept;            /**< callback the user can set to intercept received raw UDP packets */
-    size_t                connectedPeers;
-    size_t                bandwidthLimitedPeers;
-    size_t                duplicatePeers;     /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
-    size_t                maximumPacketSize;  /**< the maximum allowable packet size that may be sent or received on a peer */
-    size_t                maximumWaitingData; /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
-} ENetHost;
-
-/**
- * An ENet event type, as specified in @ref ENetEvent.
- */
-typedef enum _ENetEventType {
-    /** no event occurred within the specified time limit */
-    ENET_EVENT_TYPE_NONE       = 0,
-
-    /** a connection request initiated by enet_host_connect has completed.
-     * The peer field contains the peer which successfully connected.
-     */
-    ENET_EVENT_TYPE_CONNECT    = 1,
-
-    /** 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 intialized 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.
-     */
-    ENET_EVENT_TYPE_DISCONNECT = 2,
-
-    /** 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.
-     */
-    ENET_EVENT_TYPE_RECEIVE    = 3
-} ENetEventType;
-
-/**
- * An ENet event as returned by enet_host_service().
- *
- * @sa enet_host_service
- */
-typedef struct _ENetEvent {
-    ENetEventType type;      /**< type of the event */
-    ENetPeer *    peer;      /**< peer that generated a connect, disconnect or receive event */
-    enet_uint8    channelID; /**< channel on the peer that generated the event, if appropriate */
-    enet_uint32   data;      /**< data associated with the event, if appropriate */
-    ENetPacket *  packet;    /**< packet associated with the event, if appropriate */
-} ENetEvent;
-
-/** @defgroup global ENet global functions
- *  @{
- */
-
-/**
- * Initializes ENet globally.  Must be called prior to using any functions in
- * ENet.
- * @returns 0 on success, < 0 on failure
- */
-ENET_API int
-enet_initialize(void);
-
-/**
- * Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
- *
- * @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
- * @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
- * @returns 0 on success, < 0 on failure
- */
-ENET_API int
-enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits);
-
-/**
- * Shuts down ENet globally.  Should be called when a program that has
- * initialized ENet exits.
- */
-ENET_API void
-enet_deinitialize(void);
-
-/**
- * Gives the linked version of the ENet library.
- * @returns the version number
- */
-ENET_API ENetVersion
-enet_linked_version(void);
-
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
-/**
- * Returns the wall-time in milliseconds.  Its initial value is unspecified
- * unless otherwise set.
- */
-ENET_API enet_uint64
-enet_time_get(void);
-
-/**
- * Sets the current wall-time in milliseconds.
- */
-ENET_API void enet_time_set(enet_uint64);
-
-/** @defgroup socket ENet socket functions
- *  @{
- */
-ENET_API ENetSocket enet_socket_create(ENetSocketType);
-ENET_API int enet_socket_bind(ENetSocket, const ENetAddress *);
-ENET_API int enet_socket_get_address(ENetSocket, ENetAddress *);
-ENET_API int enet_socket_listen(ENetSocket, int);
-ENET_API ENetSocket enet_socket_accept(ENetSocket, ENetAddress *);
-ENET_API int enet_socket_connect(ENetSocket, const ENetAddress *);
-ENET_API int enet_socket_send(ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-ENET_API int enet_socket_receive(ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-ENET_API int enet_socket_wait(ENetSocket, enet_uint32 *, enet_uint64);
-ENET_API int enet_socket_set_option(ENetSocket, ENetSocketOption, int);
-ENET_API int enet_socket_get_option(ENetSocket, ENetSocketOption, int *);
-ENET_API int enet_socket_shutdown(ENetSocket, ENetSocketShutdown);
-ENET_API void enet_socket_destroy(ENetSocket);
-ENET_API int enet_socketset_select(ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-/** @} */
-
-/** @defgroup Address ENet address functions
- *  @{
- */
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
- *  and sets the host field in the address parameter if successful.
- *  @param address destination to store the parsed IP address
- *  @param hostName IP address to parse
- *  @retval 0 on success
- *  @retval < 0 on failure
- *  @returns the address of the given hostName in address on success
- */
-ENET_API int
-enet_address_set_host_ip(ENetAddress *address, const char *hostName);
-
-/** Attempts to resolve the host named by the parameter hostName and sets
- *  the host field in the address parameter if successful.
- *  @param address destination to store resolved address
- *  @param hostName host name to lookup
- *  @retval 0 on success
- *  @retval < 0 on failure
- *  @returns the address of the given hostName in address on success
- */
-ENET_API int
-enet_address_set_host(ENetAddress *address, const char *hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
- *  @param address    address printed
- *  @param hostName   destination for name, must not be NULL
- *  @param nameLength maximum length of hostName.
- *  @returns the null-terminated name of the host in hostName on success
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-ENET_API int
-enet_address_get_host_ip(const ENetAddress *address, char *hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
- *  @param address    address used for reverse lookup
- *  @param hostName   destination for name, must not be NULL
- *  @param nameLength maximum length of hostName.
- *  @returns the null-terminated name of the host in hostName on success
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-ENET_API int
-enet_address_get_host(const ENetAddress *address, char *hostName, size_t nameLength);
-
-/** @} */
-
-ENET_API ENetPacket *enet_packet_create(const void *, size_t, enet_uint32);
-ENET_API ENetPacket *enet_packet_create_offset(const void *, size_t, size_t, enet_uint32);
-ENET_API void
-enet_packet_destroy(ENetPacket *);
-ENET_API int enet_packet_resize(ENetPacket *, size_t);
-ENET_API enet_uint32 enet_crc32(const ENetBuffer *, size_t);
-
-ENET_API ENetHost *enet_host_create(const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-ENET_API void
-enet_host_destroy(ENetHost *);
-ENET_API ENetPeer *enet_host_connect(ENetHost *, const ENetAddress *, size_t, enet_uint32);
-ENET_API int
-enet_host_check_events(ENetHost *, ENetEvent *);
-ENET_API int enet_host_service(ENetHost *, ENetEvent *, enet_uint32);
-ENET_API void
-enet_host_flush(ENetHost *);
-ENET_API void enet_host_broadcast(ENetHost *, enet_uint8, ENetPacket *);
-ENET_API void
-enet_host_compress(ENetHost *, const ENetCompressor *);
-ENET_API int
-enet_host_compress_with_range_coder(ENetHost *host);
-ENET_API void enet_host_channel_limit(ENetHost *, size_t);
-ENET_API void enet_host_bandwidth_limit(ENetHost *, enet_uint32, enet_uint32);
-extern void
-enet_host_bandwidth_throttle(ENetHost *);
-extern enet_uint64
-enet_host_random_seed(void);
-
-ENET_API int enet_peer_send(ENetPeer *, enet_uint8, ENetPacket *);
-ENET_API ENetPacket *
-enet_peer_receive(ENetPeer *, enet_uint8 *channelID);
-ENET_API void
-enet_peer_ping(ENetPeer *);
-ENET_API void enet_peer_ping_interval(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_timeout(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-ENET_API void
-enet_peer_reset(ENetPeer *);
-ENET_API void enet_peer_disconnect(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_disconnect_now(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_disconnect_later(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_throttle_configure(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-extern int enet_peer_throttle(ENetPeer *, enet_uint32);
-extern void
-enet_peer_reset_queues(ENetPeer *);
-extern void
-enet_peer_setup_outgoing_command(ENetPeer *, ENetOutgoingCommand *);
-extern ENetOutgoingCommand *enet_peer_queue_outgoing_command(ENetPeer *, const ENetProtocol *, ENetPacket *,
-  enet_uint32, enet_uint16);
-extern ENetIncomingCommand *enet_peer_queue_incoming_command(ENetPeer *, const ENetProtocol *, const void *, size_t,
-  enet_uint32, enet_uint32);
-extern ENetAcknowledgement *enet_peer_queue_acknowledgement(ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void
-enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *, ENetChannel *);
-extern void
-enet_peer_dispatch_incoming_reliable_commands(ENetPeer *, ENetChannel *);
-extern void
-enet_peer_on_connect(ENetPeer *);
-extern void
-enet_peer_on_disconnect(ENetPeer *);
-
-ENET_API void *
-enet_range_coder_create(void);
-ENET_API void
-enet_range_coder_destroy(void *);
-ENET_API size_t enet_range_coder_compress(void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
-ENET_API size_t enet_range_coder_decompress(void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
-
-extern size_t enet_protocol_command_size(enet_uint8);
-
-# ifdef __cplusplus
-}
-# endif
-
-
-# if defined(ENET_IMPLEMENTATION) && !defined(ENET_IMPLEMENTATION_DONE)
-#  define ENET_IMPLEMENTATION_DONE
-
-#  ifdef __cplusplus
-extern "C"
-{
-#  endif
-
-// @from_file: src/callbacks.c
-
-/**
- * @file callbacks.c
- * @brief ENet callback functions
- */
-#  define ENET_BUILDING_LIB 1
-
-
-static ENetCallbacks callbacks = { malloc, free, abort };
-
-int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits) {
-    if (version < ENET_VERSION_CREATE(1, 3, 0)) {
-        return -1;
-    }
-
-    if (inits->malloc != NULL || inits->free != NULL) {
-        if (inits->malloc == NULL || inits->free == NULL) {
-            return -1;
-        }
-
-        callbacks.malloc = inits->malloc;
-        callbacks.free   = inits->free;
-    }
-
-    if (inits->no_memory != NULL) {
-        callbacks.no_memory = inits->no_memory;
-    }
-
-    return enet_initialize();
-}
-
-ENetVersion enet_linked_version(void) {
-    return ENET_VERSION;
-}
-
-void * enet_malloc(size_t size) {
-    void *memory = callbacks.malloc(size);
-
-    if (memory == NULL) {
-        callbacks.no_memory();
-    }
-
-    return memory;
-}
-
-void enet_free(void *memory) {
-    callbacks.free(memory);
-}
-
-// @from_file: src/compress.c
-
-/**
- * @file compress.c
- * @brief An adaptive order-2 PPM range coder
- */
-#  define ENET_BUILDING_LIB 1
-#  include <string.h>
-
-
-typedef struct _ENetSymbol {
-    /* binary indexed tree of symbols */
-    enet_uint8  value;
-    enet_uint8  count;
-    enet_uint16 under;
-    enet_uint16 left, right;
-
-    /* context defined by this symbol */
-    enet_uint16 symbols;
-    enet_uint16 escapes;
-    enet_uint16 total;
-    enet_uint16 parent;
-} ENetSymbol;
-
-/* adaptation constants tuned aggressively for small packet sizes rather than large file compression */
-enum {
-    ENET_RANGE_CODER_TOP         = 1 << 24,
-    ENET_RANGE_CODER_BOTTOM      = 1 << 16,
-
-    ENET_CONTEXT_SYMBOL_DELTA    = 3,
-    ENET_CONTEXT_SYMBOL_MINIMUM  = 1,
-    ENET_CONTEXT_ESCAPE_MINIMUM  = 1,
-
-    ENET_SUBCONTEXT_ORDER        = 2,
-    ENET_SUBCONTEXT_SYMBOL_DELTA = 2,
-    ENET_SUBCONTEXT_ESCAPE_DELTA = 5
-};
-
-/* context exclusion roughly halves compression speed, so disable for now */
-#  undef ENET_CONTEXT_EXCLUSION
-
-typedef struct _ENetRangeCoder {
-    /* only allocate enough symbols for reasonable MTUs, would need to be larger for large file compression */
-    ENetSymbol symbols[4096];
-} ENetRangeCoder;
-
-void * enet_range_coder_create(void) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) enet_malloc(sizeof(ENetRangeCoder));
-
-    if (rangeCoder == NULL) {
-        return NULL;
-    }
-
-    return rangeCoder;
-}
-
-void enet_range_coder_destroy(void *context) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-
-    if (rangeCoder == NULL) {
-        return;
-    }
-
-    enet_free(rangeCoder);
-}
-
-#  define ENET_SYMBOL_CREATE(symbol, value_, count_) \
-    { \
-        symbol          = &rangeCoder->symbols [nextSymbol++]; \
-        symbol->value   = value_; \
-        symbol->count   = count_; \
-        symbol->under   = count_; \
-        symbol->left    = 0; \
-        symbol->right   = 0; \
-        symbol->symbols = 0; \
-        symbol->escapes = 0; \
-        symbol->total   = 0; \
-        symbol->parent  = 0; \
-    }
-
-#  define ENET_CONTEXT_CREATE(context, escapes_, minimum) \
-    { \
-        ENET_SYMBOL_CREATE(context, 0, 0); \
-        (context)->escapes = escapes_; \
-        (context)->total   = escapes_ + 256 * minimum; \
-        (context)->symbols = 0; \
-    }
-
-static enet_uint16 enet_symbol_rescale(ENetSymbol *symbol) {
-    enet_uint16 total = 0;
-
-    for (;;) {
-        symbol->count -= symbol->count >> 1;
-        symbol->under  = symbol->count;
-        if (symbol->left) {
-            symbol->under += enet_symbol_rescale(symbol + symbol->left);
-        }
-        total += symbol->under;
-        if (!symbol->right) { break; }
-        symbol += symbol->right;
-    }
-    return total;
-}
-
-#  define ENET_CONTEXT_RESCALE(context, minimum) \
-    { \
-        (context)->total    = (context)->symbols ? enet_symbol_rescale((context) + (context)->symbols) : 0; \
-        (context)->escapes -= (context)->escapes >> 1; \
-        (context)->total   += (context)->escapes + 256 * minimum; \
-    }
-
-#  define ENET_RANGE_CODER_OUTPUT(value) \
-    { \
-        if (outData >= outEnd) { \
-            return 0; } \
-        *outData++ = value; \
-    }
-
-#  define ENET_RANGE_CODER_ENCODE(under, count, total) \
-    { \
-        encodeRange /= (total); \
-        encodeLow   += (under) * encodeRange; \
-        encodeRange *= (count); \
-        for (;;) \
-        { \
-            if ((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
-            { \
-                if (encodeRange >= ENET_RANGE_CODER_BOTTOM) { break; } \
-                encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-            } \
-            ENET_RANGE_CODER_OUTPUT(encodeLow >> 24); \
-            encodeRange <<= 8; \
-            encodeLow   <<= 8; \
-        } \
-    }
-
-#  define ENET_RANGE_CODER_FLUSH \
-    { \
-        while (encodeLow) \
-        { \
-            ENET_RANGE_CODER_OUTPUT(encodeLow >> 24); \
-            encodeLow <<= 8; \
-        } \
-    }
-
-#  define ENET_RANGE_CODER_FREE_SYMBOLS \
-    { \
-        if (nextSymbol >= sizeof(rangeCoder->symbols) / sizeof(ENetSymbol) - ENET_SUBCONTEXT_ORDER) \
-        { \
-            nextSymbol = 0; \
-            ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
-            predicted = 0; \
-            order     = 0; \
-        } \
-    }
-
-#  define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update, minimum) \
-    { \
-        under_ = value * minimum; \
-        count_ = minimum; \
-        if (!(context)->symbols) \
-        { \
-            ENET_SYMBOL_CREATE(symbol_, value_, update); \
-            (context)->symbols = symbol_ - (context); \
-        } \
-        else \
-        { \
-            ENetSymbol *node = (context) + (context)->symbols; \
-            for (;;) \
-            { \
-                if (value_ < node->value) \
-                { \
-                    node->under += update; \
-                    if (node->left) { node += node->left; continue; } \
-                    ENET_SYMBOL_CREATE(symbol_, value_, update); \
-                    node->left = symbol_ - node; \
-                } \
-                else if (value_ > node->value) \
-                { \
-                    under_ += node->under; \
-                    if (node->right) { node += node->right; continue; } \
-                    ENET_SYMBOL_CREATE(symbol_, value_, update); \
-                    node->right = symbol_ - node; \
-                } \
-                else \
-                { \
-                    count_      += node->count; \
-                    under_      += node->under - node->count; \
-                    node->under += update; \
-                    node->count += update; \
-                    symbol_      = node; \
-                } \
-                break; \
-            } \
-        } \
-    }
-
-#  ifdef ENET_CONTEXT_EXCLUSION
-static const ENetSymbol emptyContext = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-#   define ENET_CONTEXT_WALK(context, body) \
-    { \
-        const ENetSymbol *node = (context) + (context)->symbols; \
-        const ENetSymbol *stack [256]; \
-        size_t stackSize = 0; \
-        while (node->left) \
-        { \
-            stack [stackSize++] = node; \
-            node += node->left; \
-        } \
-        for (;;) \
-        { \
-            body; \
-            if (node->right) \
-            { \
-                node += node->right; \
-                while (node->left) \
-                { \
-                    stack [stackSize++] = node; \
-                    node += node->left; \
-                } \
-            } \
-            else if (stackSize <= 0) { \
-                break; } \
-            else { \
-                node = stack [--stackSize]; } \
-        } \
-    }
-
-#   define ENET_CONTEXT_ENCODE_EXCLUDE(context, value_, under, total, minimum) \
-    ENET_CONTEXT_WALK(context, { \
-        if (node->value != value_) \
-        { \
-            enet_uint16 parentCount = rangeCoder->symbols [node->parent].count + minimum; \
-            if (node->value < value_) { \
-                under -= parentCount; } \
-            total -= parentCount; \
-        } \
-    })
-#  endif // ifdef ENET_CONTEXT_EXCLUSION
-
-size_t enet_range_coder_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit,
-  enet_uint8 *outData, size_t outLimit) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 *outStart = outData, *outEnd = &outData [outLimit];
-    const enet_uint8 *inData, *inEnd;
-    enet_uint32 encodeLow = 0, encodeRange = ~0;
-    ENetSymbol *root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0) {
-        return 0;
-    }
-
-    inData = (const enet_uint8 *) inBuffers->data;
-    inEnd  = &inData [inBuffers->dataLength];
-    inBuffers++;
-    inBufferCount--;
-
-    ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    for (;;) {
-        ENetSymbol *subcontext, *symbol;
-        #  ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol *childContext = &emptyContext;
-        #  endif
-        enet_uint8 value;
-        enet_uint16 count, under, *parent = &predicted, total;
-        if (inData >= inEnd) {
-            if (inBufferCount <= 0) {
-                break;
-            }
-            inData = (const enet_uint8 *) inBuffers->data;
-            inEnd  = &inData [inBuffers->dataLength];
-            inBuffers++;
-            inBufferCount--;
-        }
-        value = *inData++;
-
-        for (subcontext = &rangeCoder->symbols [predicted];
-          subcontext != root;
-          #  ifdef ENET_CONTEXT_EXCLUSION
-          childContext = subcontext,
-          #  endif
-          subcontext = &rangeCoder->symbols [subcontext->parent])
-        {
-            ENET_CONTEXT_ENCODE(subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            *parent = symbol - rangeCoder->symbols;
-            parent  = &symbol->parent;
-            total   = subcontext->total;
-            #  ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) {
-                ENET_CONTEXT_ENCODE_EXCLUDE(childContext, value, under, total, 0);
-            }
-            #  endif
-            if (count > 0) {
-                ENET_RANGE_CODER_ENCODE(subcontext->escapes + under, count, total);
-            } else {
-                if (subcontext->escapes > 0 && subcontext->escapes < total) {
-                    ENET_RANGE_CODER_ENCODE(0, subcontext->escapes, total);
-                }
-                subcontext->escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                subcontext->total   += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            subcontext->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA ||
-              subcontext->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-            {
-                ENET_CONTEXT_RESCALE(subcontext, 0);
-            }
-            if (count > 0) { goto nextInput; }
-        }
-
-        ENET_CONTEXT_ENCODE(root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
-        *parent = symbol - rangeCoder->symbols;
-        parent  = &symbol->parent;
-        total   = root->total;
-        #  ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) {
-            ENET_CONTEXT_ENCODE_EXCLUDE(childContext, value, under, total, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-        #  endif
-        ENET_RANGE_CODER_ENCODE(root->escapes + under, count, total);
-        root->total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2 * ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM ||
-          root->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-        {
-            ENET_CONTEXT_RESCALE(root, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-
-nextInput:
-        if (order >= ENET_SUBCONTEXT_ORDER) {
-            predicted = rangeCoder->symbols [predicted].parent;
-        } else {
-            order++;
-        }
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    ENET_RANGE_CODER_FLUSH;
-
-    return (size_t) (outData - outStart);
-} // enet_range_coder_compress
-
-#  define ENET_RANGE_CODER_SEED \
-    { \
-        if (inData < inEnd) { decodeCode |= *inData++ << 24; } \
-        if (inData < inEnd) { decodeCode |= *inData++ << 16; } \
-        if (inData < inEnd) { decodeCode |= *inData++ << 8; } \
-        if (inData < inEnd) { decodeCode |= *inData++; } \
-    }
-
-#  define ENET_RANGE_CODER_READ(total) ((decodeCode - decodeLow) / (decodeRange /= (total)))
-
-#  define ENET_RANGE_CODER_DECODE(under, count, total) \
-    { \
-        decodeLow   += (under) * decodeRange; \
-        decodeRange *= (count); \
-        for (;;) \
-        { \
-            if ((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \
-            { \
-                if (decodeRange >= ENET_RANGE_CODER_BOTTOM) { break; } \
-                decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-            } \
-            decodeCode <<= 8; \
-            if (inData < inEnd) { \
-                decodeCode |= *inData++; } \
-            decodeRange <<= 8; \
-            decodeLow   <<= 8; \
-        } \
-    }
-
-#  define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, createRoot, visitNode, \
-      createRight, createLeft) \
-    { \
-        under_ = 0; \
-        count_ = minimum; \
-        if (!(context)->symbols) \
-        { \
-            createRoot; \
-        } \
-        else \
-        { \
-            ENetSymbol *node = (context) + (context)->symbols; \
-            for (;;) \
-            { \
-                enet_uint16 after = under_ + node->under + (node->value + 1) * minimum, before = node->count + minimum; \
-                visitNode; \
-                if (code >= after) \
-                { \
-                    under_ += node->under; \
-                    if (node->right) { node += node->right; continue; } \
-                    createRight; \
-                } \
-                else if (code < after - before) \
-                { \
-                    node->under += update; \
-                    if (node->left) { node += node->left; continue; } \
-                    createLeft; \
-                } \
-                else \
-                { \
-                    value_       = node->value; \
-                    count_      += node->count; \
-                    under_       = after - before; \
-                    node->under += update; \
-                    node->count += update; \
-                    symbol_      = node; \
-                } \
-                break; \
-            } \
-        } \
-    }
-
-#  define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-    ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, return 0, \
-      exclude(node->value, after, before), return 0, return 0)
-
-#  define ENET_CONTEXT_ROOT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-    ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, \
-    { \
-        value_ = code / minimum; \
-        under_ = code - code % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        (context)->symbols = symbol_ - (context); \
-    }, \
-      exclude(node->value, after, before), \
-    { \
-        value_ = node->value + 1 + (code - after) / minimum; \
-        under_ = code - (code - after) % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        node->right = symbol_ - node; \
-    }, \
-    { \
-        value_ = node->value - 1 - (after - before - code - 1) / minimum; \
-        under_ = code - (after - before - code - 1) % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        node->left = symbol_ - node; \
-    }) \
-
-#  ifdef ENET_CONTEXT_EXCLUSION
-typedef struct _ENetExclude {
-    enet_uint8  value;
-    enet_uint16 under;
-} ENetExclude;
-
-#   define ENET_CONTEXT_DECODE_EXCLUDE(context, total, minimum) \
-    { \
-        enet_uint16 under = 0; \
-        nextExclude = excludes; \
-        ENET_CONTEXT_WALK(context, { \
-            under += rangeCoder->symbols [node->parent].count + minimum; \
-            nextExclude->value = node->value; \
-            nextExclude->under = under; \
-            nextExclude++; \
-        }); \
-        total -= under; \
-    }
-
-#   define ENET_CONTEXT_EXCLUDED(value_, after, before) \
-    { \
-        size_t low = 0, high = nextExclude - excludes; \
-        for (;;) \
-        { \
-            size_t mid = (low + high) >> 1; \
-            const ENetExclude *exclude = &excludes [mid]; \
-            if (value_ < exclude->value) \
-            { \
-                if (low + 1 < high) \
-                { \
-                    high = mid; \
-                    continue; \
-                } \
-                if (exclude > excludes) { \
-                    after -= exclude [-1].under; } \
-            } \
-            else \
-            { \
-                if (value_ > exclude->value) \
-                { \
-                    if (low + 1 < high) \
-                    { \
-                        low = mid; \
-                        continue; \
-                    } \
-                } \
-                else { \
-                    before = 0; } \
-                after -= exclude->under; \
-            } \
-            break; \
-        } \
-    }
-#  endif // ifdef ENET_CONTEXT_EXCLUSION
-
-#  define ENET_CONTEXT_NOT_EXCLUDED(value_, after, before)
-
-size_t enet_range_coder_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData,
-  size_t outLimit) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 *outStart = outData, *outEnd = &outData [outLimit];
-    const enet_uint8 *inEnd = &inData [inLimit];
-    enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0;
-    ENetSymbol *root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    #  ifdef ENET_CONTEXT_EXCLUSION
-    ENetExclude excludes [256];
-    ENetExclude *nextExclude = excludes;
-    #  endif
-
-    if (rangeCoder == NULL || inLimit <= 0) {
-        return 0;
-    }
-
-    ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    ENET_RANGE_CODER_SEED;
-
-    for (;;) {
-        ENetSymbol *subcontext, *symbol, *patch;
-        #  ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol *childContext = &emptyContext;
-        #  endif
-        enet_uint8 value = 0;
-        enet_uint16 code, under, count, bottom, *parent = &predicted, total;
-
-        for (subcontext = &rangeCoder->symbols [predicted];
-          subcontext != root;
-          #  ifdef ENET_CONTEXT_EXCLUSION
-          childContext = subcontext,
-          #  endif
-          subcontext = &rangeCoder->symbols [subcontext->parent])
-        {
-            if (subcontext->escapes <= 0) {
-                continue;
-            }
-            total = subcontext->total;
-            #  ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > 0) {
-                ENET_CONTEXT_DECODE_EXCLUDE(childContext, total, 0);
-            }
-            #  endif
-            if (subcontext->escapes >= total) {
-                continue;
-            }
-            code = ENET_RANGE_CODER_READ(total);
-            if (code < subcontext->escapes) {
-                ENET_RANGE_CODER_DECODE(0, subcontext->escapes, total);
-                continue;
-            }
-            code -= subcontext->escapes;
-            #  ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > 0) {
-                ENET_CONTEXT_TRY_DECODE(subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0,
-                  ENET_CONTEXT_EXCLUDED);
-            } else
-            #  endif
-            {
-                ENET_CONTEXT_TRY_DECODE(subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0,
-                  ENET_CONTEXT_NOT_EXCLUDED);
-            }
-            bottom = symbol - rangeCoder->symbols;
-            ENET_RANGE_CODER_DECODE(subcontext->escapes + under, count, total);
-            subcontext->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA ||
-              subcontext->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-            {
-                ENET_CONTEXT_RESCALE(subcontext, 0);
-            }
-            goto patchContexts;
-        }
-
-        total = root->total;
-        #  ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > 0) {
-            ENET_CONTEXT_DECODE_EXCLUDE(childContext, total, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-        #  endif
-        code = ENET_RANGE_CODER_READ(total);
-        if (code < root->escapes) {
-            ENET_RANGE_CODER_DECODE(0, root->escapes, total);
-            break;
-        }
-        code -= root->escapes;
-        #  ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > 0) {
-            ENET_CONTEXT_ROOT_DECODE(root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA,
-              ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_EXCLUDED);
-        } else
-        #  endif
-        {
-            ENET_CONTEXT_ROOT_DECODE(root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA,
-              ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_NOT_EXCLUDED);
-        }
-        bottom = symbol - rangeCoder->symbols;
-        ENET_RANGE_CODER_DECODE(root->escapes + under, count, total);
-        root->total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2 * ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM ||
-          root->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-        {
-            ENET_CONTEXT_RESCALE(root, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-
-patchContexts:
-        for (patch = &rangeCoder->symbols [predicted];
-          patch != subcontext;
-          patch = &rangeCoder->symbols [patch->parent])
-        {
-            ENET_CONTEXT_ENCODE(patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            *parent = symbol - rangeCoder->symbols;
-            parent  = &symbol->parent;
-            if (count <= 0) {
-                patch->escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                patch->total   += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            patch->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA || patch->total > ENET_RANGE_CODER_BOTTOM - 0x100) {
-                ENET_CONTEXT_RESCALE(patch, 0);
-            }
-        }
-        *parent = bottom;
-
-        ENET_RANGE_CODER_OUTPUT(value);
-
-        if (order >= ENET_SUBCONTEXT_ORDER) {
-            predicted = rangeCoder->symbols [predicted].parent;
-        } else {
-            order++;
-        }
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    return (size_t) (outData - outStart);
-} // enet_range_coder_decompress
-
-/** @defgroup host ENet host functions
- *  @{
- */
-
-/** Sets the packet compressor the host should use to the default range coder.
- *  @param host host to enable the range coder for
- *  @returns 0 on success, < 0 on failure
- */
-int enet_host_compress_with_range_coder(ENetHost *host) {
-    ENetCompressor compressor;
-
-    memset(&compressor, 0, sizeof(compressor));
-    compressor.context = enet_range_coder_create();
-    if (compressor.context == NULL) {
-        return -1;
-    }
-    compressor.compress   = enet_range_coder_compress;
-    compressor.decompress = enet_range_coder_decompress;
-    compressor.destroy    = enet_range_coder_destroy;
-    enet_host_compress(host, &compressor);
-    return 0;
-}
-
-/** @} */
-
-// @from_file: src/host.c
-
-/**
- * @file host.c
- * @brief ENet host management functions
- */
-#  define ENET_BUILDING_LIB 1
-
-
-/** @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 && enet_socket_get_address(host->socket, &host->address) < 0) {
-        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) (size_t) host;
-    host->randomSeed                += enet_host_random_seed();
-    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->connectedPeers        = 0;
-    host->bandwidthLimitedPeers = 0;
-    host->duplicatePeers        = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    host->maximumPacketSize     = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
-    host->maximumWaitingData    = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
-
-    host->compressor.context    = NULL;
-    host->compressor.compress   = NULL;
-    host->compressor.decompress = NULL;
-    host->compressor.destroy    = NULL;
-
-    host->intercept = 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;
-} // enet_host_create
-
-/** 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;
-
-    if (host == NULL) {
-        return;
-    }
-
-    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;
-} // enet_host_connect
-
-/** 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,
-      peersRemaining    = (enet_uint32) host->connectedPeers,
-      dataTotal         = ~0,
-      bandwidth         = ~0,
-      throttle          = 0,
-      bandwidthLimit    = 0;
-    int needsAdjustment = host->bandwidthLimitedPeers > 0 ? 1 : 0;
-    ENetPeer *peer;
-    ENetProtocol command;
-
-    if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
-        return;
-    }
-
-    host->bandwidthThrottleEpoch = timeCurrent;
-
-    if (peersRemaining == 0) {
-        return;
-    }
-
-    if (host->outgoingBandwidth != 0) {
-        dataTotal = 0;
-        bandwidth = (host->outgoingBandwidth * elapsedTime) / 1000;
-
-        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;
-            }
-
-            dataTotal += peer->outgoingDataTotal;
-        }
-    }
-
-    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;
-
-            peer->incomingDataTotal = 0;
-            peer->outgoingDataTotal = 0;
-
-            needsAdjustment = 1;
-            --peersRemaining;
-            bandwidth -= peerBandwidth;
-            dataTotal -= peerBandwidth;
-        }
-    }
-
-    if (peersRemaining > 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)
-        {
-            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;
-            }
-
-            peer->incomingDataTotal = 0;
-            peer->outgoingDataTotal = 0;
-        }
-    }
-
-    if (host->recalculateBandwidthLimits) {
-        host->recalculateBandwidthLimits = 0;
-
-        peersRemaining  = (enet_uint32) host->connectedPeers;
-        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);
-        }
-    }
-} // enet_host_bandwidth_throttle
-
-/** @} */
-
-// @from_file: src/list.c
-
-/**
- * @file list.c
- * @brief ENet linked list functions
- */
-#  define ENET_BUILDING_LIB 1
-
-
-/**
- *  @defgroup list ENet linked list utility functions
- *  @ingroup private
- *  @{
- */
-void enet_list_clear(ENetList *list) {
-    list->sentinel.next     = &list->sentinel;
-    list->sentinel.previous = &list->sentinel;
-}
-
-ENetListIterator enet_list_insert(ENetListIterator position, void *data) {
-    ENetListIterator result = (ENetListIterator) data;
-
-    result->previous = position->previous;
-    result->next     = position;
-
-    result->previous->next = result;
-    position->previous     = result;
-
-    return result;
-}
-
-void * enet_list_remove(ENetListIterator position) {
-    position->previous->next = position->next;
-    position->next->previous = position->previous;
-
-    return position;
-}
-
-ENetListIterator enet_list_move(ENetListIterator position, void *dataFirst, void *dataLast) {
-    ENetListIterator first = (ENetListIterator) dataFirst,
-      last = (ENetListIterator) dataLast;
-
-    first->previous->next = last->next;
-    last->next->previous  = first->previous;
-
-    first->previous = position->previous;
-    last->next      = position;
-
-    first->previous->next = first;
-    position->previous    = last;
-
-    return first;
-}
-
-size_t enet_list_size(ENetList *list) {
-    size_t size = 0;
-    ENetListIterator position;
-
-    for (position = enet_list_begin(list);
-      position != enet_list_end(list);
-      position = enet_list_next(position))
-        ++size;
-
-    return size;
-}
-
-/** @} */
-
-// @from_file: src/packet.c
-
-/**
- * @file  packet.c
- * @brief ENet packet management functions
- */
-
-#  define ENET_BUILDING_LIB 1
-
-
-/** @defgroup Packet ENet packet functions
- *  @{
- */
-
-/** Creates a packet that may be sent to a peer.
- *  @param data         initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL.
- *  @param dataLength   size of the data allocated for this packet
- *  @param flags        flags for this packet as described for the ENetPacket structure.
- *  @returns the packet on success, NULL on failure
- */
-ENetPacket * enet_packet_create(const void *data, size_t dataLength, enet_uint32 flags) {
-    ENetPacket *packet = (ENetPacket *) enet_malloc(sizeof(ENetPacket));
-
-    if (packet == NULL) {
-        return NULL;
-    }
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-        packet->data = (enet_uint8 *) data;
-    } else if (dataLength <= 0) {
-        packet->data = NULL;
-    } else {
-        packet->data = (enet_uint8 *) enet_malloc(dataLength);
-        if (packet->data == NULL) {
-            enet_free(packet);
-            return NULL;
-        }
-
-        if (data != NULL) {
-            memcpy(packet->data, data, dataLength);
-        }
-    }
-
-    packet->referenceCount = 0;
-    packet->flags        = flags;
-    packet->dataLength   = dataLength;
-    packet->freeCallback = NULL;
-    packet->userData     = NULL;
-
-    return packet;
-}
-
-ENetPacket * enet_packet_create_offset(const void *data, size_t dataLength, size_t dataOffset, enet_uint32 flags) {
-    ENetPacket *packet = (ENetPacket *) enet_malloc(sizeof(ENetPacket));
-
-    if (packet == NULL) {
-        return NULL;
-    }
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-        packet->data = (enet_uint8 *) data;
-    } else if ((dataLength + dataOffset) <= 0) {
-        packet->data = NULL;
-    } else {
-        packet->data = (enet_uint8 *) enet_malloc(dataLength + dataOffset);
-        if (packet->data == NULL) {
-            enet_free(packet);
-            return NULL;
-        }
-
-        if (data != NULL) {
-            memcpy(packet->data + dataOffset, data, dataLength);
-        }
-    }
-
-    packet->referenceCount = 0;
-    packet->flags        = flags;
-    packet->dataLength   = dataLength + dataOffset;
-    packet->freeCallback = NULL;
-    packet->userData     = NULL;
-
-    return packet;
-}
-
-/** Destroys the packet and deallocates its data.
- *  @param packet packet to be destroyed
- */
-void enet_packet_destroy(ENetPacket *packet) {
-    if (packet == NULL) {
-        return;
-    }
-
-    if (packet->freeCallback != NULL) {
-        (*packet->freeCallback)(packet);
-    }
-    if (!(packet->flags & ENET_PACKET_FLAG_NO_ALLOCATE) &&
-      packet->data != NULL)
-    {
-        enet_free(packet->data);
-    }
-    enet_free(packet);
-}
-
-/** Attempts to resize the data in the packet to length specified in the
- *  dataLength parameter
- *  @param packet packet to resize
- *  @param dataLength new size for the packet data
- *  @returns 0 on success, < 0 on failure
- */
-int enet_packet_resize(ENetPacket *packet, size_t dataLength) {
-    enet_uint8 *newData;
-
-    if (dataLength <= packet->dataLength || (packet->flags & ENET_PACKET_FLAG_NO_ALLOCATE)) {
-        packet->dataLength = dataLength;
-
-        return 0;
-    }
-
-    newData = (enet_uint8 *) enet_malloc(dataLength);
-    if (newData == NULL) {
-        return -1;
-    }
-
-    memcpy(newData, packet->data, packet->dataLength);
-    enet_free(packet->data);
-
-    packet->data       = newData;
-    packet->dataLength = dataLength;
-
-    return 0;
-}
-
-static int initializedCRC32 = 0;
-static enet_uint32 crcTable [256];
-
-static enet_uint32 reflect_crc(int val, int bits) {
-    int result = 0, bit;
-
-    for (bit = 0; bit < bits; bit++) {
-        if (val & 1) { result |= 1 << (bits - 1 - bit); }
-        val >>= 1;
-    }
-
-    return result;
-}
-
-static void initialize_crc32(void) {
-    int byte;
-
-    for (byte = 0; byte < 256; ++byte) {
-        enet_uint32 crc = reflect_crc(byte, 8) << 24;
-        int offset;
-
-        for (offset = 0; offset < 8; ++offset) {
-            if (crc & 0x80000000) {
-                crc = (crc << 1) ^ 0x04c11db7;
-            } else {
-                crc <<= 1;
-            }
-        }
-
-        crcTable [byte] = reflect_crc(crc, 32);
-    }
-
-    initializedCRC32 = 1;
-}
-
-enet_uint32 enet_crc32(const ENetBuffer *buffers, size_t bufferCount) {
-    enet_uint32 crc = 0xFFFFFFFF;
-
-    if (!initializedCRC32) { initialize_crc32(); }
-
-    while (bufferCount-- > 0) {
-        const enet_uint8 *data = (const enet_uint8 *) buffers->data,
-          *dataEnd = &data [buffers->dataLength];
-
-        while (data < dataEnd) {
-            crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++];
-        }
-
-        ++buffers;
-    }
-
-    return ENET_HOST_TO_NET_32(~crc);
-}
-
-/** @} */
-
-// @from_file: src/peer.c
-
-/**
- * @file  peer.c
- * @brief ENet peer management functions
- */
-
-#  define ENET_BUILDING_LIB 1
-
-
-/** @defgroup peer ENet peer functions
- *  @{
- */
-
-/** Configures throttle parameter for a peer.
- *
- *  Unreliable packets are dropped by ENet in response to the varying conditions
- *  of the Internet connection to the peer.  The throttle represents a probability
- *  that an unreliable packet should not be dropped and thus sent by ENet to the peer.
- *  The lowest mean round trip time from the sending of a reliable packet to the
- *  receipt of its acknowledgement is measured over an amount of time specified by
- *  the interval parameter in milliseconds.  If a measured round trip time happens to
- *  be significantly less than the mean round trip time measured over the interval,
- *  then the throttle probability is increased to allow more traffic by an amount
- *  specified in the acceleration parameter, which is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
- *  constant.  If a measured round trip time happens to be significantly greater than
- *  the mean round trip time measured over the interval, then the throttle probability
- *  is decreased to limit traffic by an amount specified in the deceleration parameter, which
- *  is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE constant.  When the throttle has
- *  a value of ENET_PEER_PACKET_THROTTLE_SCALE, no unreliable packets are dropped by
- *  ENet, and so 100% of all unreliable packets will be sent.  When the throttle has a
- *  value of 0, all unreliable packets are dropped by ENet, and so 0% of all unreliable
- *  packets will be sent.  Intermediate values for the throttle represent intermediate
- *  probabilities between 0% and 100% of unreliable packets being sent.  The bandwidth
- *  limits of the local and foreign hosts are taken into account to determine a
- *  sensible limit for the throttle probability above which it should not raise even in
- *  the best of conditions.
- *
- *  @param peer peer to configure
- *  @param interval interval, in milliseconds, over which to measure lowest mean RTT; the default value is ENET_PEER_PACKET_THROTTLE_INTERVAL.
- *  @param acceleration rate at which to increase the throttle probability as mean RTT declines
- *  @param deceleration rate at which to decrease the throttle probability as mean RTT increases
- */
-void enet_peer_throttle_configure(ENetPeer *peer, enet_uint32 interval, enet_uint32 acceleration,
-  enet_uint32 deceleration) {
-    ENetProtocol command;
-
-    peer->packetThrottleInterval     = interval;
-    peer->packetThrottleAcceleration = acceleration;
-    peer->packetThrottleDeceleration = deceleration;
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-
-    command.throttleConfigure.packetThrottleInterval     = ENET_HOST_TO_NET_32(interval);
-    command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32(acceleration);
-    command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32(deceleration);
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-}
-
-int enet_peer_throttle(ENetPeer *peer, enet_uint32 rtt) {
-    if (peer->lastRoundTripTime <= peer->lastRoundTripTimeVariance) {
-        peer->packetThrottle = peer->packetThrottleLimit;
-    } else if (rtt < peer->lastRoundTripTime) {
-        peer->packetThrottle += peer->packetThrottleAcceleration;
-
-        if (peer->packetThrottle > peer->packetThrottleLimit) {
-            peer->packetThrottle = peer->packetThrottleLimit;
-        }
-
-        return 1;
-    } else if (rtt > peer->lastRoundTripTime + 2 * peer->lastRoundTripTimeVariance) {
-        if (peer->packetThrottle > peer->packetThrottleDeceleration) {
-            peer->packetThrottle -= peer->packetThrottleDeceleration;
-        } else {
-            peer->packetThrottle = 0;
-        }
-
-        return -1;
-    }
-
-    return 0;
-}
-
-/** Queues a packet to be sent.
- *  @param peer destination for the packet
- *  @param channelID channel on which to send
- *  @param packet packet to send
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-int enet_peer_send(ENetPeer *peer, enet_uint8 channelID, ENetPacket *packet) {
-    ENetChannel *channel = &peer->channels [channelID];
-    ENetProtocol command;
-    size_t fragmentLength;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTED ||
-      channelID >= peer->channelCount ||
-      packet->dataLength > peer->host->maximumPacketSize)
-    {
-        return -1;
-    }
-
-    fragmentLength = peer->mtu - sizeof(ENetProtocolHeader) - sizeof(ENetProtocolSendFragment);
-    if (peer->host->checksum != NULL) {
-        fragmentLength -= sizeof(enet_uint32);
-    }
-
-    if (packet->dataLength > fragmentLength) {
-        enet_uint32 fragmentCount = (packet->dataLength + fragmentLength - 1) / fragmentLength,
-          fragmentNumber,
-          fragmentOffset;
-        enet_uint8 commandNumber;
-        enet_uint16 startSequenceNumber;
-        ENetList fragments;
-        ENetOutgoingCommand *fragment;
-
-        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-            return -1;
-        }
-
-        if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT)) ==
-          ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT &&
-          channel->outgoingUnreliableSequenceNumber < 0xFFFF)
-        {
-            commandNumber       = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT;
-            startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingUnreliableSequenceNumber + 1);
-        } else {
-            commandNumber       = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-            startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingReliableSequenceNumber + 1);
-        }
-
-        enet_list_clear(&fragments);
-
-        for (fragmentNumber = 0,
-          fragmentOffset = 0;
-          fragmentOffset < packet->dataLength;
-          ++fragmentNumber,
-          fragmentOffset += fragmentLength)
-        {
-            if (packet->dataLength - fragmentOffset < fragmentLength) {
-                fragmentLength = packet->dataLength - fragmentOffset;
-            }
-
-            fragment = (ENetOutgoingCommand *) enet_malloc(sizeof(ENetOutgoingCommand));
-            if (fragment == NULL) {
-                while (!enet_list_empty(&fragments)) {
-                    fragment = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(&fragments));
-
-                    enet_free(fragment);
-                }
-
-                return -1;
-            }
-
-            fragment->fragmentOffset           = fragmentOffset;
-            fragment->fragmentLength           = fragmentLength;
-            fragment->packet                   = packet;
-            fragment->command.header.command   = commandNumber;
-            fragment->command.header.channelID = channelID;
-            fragment->command.sendFragment.startSequenceNumber = startSequenceNumber;
-            fragment->command.sendFragment.dataLength     = ENET_HOST_TO_NET_16(fragmentLength);
-            fragment->command.sendFragment.fragmentCount  = ENET_HOST_TO_NET_32(fragmentCount);
-            fragment->command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32(fragmentNumber);
-            fragment->command.sendFragment.totalLength    = ENET_HOST_TO_NET_32(packet->dataLength);
-            fragment->command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32(fragmentOffset);
-
-            enet_list_insert(enet_list_end(&fragments), fragment);
-        }
-
-        packet->referenceCount += fragmentNumber;
-
-        while (!enet_list_empty(&fragments)) {
-            fragment = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(&fragments));
-
-            enet_peer_setup_outgoing_command(peer, fragment);
-        }
-
-        return 0;
-    }
-
-    command.header.channelID = channelID;
-
-    if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) == ENET_PACKET_FLAG_UNSEQUENCED) {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    } else if (packet->flags & ENET_PACKET_FLAG_RELIABLE || channel->outgoingUnreliableSequenceNumber >= 0xFFFF) {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        command.sendReliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    } else {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
-        command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    }
-
-    if (enet_peer_queue_outgoing_command(peer, &command, packet, 0, packet->dataLength) == NULL) {
-        return -1;
-    }
-
-    return 0;
-} // enet_peer_send
-
-/** Attempts to dequeue any incoming queued packet.
- *  @param peer peer to dequeue packets from
- *  @param channelID holds the channel ID of the channel the packet was received on success
- *  @returns a pointer to the packet, or NULL if there are no available incoming queued packets
- */
-ENetPacket * enet_peer_receive(ENetPeer *peer, enet_uint8 *channelID) {
-    ENetIncomingCommand *incomingCommand;
-    ENetPacket *packet;
-
-    if (enet_list_empty(&peer->dispatchedCommands)) {
-        return NULL;
-    }
-
-    incomingCommand = (ENetIncomingCommand *) enet_list_remove(enet_list_begin(&peer->dispatchedCommands));
-
-    if (channelID != NULL) {
-        *channelID = incomingCommand->command.header.channelID;
-    }
-
-    packet = incomingCommand->packet;
-
-    --packet->referenceCount;
-
-    if (incomingCommand->fragments != NULL) {
-        enet_free(incomingCommand->fragments);
-    }
-
-    enet_free(incomingCommand);
-
-    peer->totalWaitingData -= packet->dataLength;
-
-    return packet;
-}
-
-static void enet_peer_reset_outgoing_commands(ENetList *queue) {
-    ENetOutgoingCommand *outgoingCommand;
-
-    while (!enet_list_empty(queue)) {
-        outgoingCommand = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(queue));
-
-        if (outgoingCommand->packet != NULL) {
-            --outgoingCommand->packet->referenceCount;
-
-            if (outgoingCommand->packet->referenceCount == 0) {
-                enet_packet_destroy(outgoingCommand->packet);
-            }
-        }
-
-        enet_free(outgoingCommand);
-    }
-}
-
-static void enet_peer_remove_incoming_commands(ENetList *queue, ENetListIterator startCommand,
-  ENetListIterator endCommand) {
-    ENetListIterator currentCommand;
-
-    for (currentCommand = startCommand; currentCommand != endCommand;) {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        currentCommand = enet_list_next(currentCommand);
-
-        enet_list_remove(&incomingCommand->incomingCommandList);
-
-        if (incomingCommand->packet != NULL) {
-            --incomingCommand->packet->referenceCount;
-
-            if (incomingCommand->packet->referenceCount == 0) {
-                enet_packet_destroy(incomingCommand->packet);
-            }
-        }
-
-        if (incomingCommand->fragments != NULL) {
-            enet_free(incomingCommand->fragments);
-        }
-
-        enet_free(incomingCommand);
-    }
-}
-
-static void enet_peer_reset_incoming_commands(ENetList *queue) {
-    enet_peer_remove_incoming_commands(queue, enet_list_begin(queue), enet_list_end(queue));
-}
-
-void enet_peer_reset_queues(ENetPeer *peer) {
-    ENetChannel *channel;
-
-    if (peer->needsDispatch) {
-        enet_list_remove(&peer->dispatchList);
-
-        peer->needsDispatch = 0;
-    }
-
-    while (!enet_list_empty(&peer->acknowledgements))
-        enet_free(enet_list_remove(enet_list_begin(&peer->acknowledgements)));
-
-    enet_peer_reset_outgoing_commands(&peer->sentReliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->sentUnreliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->outgoingReliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->outgoingUnreliableCommands);
-    enet_peer_reset_incoming_commands(&peer->dispatchedCommands);
-
-    if (peer->channels != NULL && peer->channelCount > 0) {
-        for (channel = peer->channels;
-          channel < &peer->channels [peer->channelCount];
-          ++channel)
-        {
-            enet_peer_reset_incoming_commands(&channel->incomingReliableCommands);
-            enet_peer_reset_incoming_commands(&channel->incomingUnreliableCommands);
-        }
-
-        enet_free(peer->channels);
-    }
-
-    peer->channels     = NULL;
-    peer->channelCount = 0;
-} // enet_peer_reset_queues
-
-void enet_peer_on_connect(ENetPeer *peer) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->incomingBandwidth != 0) {
-            ++peer->host->bandwidthLimitedPeers;
-        }
-
-        ++peer->host->connectedPeers;
-    }
-}
-
-void enet_peer_on_disconnect(ENetPeer *peer) {
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->incomingBandwidth != 0) {
-            --peer->host->bandwidthLimitedPeers;
-        }
-
-        --peer->host->connectedPeers;
-    }
-}
-
-/** Forcefully disconnects a peer.
- *  @param peer peer to forcefully disconnect
- *  @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
- *  on its connection to the local host.
- */
-void enet_peer_reset(ENetPeer *peer) {
-    enet_peer_on_disconnect(peer);
-
-    peer->outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    peer->connectID      = 0;
-
-    peer->state = ENET_PEER_STATE_DISCONNECTED;
-
-    peer->incomingBandwidth = 0;
-    peer->outgoingBandwidth = 0;
-    peer->incomingBandwidthThrottleEpoch = 0;
-    peer->outgoingBandwidthThrottleEpoch = 0;
-    peer->incomingDataTotal            = 0;
-    peer->outgoingDataTotal            = 0;
-    peer->lastSendTime                 = 0;
-    peer->lastReceiveTime              = 0;
-    peer->nextTimeout                  = 0;
-    peer->earliestTimeout              = 0;
-    peer->packetLossEpoch              = 0;
-    peer->packetsSent                  = 0;
-    peer->packetsLost                  = 0;
-    peer->packetLoss                   = 0;
-    peer->packetLossVariance           = 0;
-    peer->packetThrottle               = ENET_PEER_DEFAULT_PACKET_THROTTLE;
-    peer->packetThrottleLimit          = ENET_PEER_PACKET_THROTTLE_SCALE;
-    peer->packetThrottleCounter        = 0;
-    peer->packetThrottleEpoch          = 0;
-    peer->packetThrottleAcceleration   = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
-    peer->packetThrottleDeceleration   = ENET_PEER_PACKET_THROTTLE_DECELERATION;
-    peer->packetThrottleInterval       = ENET_PEER_PACKET_THROTTLE_INTERVAL;
-    peer->pingInterval                 = ENET_PEER_PING_INTERVAL;
-    peer->timeoutLimit                 = ENET_PEER_TIMEOUT_LIMIT;
-    peer->timeoutMinimum               = ENET_PEER_TIMEOUT_MINIMUM;
-    peer->timeoutMaximum               = ENET_PEER_TIMEOUT_MAXIMUM;
-    peer->lastRoundTripTime            = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->lowestRoundTripTime          = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->lastRoundTripTimeVariance    = 0;
-    peer->highestRoundTripTimeVariance = 0;
-    peer->roundTripTime                = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->roundTripTimeVariance        = 0;
-    peer->mtu = peer->host->mtu;
-    peer->reliableDataInTransit = 0;
-    peer->outgoingReliableSequenceNumber = 0;
-    peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    peer->incomingUnsequencedGroup = 0;
-    peer->outgoingUnsequencedGroup = 0;
-    peer->eventData        = 0;
-    peer->totalWaitingData = 0;
-
-    memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-
-    enet_peer_reset_queues(peer);
-} // enet_peer_reset
-
-/** Sends a ping request to a peer.
- *  @param peer destination for the ping request
- *  @remarks ping requests factor into the mean round trip time as designated by the
- *  roundTripTime field in the ENetPeer structure.  ENet automatically pings all connected
- *  peers at regular intervals, however, this function may be called to ensure more
- *  frequent ping requests.
- */
-void enet_peer_ping(ENetPeer *peer) {
-    ENetProtocol command;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTED) {
-        return;
-    }
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-}
-
-/** Sets the interval at which pings will be sent to a peer.
- *
- *  Pings are used both to monitor the liveness of the connection and also to dynamically
- *  adjust the throttle during periods of low traffic so that the throttle has reasonable
- *  responsiveness during traffic spikes.
- *
- *  @param peer the peer to adjust
- *  @param pingInterval the interval at which to send pings; defaults to ENET_PEER_PING_INTERVAL if 0
- */
-void enet_peer_ping_interval(ENetPeer *peer, enet_uint32 pingInterval) {
-    peer->pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
-}
-
-/** Sets the timeout parameters for a peer.
- *
- *  The timeout parameter control how and when a peer will timeout from a failure to acknowledge
- *  reliable traffic. Timeout values use an exponential backoff mechanism, where if a reliable
- *  packet is not acknowledge within some multiple of the average RTT plus a variance tolerance,
- *  the timeout will be doubled until it reaches a set limit. If the timeout is thus at this
- *  limit and reliable packets have been sent but not acknowledged within a certain minimum time
- *  period, the peer will be disconnected. Alternatively, if reliable packets have been sent
- *  but not acknowledged for a certain maximum time period, the peer will be disconnected regardless
- *  of the current timeout limit value.
- *
- *  @param peer the peer to adjust
- *  @param timeoutLimit the timeout limit; defaults to ENET_PEER_TIMEOUT_LIMIT if 0
- *  @param timeoutMinimum the timeout minimum; defaults to ENET_PEER_TIMEOUT_MINIMUM if 0
- *  @param timeoutMaximum the timeout maximum; defaults to ENET_PEER_TIMEOUT_MAXIMUM if 0
- */
-
-void enet_peer_timeout(ENetPeer *peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum,
-  enet_uint32 timeoutMaximum) {
-    peer->timeoutLimit   = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
-    peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
-    peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
-}
-
-/** Force an immediate disconnection from a peer.
- *  @param peer peer to disconnect
- *  @param data data describing the disconnection
- *  @remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
- *  guaranteed to receive the disconnect notification, and is reset immediately upon
- *  return from this function.
- */
-void enet_peer_disconnect_now(ENetPeer *peer, enet_uint32 data) {
-    ENetProtocol command;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED) {
-        return;
-    }
-
-    if (peer->state != ENET_PEER_STATE_ZOMBIE &&
-      peer->state != ENET_PEER_STATE_DISCONNECTING)
-    {
-        enet_peer_reset_queues(peer);
-
-        command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        command.header.channelID = 0xFF;
-        command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-
-        enet_host_flush(peer->host);
-    }
-
-    enet_peer_reset(peer);
-}
-
-/** Request a disconnection from a peer.
- *  @param peer peer to request a disconnection
- *  @param data data describing the disconnection
- *  @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
- *  once the disconnection is complete.
- */
-void enet_peer_disconnect(ENetPeer *peer, enet_uint32 data) {
-    ENetProtocol command;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTING ||
-      peer->state == ENET_PEER_STATE_DISCONNECTED ||
-      peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
-      peer->state == ENET_PEER_STATE_ZOMBIE)
-    {
-        return;
-    }
-
-    enet_peer_reset_queues(peer);
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT;
-    command.header.channelID = 0xFF;
-    command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    } else {
-        command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-    }
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        enet_peer_on_disconnect(peer);
-
-        peer->state = ENET_PEER_STATE_DISCONNECTING;
-    } else {
-        enet_host_flush(peer->host);
-        enet_peer_reset(peer);
-    }
-} // enet_peer_disconnect
-
-/** Request a disconnection from a peer, but only after all queued outgoing packets are sent.
- *  @param peer peer to request a disconnection
- *  @param data data describing the disconnection
- *  @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
- *  once the disconnection is complete.
- */
-void enet_peer_disconnect_later(ENetPeer *peer, enet_uint32 data) {
-    if ((peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) &&
-      !(enet_list_empty(&peer->outgoingReliableCommands) &&
-      enet_list_empty(&peer->outgoingUnreliableCommands) &&
-      enet_list_empty(&peer->sentReliableCommands)))
-    {
-        peer->state     = ENET_PEER_STATE_DISCONNECT_LATER;
-        peer->eventData = data;
-    } else {
-        enet_peer_disconnect(peer, data);
-    }
-}
-
-ENetAcknowledgement * enet_peer_queue_acknowledgement(ENetPeer *peer, const ENetProtocol *command,
-  enet_uint16 sentTime) {
-    ENetAcknowledgement *acknowledgement;
-
-    if (command->header.channelID < peer->channelCount) {
-        ENetChannel *channel       = &peer->channels [command->header.channelID];
-        enet_uint16 reliableWindow = command->header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-          currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (command->header.reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 &&
-          reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS)
-        {
-            return NULL;
-        }
-    }
-
-    acknowledgement = (ENetAcknowledgement *) enet_malloc(sizeof(ENetAcknowledgement));
-    if (acknowledgement == NULL) {
-        return NULL;
-    }
-
-    peer->outgoingDataTotal += sizeof(ENetProtocolAcknowledge);
-
-    acknowledgement->sentTime = sentTime;
-    acknowledgement->command  = *command;
-
-    enet_list_insert(enet_list_end(&peer->acknowledgements), acknowledgement);
-
-    return acknowledgement;
-}
-
-void enet_peer_setup_outgoing_command(ENetPeer *peer, ENetOutgoingCommand *outgoingCommand) {
-    ENetChannel *channel = &peer->channels [outgoingCommand->command.header.channelID];
-
-    peer->outgoingDataTotal += enet_protocol_command_size(outgoingCommand->command.header.command)
-      + outgoingCommand->fragmentLength;
-
-    if (outgoingCommand->command.header.channelID == 0xFF) {
-        ++peer->outgoingReliableSequenceNumber;
-
-        outgoingCommand->reliableSequenceNumber   = peer->outgoingReliableSequenceNumber;
-        outgoingCommand->unreliableSequenceNumber = 0;
-    } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        ++channel->outgoingReliableSequenceNumber;
-        channel->outgoingUnreliableSequenceNumber = 0;
-
-        outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
-        outgoingCommand->unreliableSequenceNumber = 0;
-    } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) {
-        ++peer->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 =
-      ENET_HOST_TO_NET_16(outgoingCommand->reliableSequenceNumber);
-
-    switch (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-            outgoingCommand->command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16(
-                outgoingCommand->unreliableSequenceNumber);
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-            outgoingCommand->command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16(
-                peer->outgoingUnsequencedGroup);
-            break;
-
-        default:
-            break;
-    }
-
-    if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        enet_list_insert(enet_list_end(&peer->outgoingReliableCommands), outgoingCommand);
-    } else {
-        enet_list_insert(enet_list_end(&peer->outgoingUnreliableCommands), outgoingCommand);
-    }
-} // enet_peer_setup_outgoing_command
-
-ENetOutgoingCommand * enet_peer_queue_outgoing_command(ENetPeer *peer, const ENetProtocol *command, ENetPacket *packet,
-  enet_uint32 offset, enet_uint16 length) {
-    ENetOutgoingCommand *outgoingCommand = (ENetOutgoingCommand *) enet_malloc(sizeof(ENetOutgoingCommand));
-
-    if (outgoingCommand == NULL) {
-        return NULL;
-    }
-
-    outgoingCommand->command        = *command;
-    outgoingCommand->fragmentOffset = offset;
-    outgoingCommand->fragmentLength = length;
-    outgoingCommand->packet         = packet;
-    if (packet != NULL) {
-        ++packet->referenceCount;
-    }
-
-    enet_peer_setup_outgoing_command(peer, outgoingCommand);
-
-    return outgoingCommand;
-}
-
-void enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *peer, ENetChannel *channel) {
-    ENetListIterator droppedCommand, startCommand, currentCommand;
-
-    for (droppedCommand = startCommand = currentCommand = enet_list_begin(&channel->incomingUnreliableCommands);
-      currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) ==
-          ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
-        {
-            continue;
-        }
-
-        if (incomingCommand->reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-            if (incomingCommand->fragmentsRemaining <= 0) {
-                channel->incomingUnreliableSequenceNumber = incomingCommand->unreliableSequenceNumber;
-                continue;
-            }
-
-            if (startCommand != currentCommand) {
-                enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(
-                      currentCommand));
-
-                if (!peer->needsDispatch) {
-                    enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-                    peer->needsDispatch = 1;
-                }
-
-                droppedCommand = currentCommand;
-            } else if (droppedCommand != currentCommand) {
-                droppedCommand = enet_list_previous(currentCommand);
-            }
-        } else {
-            enet_uint16 reliableWindow = incomingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-              currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-            if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-            }
-            if (reliableWindow >= currentWindow &&
-              reliableWindow < currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-            {
-                break;
-            }
-
-            droppedCommand = enet_list_next(currentCommand);
-
-            if (startCommand != currentCommand) {
-                enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(
-                      currentCommand));
-
-                if (!peer->needsDispatch) {
-                    enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-                    peer->needsDispatch = 1;
-                }
-            }
-        }
-
-        startCommand = enet_list_next(currentCommand);
-    }
-
-    if (startCommand != currentCommand) {
-        enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
-
-        if (!peer->needsDispatch) {
-            enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-            peer->needsDispatch = 1;
-        }
-
-        droppedCommand = currentCommand;
-    }
-
-    enet_peer_remove_incoming_commands(&channel->incomingUnreliableCommands,
-      enet_list_begin(&channel->incomingUnreliableCommands), droppedCommand);
-} // enet_peer_dispatch_incoming_unreliable_commands
-
-void enet_peer_dispatch_incoming_reliable_commands(ENetPeer *peer, ENetChannel *channel) {
-    ENetListIterator currentCommand;
-
-    for (currentCommand = enet_list_begin(&channel->incomingReliableCommands);
-      currentCommand != enet_list_end(&channel->incomingReliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if (incomingCommand->fragmentsRemaining > 0 ||
-          incomingCommand->reliableSequenceNumber != (enet_uint16) (channel->incomingReliableSequenceNumber + 1))
-        {
-            break;
-        }
-
-        channel->incomingReliableSequenceNumber = incomingCommand->reliableSequenceNumber;
-
-        if (incomingCommand->fragmentCount > 0) {
-            channel->incomingReliableSequenceNumber += incomingCommand->fragmentCount - 1;
-        }
-    }
-
-    if (currentCommand == enet_list_begin(&channel->incomingReliableCommands)) {
-        return;
-    }
-
-    channel->incomingUnreliableSequenceNumber = 0;
-
-    enet_list_move(enet_list_end(&peer->dispatchedCommands), enet_list_begin(
-          &channel->incomingReliableCommands), enet_list_previous(currentCommand));
-
-    if (!peer->needsDispatch) {
-        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-        peer->needsDispatch = 1;
-    }
-
-    if (!enet_list_empty(&channel->incomingUnreliableCommands)) {
-        enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-    }
-} // enet_peer_dispatch_incoming_reliable_commands
-
-ENetIncomingCommand * enet_peer_queue_incoming_command(ENetPeer *peer, const ENetProtocol *command, const void *data,
-  size_t dataLength, enet_uint32 flags,
-  enet_uint32 fragmentCount) {
-    static ENetIncomingCommand dummyCommand;
-
-    ENetChannel *channel = &peer->channels [command->header.channelID];
-    enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber = 0;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetIncomingCommand *incomingCommand;
-    ENetListIterator currentCommand;
-    ENetPacket *packet = NULL;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        goto discardCommand;
-    }
-
-    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-        reliableSequenceNumber = command->header.reliableSequenceNumber;
-        reliableWindow         = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-            goto discardCommand;
-        }
-    }
-
-    switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-        case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-            if (reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-                goto discardCommand;
-            }
-
-            for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-              currentCommand != enet_list_end(&channel->incomingReliableCommands);
-              currentCommand = enet_list_previous(currentCommand))
-            {
-                incomingCommand = (ENetIncomingCommand *) 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;
-                    }
-
-                    goto discardCommand;
-                }
-            }
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-            unreliableSequenceNumber = ENET_NET_TO_HOST_16(command->sendUnreliable.unreliableSequenceNumber);
-
-            if (reliableSequenceNumber == channel->incomingReliableSequenceNumber &&
-              unreliableSequenceNumber <= channel->incomingUnreliableSequenceNumber)
-            {
-                goto discardCommand;
-            }
-
-            for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-              currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-              currentCommand = enet_list_previous(currentCommand))
-            {
-                incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-                if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-                    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;
-                    }
-
-                    goto discardCommand;
-                }
-            }
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-            currentCommand = enet_list_end(&channel->incomingUnreliableCommands);
-            break;
-
-        default:
-            goto discardCommand;
-    }
-
-    if (peer->totalWaitingData >= peer->host->maximumWaitingData) {
-        goto notifyError;
-    }
-
-    packet = enet_packet_create(data, dataLength, flags);
-    if (packet == NULL) {
-        goto notifyError;
-    }
-
-    incomingCommand = (ENetIncomingCommand *) enet_malloc(sizeof(ENetIncomingCommand));
-    if (incomingCommand == NULL) {
-        goto notifyError;
-    }
-
-    incomingCommand->reliableSequenceNumber   = command->header.reliableSequenceNumber;
-    incomingCommand->unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF;
-    incomingCommand->command            = *command;
-    incomingCommand->fragmentCount      = fragmentCount;
-    incomingCommand->fragmentsRemaining = fragmentCount;
-    incomingCommand->packet    = packet;
-    incomingCommand->fragments = NULL;
-
-    if (fragmentCount > 0) {
-        if (fragmentCount <= ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-            incomingCommand->fragments = (enet_uint32 *) enet_malloc((fragmentCount + 31) / 32 * sizeof(enet_uint32));
-        }
-        if (incomingCommand->fragments == NULL) {
-            enet_free(incomingCommand);
-
-            goto notifyError;
-        }
-        memset(incomingCommand->fragments, 0, (fragmentCount + 31) / 32 * sizeof(enet_uint32));
-    }
-
-    if (packet != NULL) {
-        ++packet->referenceCount;
-
-        peer->totalWaitingData += packet->dataLength;
-    }
-
-    enet_list_insert(enet_list_next(currentCommand), incomingCommand);
-
-    switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-        case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-            enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-            break;
-
-        default:
-            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-            break;
-    }
-
-    return incomingCommand;
-
-discardCommand:
-    if (fragmentCount > 0) {
-        goto notifyError;
-    }
-
-    if (packet != NULL && packet->referenceCount == 0) {
-        enet_packet_destroy(packet);
-    }
-
-    return &dummyCommand;
-
-notifyError:
-    if (packet != NULL && packet->referenceCount == 0) {
-        enet_packet_destroy(packet);
-    }
-
-    return NULL;
-} // enet_peer_queue_incoming_command
-
-/** @} */
-
-// @from_file: src/protocol.c
-
-/**
- * @file  protocol.c
- * @brief ENet protocol functions
- */
-#  include <stdio.h>
-
-#  define ENET_BUILDING_LIB 1
-
-
-static size_t commandSizes [ENET_PROTOCOL_COMMAND_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)
-};
-
-size_t enet_protocol_command_size(enet_uint8 commandNumber) {
-    return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK];
-}
-
-static void enet_protocol_change_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-    if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        enet_peer_on_connect(peer);
-    } else {
-        enet_peer_on_disconnect(peer);
-    }
-
-    peer->state = state;
-}
-
-static void enet_protocol_dispatch_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-    enet_protocol_change_state(host, peer, state);
-
-    if (!peer->needsDispatch) {
-        enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-
-        peer->needsDispatch = 1;
-    }
-}
-
-static int enet_protocol_dispatch_incoming_commands(ENetHost *host, ENetEvent *event) {
-    while (!enet_list_empty(&host->dispatchQueue)) {
-        ENetPeer *peer = (ENetPeer *) enet_list_remove(enet_list_begin(&host->dispatchQueue));
-
-        peer->needsDispatch = 0;
-
-        switch (peer->state) {
-            case ENET_PEER_STATE_CONNECTION_PENDING:
-            case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
-                enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-                event->type = ENET_EVENT_TYPE_CONNECT;
-                event->peer = peer;
-                event->data = peer->eventData;
-
-                return 1;
-
-            case ENET_PEER_STATE_ZOMBIE:
-                host->recalculateBandwidthLimits = 1;
-
-                event->type = ENET_EVENT_TYPE_DISCONNECT;
-                event->peer = peer;
-                event->data = peer->eventData;
-
-                enet_peer_reset(peer);
-
-                return 1;
-
-            case ENET_PEER_STATE_CONNECTED:
-                if (enet_list_empty(&peer->dispatchedCommands)) {
-                    continue;
-                }
-
-                event->packet = enet_peer_receive(peer, &event->channelID);
-                if (event->packet == NULL) {
-                    continue;
-                }
-
-                event->type = ENET_EVENT_TYPE_RECEIVE;
-                event->peer = peer;
-
-                if (!enet_list_empty(&peer->dispatchedCommands)) {
-                    peer->needsDispatch = 1;
-
-                    enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-                }
-
-                return 1;
-
-            default:
-                break;
-        }
-    }
-
-    return 0;
-} // enet_protocol_dispatch_incoming_commands
-
-static void enet_protocol_notify_connect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    host->recalculateBandwidthLimits = 1;
-
-    if (event != NULL) {
-        enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-        event->type = ENET_EVENT_TYPE_CONNECT;
-        event->peer = peer;
-        event->data = peer->eventData;
-    } else {
-        enet_protocol_dispatch_state(host, peer,
-          peer->state ==
-          ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING);
-    }
-}
-
-static void enet_protocol_notify_disconnect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
-        host->recalculateBandwidthLimits = 1;
-    }
-
-    if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
-        enet_peer_reset(peer);
-    } else if (event != NULL) {
-        event->type = ENET_EVENT_TYPE_DISCONNECT;
-        event->peer = peer;
-        event->data = 0;
-
-        enet_peer_reset(peer);
-    } else {
-        peer->eventData = 0;
-
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    }
-}
-
-static void enet_protocol_remove_sent_unreliable_commands(ENetPeer *peer) {
-    ENetOutgoingCommand *outgoingCommand;
-
-    while (!enet_list_empty(&peer->sentUnreliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) enet_list_front(&peer->sentUnreliableCommands);
-
-        enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-        if (outgoingCommand->packet != NULL) {
-            --outgoingCommand->packet->referenceCount;
-
-            if (outgoingCommand->packet->referenceCount == 0) {
-                outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-
-                enet_packet_destroy(outgoingCommand->packet);
-            }
-        }
-
-        enet_free(outgoingCommand);
-    }
-}
-
-static ENetProtocolCommand enet_protocol_remove_sent_reliable_command(ENetPeer *peer,
-  enet_uint16                                                                   reliableSequenceNumber,
-  enet_uint8                                                                    channelID) {
-    ENetOutgoingCommand *outgoingCommand = NULL;
-    ENetListIterator currentCommand;
-    ENetProtocolCommand commandNumber;
-    int wasSent = 1;
-
-    for (currentCommand = enet_list_begin(&peer->sentReliableCommands);
-      currentCommand != enet_list_end(&peer->sentReliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber &&
-          outgoingCommand->command.header.channelID == channelID)
-        {
-            break;
-        }
-    }
-
-    if (currentCommand == enet_list_end(&peer->sentReliableCommands)) {
-        for (currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-          currentCommand != enet_list_end(&peer->outgoingReliableCommands);
-          currentCommand = enet_list_next(currentCommand))
-        {
-            outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-            if (outgoingCommand->sendAttempts < 1) { return ENET_PROTOCOL_COMMAND_NONE; }
-
-            if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber &&
-              outgoingCommand->command.header.channelID == channelID)
-            {
-                break;
-            }
-        }
-
-        if (currentCommand == enet_list_end(&peer->outgoingReliableCommands)) {
-            return ENET_PROTOCOL_COMMAND_NONE;
-        }
-
-        wasSent = 0;
-    }
-
-    if (outgoingCommand == NULL) {
-        return ENET_PROTOCOL_COMMAND_NONE;
-    }
-
-    if (channelID < peer->channelCount) {
-        ENetChannel *channel       = &peer->channels [channelID];
-        enet_uint16 reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        if (channel->reliableWindows [reliableWindow] > 0) {
-            --channel->reliableWindows [reliableWindow];
-            if (!channel->reliableWindows [reliableWindow]) {
-                channel->usedReliableWindows &= ~(1 << reliableWindow);
-            }
-        }
-    }
-
-    commandNumber = (ENetProtocolCommand) (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK);
-
-    enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-    if (outgoingCommand->packet != NULL) {
-        if (wasSent) {
-            peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-        }
-
-        --outgoingCommand->packet->referenceCount;
-
-        if (outgoingCommand->packet->referenceCount == 0) {
-            outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-
-            enet_packet_destroy(outgoingCommand->packet);
-        }
-    }
-
-    enet_free(outgoingCommand);
-
-    if (enet_list_empty(&peer->sentReliableCommands)) {
-        return commandNumber;
-    }
-
-    outgoingCommand = (ENetOutgoingCommand *) enet_list_front(&peer->sentReliableCommands);
-
-    peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-
-    return commandNumber;
-} // enet_protocol_remove_sent_reliable_command
-
-static ENetPeer * enet_protocol_handle_connect(ENetHost *host, ENetProtocolHeader *header, ENetProtocol *command) {
-    enet_uint8 incomingSessionID, outgoingSessionID;
-    enet_uint32 mtu, windowSize;
-    ENetChannel *channel;
-    size_t channelCount, duplicatePeers = 0;
-    ENetPeer *currentPeer, *peer = NULL;
-    ENetProtocol verifyCommand;
-
-    channelCount = ENET_NET_TO_HOST_32(command->connect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||
-      channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-    {
-        return NULL;
-    }
-
-    for (currentPeer = host->peers;
-      currentPeer < &host->peers [host->peerCount];
-      ++currentPeer)
-    {
-        if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
-            if (peer == NULL) {
-                peer = currentPeer;
-            }
-        } else if (currentPeer->state != ENET_PEER_STATE_CONNECTING &&
-          currentPeer->address.host == host->receivedAddress.host)
-        {
-            if (currentPeer->address.port == host->receivedAddress.port &&
-              currentPeer->connectID == command->connect.connectID)
-            {
-                return NULL;
-            }
-
-            ++duplicatePeers;
-        }
-    }
-
-    if (peer == NULL || duplicatePeers >= host->duplicatePeers) {
-        return NULL;
-    }
-
-    if (channelCount > host->channelLimit) {
-        channelCount = host->channelLimit;
-    }
-    peer->channels = (ENetChannel *) enet_malloc(channelCount * sizeof(ENetChannel));
-    if (peer->channels == NULL) {
-        return NULL;
-    }
-    peer->channelCount               = channelCount;
-    peer->state                      = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
-    peer->connectID                  = command->connect.connectID;
-    peer->address                    = host->receivedAddress;
-    peer->outgoingPeerID             = ENET_NET_TO_HOST_16(command->connect.outgoingPeerID);
-    peer->incomingBandwidth          = ENET_NET_TO_HOST_32(command->connect.incomingBandwidth);
-    peer->outgoingBandwidth          = ENET_NET_TO_HOST_32(command->connect.outgoingBandwidth);
-    peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->connect.packetThrottleInterval);
-    peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleAcceleration);
-    peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleDeceleration);
-    peer->eventData                  = ENET_NET_TO_HOST_32(command->connect.data);
-
-    incomingSessionID = command->connect.incomingSessionID ==
-      0xFF ? peer->outgoingSessionID : command->connect.incomingSessionID;
-    incomingSessionID = (incomingSessionID + 1)
-      & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (incomingSessionID == peer->outgoingSessionID) {
-        incomingSessionID = (incomingSessionID + 1)
-          & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    }
-    peer->outgoingSessionID = incomingSessionID;
-
-    outgoingSessionID = command->connect.outgoingSessionID ==
-      0xFF ? peer->incomingSessionID : command->connect.outgoingSessionID;
-    outgoingSessionID = (outgoingSessionID + 1)
-      & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (outgoingSessionID == peer->incomingSessionID) {
-        outgoingSessionID = (outgoingSessionID + 1)
-          & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    }
-    peer->incomingSessionID = outgoingSessionID;
-
-    for (channel = peer->channels;
-      channel < &peer->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));
-    }
-
-    mtu = ENET_NET_TO_HOST_32(command->connect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-    }
-
-    peer->mtu = mtu;
-
-    if (host->outgoingBandwidth == 0 &&
-      peer->incomingBandwidth == 0)
-    {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else if (host->outgoingBandwidth == 0 ||
-      peer->incomingBandwidth == 0)
-    {
-        peer->windowSize = (ENET_MAX(host->outgoingBandwidth, peer->incomingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else {
-        peer->windowSize = (ENET_MIN(host->outgoingBandwidth, peer->incomingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    if (host->incomingBandwidth == 0) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else {
-        windowSize = (host->incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize > ENET_NET_TO_HOST_32(command->connect.windowSize)) {
-        windowSize = ENET_NET_TO_HOST_32(command->connect.windowSize);
-    }
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    verifyCommand.header.command   = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    verifyCommand.header.channelID = 0xFF;
-    verifyCommand.verifyConnect.outgoingPeerID    = ENET_HOST_TO_NET_16(peer->incomingPeerID);
-    verifyCommand.verifyConnect.incomingSessionID = incomingSessionID;
-    verifyCommand.verifyConnect.outgoingSessionID = outgoingSessionID;
-    verifyCommand.verifyConnect.mtu                        = ENET_HOST_TO_NET_32(peer->mtu);
-    verifyCommand.verifyConnect.windowSize                 = ENET_HOST_TO_NET_32(windowSize);
-    verifyCommand.verifyConnect.channelCount               = ENET_HOST_TO_NET_32(channelCount);
-    verifyCommand.verifyConnect.incomingBandwidth          = ENET_HOST_TO_NET_32(host->incomingBandwidth);
-    verifyCommand.verifyConnect.outgoingBandwidth          = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
-    verifyCommand.verifyConnect.packetThrottleInterval     = ENET_HOST_TO_NET_32(peer->packetThrottleInterval);
-    verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32(peer->packetThrottleAcceleration);
-    verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32(peer->packetThrottleDeceleration);
-    verifyCommand.verifyConnect.connectID                  = peer->connectID;
-
-    enet_peer_queue_outgoing_command(peer, &verifyCommand, NULL, 0, 0);
-
-    return peer;
-} // enet_protocol_handle_connect
-
-static int enet_protocol_handle_send_reliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendReliable.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *) command + sizeof(ENetProtocolSendReliable),
-      dataLength, ENET_PACKET_FLAG_RELIABLE, 0) == NULL)
-    {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_send_unsequenced(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 unsequencedGroup, index;
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendUnsequenced.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    unsequencedGroup = ENET_NET_TO_HOST_16(command->sendUnsequenced.unsequencedGroup);
-    index = unsequencedGroup % ENET_PEER_UNSEQUENCED_WINDOW_SIZE;
-
-    if (unsequencedGroup < peer->incomingUnsequencedGroup) {
-        unsequencedGroup += 0x10000;
-    }
-
-    if (unsequencedGroup >=
-      (enet_uint32) peer->incomingUnsequencedGroup + ENET_PEER_FREE_UNSEQUENCED_WINDOWS
-      * ENET_PEER_UNSEQUENCED_WINDOW_SIZE)
-    {
-        return 0;
-    }
-
-    unsequencedGroup &= 0xFFFF;
-
-    if (unsequencedGroup - index != peer->incomingUnsequencedGroup) {
-        peer->incomingUnsequencedGroup = unsequencedGroup - index;
-
-        memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-    } else if (peer->unsequencedWindow [index / 32] & (1 << (index % 32))) {
-        return 0;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command,
-      (const enet_uint8 *) command + sizeof(ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED,
-      0) == NULL)
-    {
-        return -1;
-    }
-
-    peer->unsequencedWindow [index / 32] |= 1 << (index % 32);
-
-    return 0;
-} // enet_protocol_handle_send_unsequenced
-
-static int enet_protocol_handle_send_unreliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendUnreliable.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command,
-      (const enet_uint8 *) command + sizeof(ENetProtocolSendUnreliable), dataLength, 0, 0) == NULL)
-    {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_send_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 fragmentNumber,
-      fragmentCount,
-      fragmentOffset,
-      fragmentLength,
-      startSequenceNumber,
-      totalLength;
-    ENetChannel *channel;
-    enet_uint16 startWindow, currentWindow;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand *startCommand = NULL;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-    *currentData  += fragmentLength;
-    if (fragmentLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    channel = &peer->channels [command->header.channelID];
-    startSequenceNumber = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-    startWindow         = startSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow       = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (startSequenceNumber < channel->incomingReliableSequenceNumber) {
-        startWindow += ENET_PEER_RELIABLE_WINDOWS;
-    }
-
-    if (startWindow < currentWindow || startWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-        return 0;
-    }
-
-    fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-    fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-    totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-      fragmentNumber >= fragmentCount ||
-      totalLength > host->maximumPacketSize ||
-      fragmentOffset >= totalLength ||
-      fragmentLength > totalLength - fragmentOffset)
-    {
-        return -1;
-    }
-
-    for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-      currentCommand != enet_list_end(&channel->incomingReliableCommands);
-      currentCommand = enet_list_previous(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if (startSequenceNumber >= channel->incomingReliableSequenceNumber) {
-            if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                continue;
-            }
-        } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-            break;
-        }
-
-        if (incomingCommand->reliableSequenceNumber <= startSequenceNumber) {
-            if (incomingCommand->reliableSequenceNumber < startSequenceNumber) {
-                break;
-            }
-
-            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-              ENET_PROTOCOL_COMMAND_SEND_FRAGMENT ||
-              totalLength != incomingCommand->packet->dataLength ||
-              fragmentCount != incomingCommand->fragmentCount)
-            {
-                return -1;
-            }
-
-            startCommand = incomingCommand;
-            break;
-        }
-    }
-
-    if (startCommand == NULL) {
-        ENetProtocol hostCommand = *command;
-
-        hostCommand.header.reliableSequenceNumber = startSequenceNumber;
-
-        startCommand = enet_peer_queue_incoming_command(peer, &hostCommand, NULL, totalLength,
-            ENET_PACKET_FLAG_RELIABLE, fragmentCount);
-        if (startCommand == NULL) {
-            return -1;
-        }
-    }
-
-    if ((startCommand->fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-        --startCommand->fragmentsRemaining;
-
-        startCommand->fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-        if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-            fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-        }
-
-        memcpy(startCommand->packet->data + fragmentOffset,
-          (enet_uint8 *) command + sizeof(ENetProtocolSendFragment),
-          fragmentLength);
-
-        if (startCommand->fragmentsRemaining <= 0) {
-            enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-        }
-    }
-
-    return 0;
-} // enet_protocol_handle_send_fragment
-
-static int enet_protocol_handle_send_unreliable_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 fragmentNumber,
-      fragmentCount,
-      fragmentOffset,
-      fragmentLength,
-      reliableSequenceNumber,
-      startSequenceNumber,
-      totalLength;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetChannel *channel;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand *startCommand = NULL;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-    *currentData  += fragmentLength;
-    if (fragmentLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    channel = &peer->channels [command->header.channelID];
-    reliableSequenceNumber = command->header.reliableSequenceNumber;
-    startSequenceNumber    = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-
-    reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-        reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-    }
-
-    if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-        return 0;
-    }
-
-    if (reliableSequenceNumber == channel->incomingReliableSequenceNumber &&
-      startSequenceNumber <= channel->incomingUnreliableSequenceNumber)
-    {
-        return 0;
-    }
-
-    fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-    fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-    totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-      fragmentNumber >= fragmentCount ||
-      totalLength > host->maximumPacketSize ||
-      fragmentOffset >= totalLength ||
-      fragmentLength > totalLength - fragmentOffset)
-    {
-        return -1;
-    }
-
-    for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-      currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-      currentCommand = enet_list_previous(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        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 <= startSequenceNumber) {
-            if (incomingCommand->unreliableSequenceNumber < startSequenceNumber) {
-                break;
-            }
-
-            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-              ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT ||
-              totalLength != incomingCommand->packet->dataLength ||
-              fragmentCount != incomingCommand->fragmentCount)
-            {
-                return -1;
-            }
-
-            startCommand = incomingCommand;
-            break;
-        }
-    }
-
-    if (startCommand == NULL) {
-        startCommand = enet_peer_queue_incoming_command(peer, command, NULL, totalLength,
-            ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT, fragmentCount);
-        if (startCommand == NULL) {
-            return -1;
-        }
-    }
-
-    if ((startCommand->fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-        --startCommand->fragmentsRemaining;
-
-        startCommand->fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-        if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-            fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-        }
-
-        memcpy(startCommand->packet->data + fragmentOffset,
-          (enet_uint8 *) command + sizeof(ENetProtocolSendFragment),
-          fragmentLength);
-
-        if (startCommand->fragmentsRemaining <= 0) {
-            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-        }
-    }
-
-    return 0;
-} // enet_protocol_handle_send_unreliable_fragment
-
-static int enet_protocol_handle_ping(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_bandwidth_limit(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    if (peer->incomingBandwidth != 0) {
-        --host->bandwidthLimitedPeers;
-    }
-
-    peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.incomingBandwidth);
-    peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
-
-    if (peer->incomingBandwidth != 0) {
-        ++host->bandwidthLimitedPeers;
-    }
-
-    if (peer->incomingBandwidth == 0 && host->outgoingBandwidth == 0) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else if (peer->incomingBandwidth == 0 || host->outgoingBandwidth == 0) {
-        peer->windowSize = (ENET_MAX(peer->incomingBandwidth, host->outgoingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else {
-        peer->windowSize = (ENET_MIN(peer->incomingBandwidth, host->outgoingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    return 0;
-} // enet_protocol_handle_bandwidth_limit
-
-static int enet_protocol_handle_throttle_configure(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleInterval);
-    peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleAcceleration);
-    peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleDeceleration);
-
-    return 0;
-}
-
-static int enet_protocol_handle_disconnect(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE ||
-      peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT)
-    {
-        return 0;
-    }
-
-    enet_peer_reset_queues(peer);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer->state == ENET_PEER_STATE_DISCONNECTING ||
-      peer->state == ENET_PEER_STATE_CONNECTING)
-    {
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    } else if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->state == ENET_PEER_STATE_CONNECTION_PENDING) { host->recalculateBandwidthLimits = 1; }
-
-        enet_peer_reset(peer);
-    } else if (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        enet_protocol_change_state(host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
-    } else {
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    }
-
-    if (peer->state != ENET_PEER_STATE_DISCONNECTED) {
-        peer->eventData = ENET_NET_TO_HOST_32(command->disconnect.data);
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_acknowledge(ENetHost *host, ENetEvent *event, ENetPeer *peer,
-  const ENetProtocol *command) {
-    enet_uint32 roundTripTime,
-      receivedSentTime,
-      receivedReliableSequenceNumber;
-    ENetProtocolCommand commandNumber;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE) {
-        return 0;
-    }
-
-    receivedSentTime  = ENET_NET_TO_HOST_16(command->acknowledge.receivedSentTime);
-    receivedSentTime |= host->serviceTime & 0xFFFF0000;
-    if ((receivedSentTime & 0x8000) > (host->serviceTime & 0x8000)) {
-        receivedSentTime -= 0x10000;
-    }
-
-    if (ENET_TIME_LESS(host->serviceTime, receivedSentTime)) {
-        return 0;
-    }
-
-    peer->lastReceiveTime = host->serviceTime;
-    peer->earliestTimeout = 0;
-
-    roundTripTime = ENET_TIME_DIFFERENCE(host->serviceTime, receivedSentTime);
-
-    enet_peer_throttle(peer, roundTripTime);
-
-    peer->roundTripTimeVariance -= peer->roundTripTimeVariance / 4;
-
-    if (roundTripTime >= peer->roundTripTime) {
-        peer->roundTripTime         += (roundTripTime - peer->roundTripTime) / 8;
-        peer->roundTripTimeVariance += (roundTripTime - peer->roundTripTime) / 4;
-    } else {
-        peer->roundTripTime         -= (peer->roundTripTime - roundTripTime) / 8;
-        peer->roundTripTimeVariance += (peer->roundTripTime - roundTripTime) / 4;
-    }
-
-    if (peer->roundTripTime < peer->lowestRoundTripTime) {
-        peer->lowestRoundTripTime = peer->roundTripTime;
-    }
-
-    if (peer->roundTripTimeVariance > peer->highestRoundTripTimeVariance) {
-        peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-    }
-
-    if (peer->packetThrottleEpoch == 0 ||
-      ENET_TIME_DIFFERENCE(host->serviceTime, peer->packetThrottleEpoch) >= peer->packetThrottleInterval)
-    {
-        peer->lastRoundTripTime            = peer->lowestRoundTripTime;
-        peer->lastRoundTripTimeVariance    = peer->highestRoundTripTimeVariance;
-        peer->lowestRoundTripTime          = peer->roundTripTime;
-        peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-        peer->packetThrottleEpoch          = host->serviceTime;
-    }
-
-    receivedReliableSequenceNumber = ENET_NET_TO_HOST_16(command->acknowledge.receivedReliableSequenceNumber);
-
-    commandNumber = enet_protocol_remove_sent_reliable_command(peer, receivedReliableSequenceNumber,
-        command->header.channelID);
-
-    switch (peer->state) {
-        case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-            if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT) {
-                return -1;
-            }
-
-            enet_protocol_notify_connect(host, peer, event);
-            break;
-
-        case ENET_PEER_STATE_DISCONNECTING:
-            if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                return -1;
-            }
-
-            enet_protocol_notify_disconnect(host, peer, event);
-            break;
-
-        case ENET_PEER_STATE_DISCONNECT_LATER:
-            if (enet_list_empty(&peer->outgoingReliableCommands) &&
-              enet_list_empty(&peer->outgoingUnreliableCommands) &&
-              enet_list_empty(&peer->sentReliableCommands))
-            {
-                enet_peer_disconnect(peer, peer->eventData);
-            }
-            break;
-
-        default:
-            break;
-    }
-
-    return 0;
-} // enet_protocol_handle_acknowledge
-
-static int enet_protocol_handle_verify_connect(ENetHost *host, ENetEvent *event, ENetPeer *peer,
-  const ENetProtocol *command) {
-    enet_uint32 mtu, windowSize;
-    size_t channelCount;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTING) {
-        return 0;
-    }
-
-    channelCount = ENET_NET_TO_HOST_32(command->verifyConnect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleInterval) != peer->packetThrottleInterval ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleAcceleration) != peer->packetThrottleAcceleration ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleDeceleration) != peer->packetThrottleDeceleration ||
-      command->verifyConnect.connectID != peer->connectID)
-    {
-        peer->eventData = 0;
-
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-
-        return -1;
-    }
-
-    enet_protocol_remove_sent_reliable_command(peer, 1, 0xFF);
-
-    if (channelCount < peer->channelCount) {
-        peer->channelCount = channelCount;
-    }
-
-    peer->outgoingPeerID    = ENET_NET_TO_HOST_16(command->verifyConnect.outgoingPeerID);
-    peer->incomingSessionID = command->verifyConnect.incomingSessionID;
-    peer->outgoingSessionID = command->verifyConnect.outgoingSessionID;
-
-    mtu = ENET_NET_TO_HOST_32(command->verifyConnect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-    }
-
-    if (mtu < peer->mtu) {
-        peer->mtu = mtu;
-    }
-
-    windowSize = ENET_NET_TO_HOST_32(command->verifyConnect.windowSize);
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize < peer->windowSize) {
-        peer->windowSize = windowSize;
-    }
-
-    peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.incomingBandwidth);
-    peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.outgoingBandwidth);
-
-    enet_protocol_notify_connect(host, peer, event);
-    return 0;
-} // enet_protocol_handle_verify_connect
-
-static int enet_protocol_handle_incoming_commands(ENetHost *host, ENetEvent *event) {
-    ENetProtocolHeader *header;
-    ENetProtocol *command;
-    ENetPeer *peer;
-    enet_uint8 *currentData;
-    size_t headerSize;
-    enet_uint16 peerID, flags;
-    enet_uint8 sessionID;
-
-    if (host->receivedDataLength < (size_t) &((ENetProtocolHeader *) 0)->sentTime) {
-        return 0;
-    }
-
-    header = (ENetProtocolHeader *) host->receivedData;
-
-    peerID    = ENET_NET_TO_HOST_16(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;
-        }
-    }
-
-    if (flags & ENET_PROTOCOL_HEADER_FLAG_COMPRESSED) {
-        size_t originalSize;
-        if (host->compressor.context == NULL || host->compressor.decompress == NULL) {
-            return 0;
-        }
-
-        originalSize = host->compressor.decompress(host->compressor.context,
-            host->receivedData + headerSize,
-            host->receivedDataLength - headerSize,
-            host->packetData [1] + headerSize,
-            sizeof(host->packetData [1]) - headerSize);
-        if (originalSize <= 0 || originalSize > sizeof(host->packetData [1]) - headerSize) {
-            return 0;
-        }
-
-        memcpy(host->packetData [1], header, headerSize);
-        host->receivedData       = host->packetData [1];
-        host->receivedDataLength = headerSize + originalSize;
-    }
-
-    if (host->checksum != NULL) {
-        enet_uint32 *checksum = (enet_uint32 *) &host->receivedData [headerSize - sizeof(enet_uint32)],
-          desiredChecksum     = *checksum;
-        ENetBuffer buffer;
-
-        *checksum = peer != NULL ? peer->connectID : 0;
-
-        buffer.data       = host->receivedData;
-        buffer.dataLength = host->receivedDataLength;
-
-        if (host->checksum(&buffer, 1) != desiredChecksum) {
-            return 0;
-        }
-    }
-
-    if (peer != NULL) {
-        peer->address.host       = host->receivedAddress.host;
-        peer->address.port       = host->receivedAddress.port;
-        peer->incomingDataTotal += host->receivedDataLength;
-    }
-
-    currentData = host->receivedData + headerSize;
-
-    while (currentData < &host->receivedData [host->receivedDataLength]) {
-        enet_uint8 commandNumber;
-        size_t commandSize;
-
-        command = (ENetProtocol *) currentData;
-
-        if (currentData + sizeof(ENetProtocolCommandHeader) > &host->receivedData [host->receivedDataLength]) {
-            break;
-        }
-
-        commandNumber = command->header.command & ENET_PROTOCOL_COMMAND_MASK;
-        if (commandNumber >= ENET_PROTOCOL_COMMAND_COUNT) {
-            break;
-        }
-
-        commandSize = commandSizes [commandNumber];
-        if (commandSize == 0 || currentData + commandSize > &host->receivedData [host->receivedDataLength]) {
-            break;
-        }
-
-        currentData += commandSize;
-
-        if (peer == NULL && commandNumber != ENET_PROTOCOL_COMMAND_CONNECT) {
-            break;
-        }
-
-        command->header.reliableSequenceNumber = ENET_NET_TO_HOST_16(command->header.reliableSequenceNumber);
-
-        switch (commandNumber) {
-            case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
-                if (enet_protocol_handle_acknowledge(host, event, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_CONNECT:
-                if (peer != NULL) {
-                    goto commandError;
-                }
-                peer = enet_protocol_handle_connect(host, header, command);
-                if (peer == NULL) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
-                if (enet_protocol_handle_verify_connect(host, event, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_DISCONNECT:
-                if (enet_protocol_handle_disconnect(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_PING:
-                if (enet_protocol_handle_ping(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-                if (enet_protocol_handle_send_reliable(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-                if (enet_protocol_handle_send_unreliable(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-                if (enet_protocol_handle_send_unsequenced(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-                if (enet_protocol_handle_send_fragment(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
-                if (enet_protocol_handle_bandwidth_limit(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
-                if (enet_protocol_handle_throttle_configure(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-                if (enet_protocol_handle_send_unreliable_fragment(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            default:
-                goto commandError;
-        }
-
-        if (peer != NULL &&
-          (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0)
-        {
-            enet_uint16 sentTime;
-
-            if (!(flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)) {
-                break;
-            }
-
-            sentTime = ENET_NET_TO_HOST_16(header->sentTime);
-
-            switch (peer->state) {
-                case ENET_PEER_STATE_DISCONNECTING:
-                case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-                case ENET_PEER_STATE_DISCONNECTED:
-                case ENET_PEER_STATE_ZOMBIE:
-                    break;
-
-                case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
-                    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                        enet_peer_queue_acknowledgement(peer, command, sentTime);
-                    }
-                    break;
-
-                default:
-                    enet_peer_queue_acknowledgement(peer, command, sentTime);
-                    break;
-            }
-        }
-    }
-
-commandError:
-    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-        return 1;
-    }
-
-    return 0;
-} // enet_protocol_handle_incoming_commands
-
-static int enet_protocol_receive_incoming_commands(ENetHost *host, ENetEvent *event) {
-    int packets;
-
-    for (packets = 0; packets < 256; ++packets) {
-        int receivedLength;
-        ENetBuffer buffer;
-
-        buffer.data       = host->packetData [0];
-        buffer.dataLength = sizeof(host->packetData [0]);
-
-        receivedLength = enet_socket_receive(host->socket,
-            &host->receivedAddress,
-            &buffer,
-            1);
-
-        if (receivedLength < 0) {
-            return -1;
-        }
-
-        if (receivedLength == 0) {
-            return 0;
-        }
-
-        host->receivedData       = host->packetData [0];
-        host->receivedDataLength = receivedLength;
-
-        host->totalReceivedData += receivedLength;
-        host->totalReceivedPackets++;
-
-        if (host->intercept != NULL) {
-            switch (host->intercept(host, event)) {
-                case 1:
-                    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                        return 1;
-                    }
-
-                    continue;
-
-                case -1:
-                    return -1;
-
-                default:
-                    break;
-            }
-        }
-
-        switch (enet_protocol_handle_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                return -1;
-
-            default:
-                break;
-        }
-    }
-
-    return -1;
-} // enet_protocol_receive_incoming_commands
-
-static void enet_protocol_send_acknowledgements(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetAcknowledgement *acknowledgement;
-    ENetListIterator currentAcknowledgement;
-    enet_uint16 reliableSequenceNumber;
-
-    currentAcknowledgement = enet_list_begin(&peer->acknowledgements);
-
-    while (currentAcknowledgement != enet_list_end(&peer->acknowledgements)) {
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < sizeof(ENetProtocolAcknowledge))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        acknowledgement = (ENetAcknowledgement *) currentAcknowledgement;
-
-        currentAcknowledgement = enet_list_next(currentAcknowledgement);
-
-        buffer->data       = command;
-        buffer->dataLength = sizeof(ENetProtocolAcknowledge);
-
-        host->packetSize += buffer->dataLength;
-
-        reliableSequenceNumber = ENET_HOST_TO_NET_16(acknowledgement->command.header.reliableSequenceNumber);
-
-        command->header.command   = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
-        command->header.channelID = acknowledgement->command.header.channelID;
-        command->header.reliableSequenceNumber = reliableSequenceNumber;
-        command->acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
-        command->acknowledge.receivedSentTime = ENET_HOST_TO_NET_16(acknowledgement->sentTime);
-
-        if ((acknowledgement->command.header.command & ENET_PROTOCOL_COMMAND_MASK) ==
-          ENET_PROTOCOL_COMMAND_DISCONNECT)
-        {
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        }
-
-        enet_list_remove(&acknowledgement->acknowledgementList);
-        enet_free(acknowledgement);
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-} // enet_protocol_send_acknowledgements
-
-static void enet_protocol_send_unreliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand;
-
-    currentCommand = enet_list_begin(&peer->outgoingUnreliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->outgoingUnreliableCommands)) {
-        size_t commandSize;
-
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-        commandSize     = commandSizes [outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer + 1 >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < commandSize ||
-          (outgoingCommand->packet != NULL &&
-          peer->mtu - host->packetSize < commandSize + outgoingCommand->fragmentLength))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (outgoingCommand->packet != NULL && outgoingCommand->fragmentOffset == 0) {
-            peer->packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
-            peer->packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-
-            if (peer->packetThrottleCounter > peer->packetThrottle) {
-                enet_uint16 reliableSequenceNumber = outgoingCommand->reliableSequenceNumber,
-                  unreliableSequenceNumber         = outgoingCommand->unreliableSequenceNumber;
-                for (;;) {
-                    --outgoingCommand->packet->referenceCount;
-
-                    if (outgoingCommand->packet->referenceCount == 0) {
-                        enet_packet_destroy(outgoingCommand->packet);
-                    }
-
-                    enet_list_remove(&outgoingCommand->outgoingCommandList);
-                    enet_free(outgoingCommand);
-
-                    if (currentCommand == enet_list_end(&peer->outgoingUnreliableCommands)) {
-                        break;
-                    }
-
-                    outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-                    if (outgoingCommand->reliableSequenceNumber != reliableSequenceNumber ||
-                      outgoingCommand->unreliableSequenceNumber != unreliableSequenceNumber)
-                    {
-                        break;
-                    }
-
-                    currentCommand = enet_list_next(currentCommand);
-                }
-
-                continue;
-            }
-        }
-
-        buffer->data       = command;
-        buffer->dataLength = commandSize;
-
-        host->packetSize += buffer->dataLength;
-
-        *command = outgoingCommand->command;
-
-        enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-        if (outgoingCommand->packet != NULL) {
-            ++buffer;
-
-            buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-            buffer->dataLength = outgoingCommand->fragmentLength;
-
-            host->packetSize += buffer->dataLength;
-
-            enet_list_insert(enet_list_end(&peer->sentUnreliableCommands), outgoingCommand);
-        } else {
-            enet_free(outgoingCommand);
-        }
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER &&
-      enet_list_empty(&peer->outgoingReliableCommands) &&
-      enet_list_empty(&peer->outgoingUnreliableCommands) &&
-      enet_list_empty(&peer->sentReliableCommands))
-    {
-        enet_peer_disconnect(peer, peer->eventData);
-    }
-} // enet_protocol_send_unreliable_outgoing_commands
-
-static int enet_protocol_check_timeouts(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand, insertPosition;
-
-    currentCommand = enet_list_begin(&peer->sentReliableCommands);
-    insertPosition = enet_list_begin(&peer->outgoingReliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->sentReliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (ENET_TIME_DIFFERENCE(host->serviceTime, outgoingCommand->sentTime) < outgoingCommand->roundTripTimeout) {
-            continue;
-        }
-
-        if (peer->earliestTimeout == 0 ||
-          ENET_TIME_LESS(outgoingCommand->sentTime, peer->earliestTimeout))
-        {
-            peer->earliestTimeout = outgoingCommand->sentTime;
-        }
-
-        if (peer->earliestTimeout != 0 &&
-          (ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMaximum ||
-          (outgoingCommand->roundTripTimeout >= outgoingCommand->roundTripTimeoutLimit &&
-          ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMinimum)))
-        {
-            enet_protocol_notify_disconnect(host, peer, event);
-
-            return 1;
-        }
-
-        if (outgoingCommand->packet != NULL) {
-            peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-        }
-
-        ++peer->packetsLost;
-
-        outgoingCommand->roundTripTimeout *= 2;
-
-        enet_list_insert(insertPosition, enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-        if (currentCommand == enet_list_begin(&peer->sentReliableCommands) &&
-          !enet_list_empty(&peer->sentReliableCommands))
-        {
-            outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-            peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-        }
-    }
-
-    return 0;
-} // enet_protocol_check_timeouts
-
-static int enet_protocol_send_reliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand;
-    ENetChannel *channel;
-    enet_uint16 reliableWindow;
-    size_t commandSize;
-    int windowExceeded = 0, windowWrap = 0, canPing = 1;
-
-    currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->outgoingReliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        channel = outgoingCommand->command.header.channelID <
-          peer->channelCount ? &peer->channels [outgoingCommand->command.header.channelID] : NULL;
-        reliableWindow = outgoingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        if (channel != NULL) {
-            if (!windowWrap &&
-              outgoingCommand->sendAttempts < 1 &&
-              !(outgoingCommand->reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
-              (channel->reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1)
-              % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
-              channel->usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow)
-              | (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
-            {
-                windowWrap = 1;
-            }
-            if (windowWrap) {
-                currentCommand = enet_list_next(currentCommand);
-
-                continue;
-            }
-        }
-
-        if (outgoingCommand->packet != NULL) {
-            if (!windowExceeded) {
-                enet_uint32 windowSize = (peer->packetThrottle * peer->windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
-
-                if (peer->reliableDataInTransit + outgoingCommand->fragmentLength > ENET_MAX(windowSize, peer->mtu)) {
-                    windowExceeded = 1;
-                }
-            }
-            if (windowExceeded) {
-                currentCommand = enet_list_next(currentCommand);
-
-                continue;
-            }
-        }
-
-        canPing = 0;
-
-        commandSize = commandSizes [outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer + 1 >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < commandSize ||
-          (outgoingCommand->packet != NULL &&
-          (enet_uint16) (peer->mtu - host->packetSize) < (enet_uint16) (commandSize + outgoingCommand->fragmentLength)))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (channel != NULL && outgoingCommand->sendAttempts < 1) {
-            channel->usedReliableWindows |= 1 << reliableWindow;
-            ++channel->reliableWindows [reliableWindow];
-        }
-
-        ++outgoingCommand->sendAttempts;
-
-        if (outgoingCommand->roundTripTimeout == 0) {
-            outgoingCommand->roundTripTimeout      = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
-            outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
-        }
-
-        if (enet_list_empty(&peer->sentReliableCommands)) {
-            peer->nextTimeout = host->serviceTime + outgoingCommand->roundTripTimeout;
-        }
-
-        enet_list_insert(enet_list_end(&peer->sentReliableCommands),
-          enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-        outgoingCommand->sentTime = host->serviceTime;
-
-        buffer->data       = command;
-        buffer->dataLength = commandSize;
-
-        host->packetSize  += buffer->dataLength;
-        host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
-
-        *command = outgoingCommand->command;
-
-        if (outgoingCommand->packet != NULL) {
-            ++buffer;
-
-            buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-            buffer->dataLength = outgoingCommand->fragmentLength;
-
-            host->packetSize += outgoingCommand->fragmentLength;
-
-            peer->reliableDataInTransit += outgoingCommand->fragmentLength;
-        }
-
-        ++peer->packetsSent;
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-
-    return canPing;
-} // enet_protocol_send_reliable_outgoing_commands
-
-static int enet_protocol_send_outgoing_commands(ENetHost *host, ENetEvent *event, int checkForTimeouts) {
-    enet_uint8 headerData [sizeof(ENetProtocolHeader) + sizeof(enet_uint32)];
-    ENetProtocolHeader *header = (ENetProtocolHeader *) headerData;
-    ENetPeer *currentPeer;
-    int sentLength;
-    size_t shouldCompress = 0;
-
-    host->continueSending = 1;
-
-    while (host->continueSending)
-        for (host->continueSending = 0,
-          currentPeer = host->peers;
-          currentPeer < &host->peers [host->peerCount];
-          ++currentPeer)
-        {
-            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED ||
-              currentPeer->state == ENET_PEER_STATE_ZOMBIE)
-            {
-                continue;
-            }
-
-            host->headerFlags  = 0;
-            host->commandCount = 0;
-            host->bufferCount  = 1;
-            host->packetSize   = sizeof(ENetProtocolHeader);
-
-            if (!enet_list_empty(&currentPeer->acknowledgements)) {
-                enet_protocol_send_acknowledgements(host, currentPeer);
-            }
-
-            if (checkForTimeouts != 0 &&
-              !enet_list_empty(&currentPeer->sentReliableCommands) &&
-              ENET_TIME_GREATER_EQUAL(host->serviceTime, currentPeer->nextTimeout) &&
-              enet_protocol_check_timeouts(host, currentPeer, event) == 1)
-            {
-                if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                    return 1;
-                } else {
-                    continue;
-                }
-            }
-
-            if ((enet_list_empty(&currentPeer->outgoingReliableCommands) ||
-              enet_protocol_send_reliable_outgoing_commands(host, currentPeer)) &&
-              enet_list_empty(&currentPeer->sentReliableCommands) &&
-              ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->lastReceiveTime) >= currentPeer->pingInterval &&
-              currentPeer->mtu - host->packetSize >= sizeof(ENetProtocolPing))
-            {
-                enet_peer_ping(currentPeer);
-                enet_protocol_send_reliable_outgoing_commands(host, currentPeer);
-            }
-
-            if (!enet_list_empty(&currentPeer->outgoingUnreliableCommands)) {
-                enet_protocol_send_unreliable_outgoing_commands(host, currentPeer);
-            }
-
-            if (host->commandCount == 0) {
-                continue;
-            }
-
-            if (currentPeer->packetLossEpoch == 0) {
-                currentPeer->packetLossEpoch = host->serviceTime;
-            } else if (ENET_TIME_DIFFERENCE(host->serviceTime,
-              currentPeer->packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL &&
-              currentPeer->packetsSent > 0)
-            {
-                enet_uint32 packetLoss = currentPeer->packetsLost * ENET_PEER_PACKET_LOSS_SCALE
-                  / currentPeer->packetsSent;
-
-                #  ifdef ENET_DEBUG
-                printf(
-                    "peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer->incomingPeerID,
-                    currentPeer->packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE,
-                    currentPeer->packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer->roundTripTime, currentPeer->roundTripTimeVariance,
-                    currentPeer->packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE,
-                    enet_list_size(&currentPeer->outgoingReliableCommands),
-                    enet_list_size(
-                        &currentPeer->outgoingUnreliableCommands),
-                    currentPeer->channels != NULL ? enet_list_size(
-                        &currentPeer->channels->incomingReliableCommands) : 0,
-                    currentPeer->channels !=
-                    NULL ? enet_list_size(&currentPeer->channels->incomingUnreliableCommands) : 0);
-                #  endif
-
-                currentPeer->packetLossVariance -= currentPeer->packetLossVariance / 4;
-
-                if (packetLoss >= currentPeer->packetLoss) {
-                    currentPeer->packetLoss         += (packetLoss - currentPeer->packetLoss) / 8;
-                    currentPeer->packetLossVariance += (packetLoss - currentPeer->packetLoss) / 4;
-                } else {
-                    currentPeer->packetLoss         -= (currentPeer->packetLoss - packetLoss) / 8;
-                    currentPeer->packetLossVariance += (currentPeer->packetLoss - packetLoss) / 4;
-                }
-
-                currentPeer->packetLossEpoch = host->serviceTime;
-                currentPeer->packetsSent     = 0;
-                currentPeer->packetsLost     = 0;
-            }
-
-            host->buffers->data = headerData;
-            if (host->headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) {
-                header->sentTime = ENET_HOST_TO_NET_16(host->serviceTime & 0xFFFF);
-
-                host->buffers->dataLength = sizeof(ENetProtocolHeader);
-            } else {
-                host->buffers->dataLength = (size_t) &((ENetProtocolHeader *) 0)->sentTime;
-            }
-
-            shouldCompress = 0;
-            if (host->compressor.context != NULL && host->compressor.compress != NULL) {
-                size_t originalSize = host->packetSize - sizeof(ENetProtocolHeader),
-                  compressedSize    = host->compressor.compress(host->compressor.context,
-                    &host->buffers [1], host->bufferCount - 1,
-                    originalSize,
-                    host->packetData [1],
-                    originalSize);
-                if (compressedSize > 0 && compressedSize < originalSize) {
-                    host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED;
-                    shouldCompress     = compressedSize;
-                    #  ifdef ENET_DEBUG_COMPRESS
-                    printf("peer %u: compressed %u -> %u (%u%%)\n", currentPeer->incomingPeerID, originalSize,
-                      compressedSize, (compressedSize * 100) / originalSize);
-                    #  endif
-                }
-            }
-
-            if (currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID) {
-                host->headerFlags |= currentPeer->outgoingSessionID << ENET_PROTOCOL_HEADER_SESSION_SHIFT;
-            }
-            header->peerID = ENET_HOST_TO_NET_16(currentPeer->outgoingPeerID | host->headerFlags);
-            if (host->checksum != NULL) {
-                enet_uint32 *checksum = (enet_uint32 *) &headerData [host->buffers->dataLength];
-                *checksum = currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer->connectID : 0;
-                host->buffers->dataLength += sizeof(enet_uint32);
-                *checksum = host->checksum(host->buffers, host->bufferCount);
-            }
-
-            if (shouldCompress > 0) {
-                host->buffers [1].data       = host->packetData [1];
-                host->buffers [1].dataLength = shouldCompress;
-                host->bufferCount = 2;
-            }
-
-            currentPeer->lastSendTime = host->serviceTime;
-
-            sentLength = enet_socket_send(host->socket, &currentPeer->address, host->buffers, host->bufferCount);
-
-            enet_protocol_remove_sent_unreliable_commands(currentPeer);
-
-            if (sentLength < 0) {
-                return -1;
-            }
-
-            host->totalSentData += sentLength;
-            host->totalSentPackets++;
-        }
-
-    return 0;
-} // enet_protocol_send_outgoing_commands
-
-/** Sends any queued packets on the host specified to its designated peers.
- *
- *  @param host   host to flush
- *  @remarks this function need only be used in circumstances where one wishes to send queued packets earlier than in a call to enet_host_service().
- *  @ingroup host
- */
-void enet_host_flush(ENetHost *host) {
-    host->serviceTime = enet_time_get();
-
-    enet_protocol_send_outgoing_commands(host, NULL, 0);
-}
-
-/** Checks for any queued events on the host and dispatches one if available.
- *
- *  @param host    host to check for events
- *  @param event   an event structure where event details will be placed if available
- *  @retval > 0 if an event was dispatched
- *  @retval 0 if no events are available
- *  @retval < 0 on failure
- *  @ingroup host
- */
-int enet_host_check_events(ENetHost *host, ENetEvent *event) {
-    if (event == NULL) { return -1; }
-
-    event->type   = ENET_EVENT_TYPE_NONE;
-    event->peer   = NULL;
-    event->packet = NULL;
-
-    return enet_protocol_dispatch_incoming_commands(host, event);
-}
-
-/** Waits for events on the host specified and shuttles packets between
- *  the host and its peers.
- *
- *  @param host    host to service
- *  @param event   an event structure where event details will be placed if one occurs
- *                 if event == NULL then no events will be delivered
- *  @param timeout number of milliseconds that ENet should wait for events
- *  @retval > 0 if an event occurred within the specified time limit
- *  @retval 0 if no event occurred
- *  @retval < 0 on failure
- *  @remarks enet_host_service should be called fairly regularly for adequate performance
- *  @ingroup host
- */
-int enet_host_service(ENetHost *host, ENetEvent *event, enet_uint32 timeout) {
-    enet_uint32 waitCondition;
-
-    if (event != NULL) {
-        event->type   = ENET_EVENT_TYPE_NONE;
-        event->peer   = NULL;
-        event->packet = NULL;
-
-        switch (enet_protocol_dispatch_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #  ifdef ENET_DEBUG
-                perror("Error dispatching incoming packets");
-                #  endif
-
-                return -1;
-
-            default:
-                break;
-        }
-    }
-
-    host->serviceTime = enet_time_get();
-
-    timeout += host->serviceTime;
-
-    do {
-        if (ENET_TIME_DIFFERENCE(host->serviceTime,
-          host->bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
-        {
-            enet_host_bandwidth_throttle(host);
-        }
-
-        switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #  ifdef ENET_DEBUG
-                perror("Error sending outgoing packets");
-                #  endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        switch (enet_protocol_receive_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #  ifdef ENET_DEBUG
-                perror("Error receiving incoming packets");
-                #  endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #  ifdef ENET_DEBUG
-                perror("Error sending outgoing packets");
-                #  endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        if (event != NULL) {
-            switch (enet_protocol_dispatch_incoming_commands(host, 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(host->serviceTime, timeout)) {
-            return 0;
-        }
-
-        do {
-            host->serviceTime = enet_time_get();
-
-            if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
-                return 0;
-            }
-
-            waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
-
-            if (enet_socket_wait(host->socket, &waitCondition, ENET_TIME_DIFFERENCE(timeout, host->serviceTime)) != 0) {
-                return -1;
-            }
-        } while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
-
-        host->serviceTime = enet_time_get();
-    } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
-
-    return 0;
-} // enet_host_service
-
-// @from_file: src/unix.c
-
-/**
- * @file  unix.c
- * @brief ENet Unix system specific functions
- */
-#  ifndef _WIN32
-
-
-#   include <sys/ioctl.h>
-
-#   include <arpa/inet.h>
-#   include <netinet/tcp.h>
-#   include <netdb.h>
-
-
-#   include <errno.h>
-#   include <time.h>
-
-#   define ENET_BUILDING_LIB 1
-
-
-#   ifdef __APPLE__
-#    ifdef HAS_POLL
-#     undef HAS_POLL
-#    endif
-#    ifndef HAS_FCNTL
-#     define HAS_FCNTL 1
-#    endif
-#    ifndef HAS_INET_PTON
-#     define HAS_INET_PTON 1
-#    endif
-#    ifndef HAS_INET_NTOP
-#     define HAS_INET_NTOP 1
-#    endif
-#    ifndef HAS_MSGHDR_FLAGS
-#     define HAS_MSGHDR_FLAGS 1
-#    endif
-#    ifndef HAS_SOCKLEN_T
-#     define HAS_SOCKLEN_T 1
-#    endif
-#    ifndef HAS_GETADDRINFO
-#     define HAS_GETADDRINFO 1
-#    endif
-#    ifndef HAS_GETNAMEINFO
-#     define HAS_GETNAMEINFO 1
-#    endif
-#   endif // ifdef __APPLE__
-
-#   ifdef HAS_FCNTL
-#    include <fcntl.h>
-#   endif
-
-#   ifdef HAS_POLL
-#    include <sys/poll.h>
-#   endif
-
-#   ifndef HAS_SOCKLEN_T
-typedef int socklen_t;
-#   endif
-
-#   ifndef MSG_NOSIGNAL
-#    define MSG_NOSIGNAL 0
-#   endif
-
-static enet_uint64 timeBase = 0;
-
-int enet_initialize(void) {
-    return 0;
-}
-
-void enet_deinitialize(void)
-{ }
-
-enet_uint64 enet_host_random_seed(void) {
-    return (enet_uint64) time(NULL);
-}
-
-enet_uint64 enet_time_get(void) {
-    struct timeval timeVal;
-
-    gettimeofday(&timeVal, NULL);
-
-    return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
-}
-
-void enet_time_set(enet_uint64 newTimeBase) {
-    struct timeval timeVal;
-
-    gettimeofday(&timeVal, NULL);
-
-    timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
-}
-
-int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-    #   ifdef HAS_INET_PTON
-    if (!inet_pton(AF_INET, name, &address->host))
-    #   else
-    if (!inet_aton(name, (struct in_addr *) &address->host))
-    #   endif
-    { return -1; }
-
-    return 0;
-}
-
-int enet_address_set_host(ENetAddress *address, const char *name) {
-    #   ifdef HAS_GETADDRINFO
-    struct addrinfo hints, *resultList = NULL, *result = NULL;
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET;
-
-    if (getaddrinfo(name, NULL, NULL, &resultList) != 0) {
-        return -1;
-    }
-
-    for (result = resultList; result != NULL; result = result->ai_next) {
-        if (result->ai_family == AF_INET && result->ai_addr != NULL &&
-          result->ai_addrlen >= sizeof(struct sockaddr_in))
-        {
-            struct sockaddr_in *sin = (struct sockaddr_in *) result->ai_addr;
-
-            address->host = sin->sin_addr.s_addr;
-
-            freeaddrinfo(resultList);
-
-            return 0;
-        }
-    }
-
-    if (resultList != NULL) {
-        freeaddrinfo(resultList);
-    }
-    #   else // ifdef HAS_GETADDRINFO
-    struct hostent *hostEntry = NULL;
-    #    ifdef HAS_GETHOSTBYNAME_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    #     if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
-    #     else
-    hostEntry = gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &errnum);
-    #     endif
-    #    else
-    hostEntry = gethostbyname(name);
-    #    endif // ifdef HAS_GETHOSTBYNAME_R
-
-    if (hostEntry != NULL && hostEntry->h_addrtype == AF_INET) {
-        address->host = *(enet_uint32 *) hostEntry->h_addr_list [0];
-
-        return 0;
-    }
-    #   endif // ifdef HAS_GETADDRINFO
-
-    return enet_address_set_host_ip(address, name);
-} // enet_address_set_host
-
-int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-    #   ifdef HAS_INET_NTOP
-    if (inet_ntop(AF_INET, &address->host, name, nameLength) == NULL)
-    #   else
-    char *addr = inet_ntoa(*(struct in_addr *) &address->host);
-    if (addr != NULL) {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, addr, addrLen + 1);
-    } else
-    #   endif
-    { return -1; }
-    return 0;
-}
-
-int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-    #   ifdef HAS_GETNAMEINFO
-    struct sockaddr_in sin;
-    int err;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    err = getnameinfo((struct sockaddr *) &sin, sizeof(sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-    if (!err) {
-        if (name != NULL && nameLength > 0 && !memchr(name, '\0', nameLength)) {
-            return -1;
-        }
-        return 0;
-    }
-    if (err != EAI_NONAME) {
-        return -1;
-    }
-    #   else // ifdef HAS_GETNAMEINFO
-    struct in_addr in;
-    struct hostent *hostEntry = NULL;
-    #    ifdef HAS_GETHOSTBYADDR_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    in.s_addr = address->host;
-
-    #     if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyaddr_r((char *) &in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &hostEntry,
-      &errnum);
-    #     else
-    hostEntry = gethostbyaddr_r((char *) &in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer),
-        &errnum);
-    #     endif
-    #    else // ifdef HAS_GETHOSTBYADDR_R
-    in.s_addr = address->host;
-
-    hostEntry = gethostbyaddr((char *) &in, sizeof(struct in_addr), AF_INET);
-    #    endif // ifdef HAS_GETHOSTBYADDR_R
-
-    if (hostEntry != NULL) {
-        size_t hostLen = strlen(hostEntry->h_name);
-        if (hostLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, hostEntry->h_name, hostLen + 1);
-        return 0;
-    }
-    #   endif // ifdef HAS_GETNAMEINFO
-
-    return enet_address_get_host_ip(address, name, nameLength);
-} // enet_address_get_host
-
-int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL) {
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    } else {
-        sin.sin_port        = 0;
-        sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind(socket,
-             (struct sockaddr *) &sin,
-             sizeof(struct sockaddr_in));
-}
-
-int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof(struct sockaddr_in);
-
-    if (getsockname(socket, (struct sockaddr *) &sin, &sinLength) == -1) {
-        return -1;
-    }
-
-    address->host = (enet_uint32) sin.sin_addr.s_addr;
-    address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-
-    return 0;
-}
-
-int enet_socket_listen(ENetSocket socket, int backlog) {
-    return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
-}
-
-ENetSocket enet_socket_create(ENetSocketType type) {
-    return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-    int result = -1;
-
-    switch (option) {
-        case ENET_SOCKOPT_NONBLOCK:
-            #   ifdef HAS_FCNTL
-            result = fcntl(socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl(socket, F_GETFL) & ~O_NONBLOCK));
-            #   else
-            result = ioctl(socket, FIONBIO, &value);
-            #   endif
-            break;
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO: {
-            struct timeval timeVal;
-            timeVal.tv_sec  = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeVal, sizeof(struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_SNDTIMEO: {
-            struct timeval timeVal;
-            timeVal.tv_sec  = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeVal, sizeof(struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *) &value, sizeof(int));
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-} // enet_socket_set_option
-
-int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-    int result = -1;
-    socklen_t len;
-
-    switch (option) {
-        case ENET_SOCKOPT_ERROR:
-            len    = sizeof(int);
-            result = getsockopt(socket, SOL_SOCKET, SO_ERROR, value, &len);
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-    int result;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    result = connect(socket, (struct sockaddr *) &sin, sizeof(struct sockaddr_in));
-    if (result == -1 && errno == EINPROGRESS) {
-        return 0;
-    }
-
-    return result;
-}
-
-ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-    int result;
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof(struct sockaddr_in);
-
-    result = accept(socket,
-        address != NULL ? (struct sockaddr *) &sin : NULL,
-        address != NULL ? &sinLength : NULL);
-
-    if (result == -1) {
-        return ENET_SOCKET_NULL;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return result;
-}
-
-int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-    return shutdown(socket, (int) how);
-}
-
-void enet_socket_destroy(ENetSocket socket) {
-    if (socket != -1) {
-        close(socket);
-    }
-}
-
-int enet_socket_send(ENetSocket socket,
-  const ENetAddress *           address,
-  const ENetBuffer *            buffers,
-  size_t                        bufferCount) {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int sentLength;
-
-    memset(&msgHdr, 0, sizeof(struct msghdr));
-
-    if (address != NULL) {
-        memset(&sin, 0, sizeof(struct sockaddr_in));
-
-        sin.sin_family      = AF_INET;
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-
-        msgHdr.msg_name    = &sin;
-        msgHdr.msg_namelen = sizeof(struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov    = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-    if (sentLength == -1) {
-        if (errno == EWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    return sentLength;
-} // enet_socket_send
-
-int enet_socket_receive(ENetSocket socket,
-  ENetAddress *                    address,
-  ENetBuffer *                     buffers,
-  size_t                           bufferCount) {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int recvLength;
-
-    memset(&msgHdr, 0, sizeof(struct msghdr));
-
-    if (address != NULL) {
-        msgHdr.msg_name    = &sin;
-        msgHdr.msg_namelen = sizeof(struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov    = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-    if (recvLength == -1) {
-        if (errno == EWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    #   ifdef HAS_MSGHDR_FLAGS
-    if (msgHdr.msg_flags & MSG_TRUNC) {
-        return -1;
-    }
-    #   endif
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return recvLength;
-} // enet_socket_receive
-
-int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-    struct timeval timeVal;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-}
-
-int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-    #   ifdef HAS_POLL
-    struct pollfd pollSocket;
-    int pollCount;
-
-    pollSocket.fd     = socket;
-    pollSocket.events = 0;
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        pollSocket.events |= POLLOUT;
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        pollSocket.events |= POLLIN;
-    }
-
-    pollCount = poll(&pollSocket, 1, timeout);
-
-    if (pollCount < 0) {
-        if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
-            *condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (pollCount == 0) {
-        return 0;
-    }
-
-    if (pollSocket.revents & POLLOUT) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (pollSocket.revents & POLLIN) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-
-    #   else // ifdef HAS_POLL
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO(&readSet);
-    FD_ZERO(&writeSet);
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        FD_SET(socket, &writeSet);
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        FD_SET(socket, &readSet);
-    }
-
-    selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
-
-    if (selectCount < 0) {
-        if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
-            *condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0) {
-        return 0;
-    }
-
-    if (FD_ISSET(socket, &writeSet)) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (FD_ISSET(socket, &readSet)) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-
-    #   endif // ifdef HAS_POLL
-} // enet_socket_wait
-
-#  endif // ifndef _WIN32
-
-// @from_file: src/win32.c
-
-/**
- * @file  win32.c
- * @brief ENet Win32 system specific functions
- */
-#  ifdef _WIN32
-
-#   define ENET_BUILDING_LIB 1
-
-#   include <windows.h>
-#   include <mmsystem.h>
-
-static enet_uint64 timeBase = 0;
-
-int enet_initialize(void) {
-    WORD versionRequested = MAKEWORD(1, 1);
-    WSADATA wsaData;
-
-    if (WSAStartup(versionRequested, &wsaData)) {
-        return -1;
-    }
-
-    if (LOBYTE(wsaData.wVersion) != 1 ||
-      HIBYTE(wsaData.wVersion) != 1)
-    {
-        WSACleanup();
-
-        return -1;
-    }
-
-    timeBeginPeriod(1);
-
-    return 0;
-}
-
-void enet_deinitialize(void) {
-    timeEndPeriod(1);
-
-    WSACleanup();
-}
-
-enet_uint64 enet_host_random_seed(void) {
-    return (enet_uint64) timeGetTime();
-}
-
-enet_uint64 enet_time_get(void) {
-    return (enet_uint64) timeGetTime() - timeBase;
-}
-
-void enet_time_set(enet_uint64 newTimeBase) {
-    timeBase = (enet_uint64) timeGetTime() - newTimeBase;
-}
-
-int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-    enet_uint8 vals [4] = { 0, 0, 0, 0 };
-    int i;
-
-    for (i = 0; i < 4; ++i) {
-        const char *next = name + 1;
-        if (*name != '0') {
-            long val = strtol(name, (char **) &next, 10);
-            if (val < 0 || val > 255 || next == name || next - name > 3) {
-                return -1;
-            }
-            vals [i] = (enet_uint8) val;
-        }
-
-        if (*next != (i < 3 ? '.' : '\0')) {
-            return -1;
-        }
-        name = next + 1;
-    }
-
-    memcpy(&address->host, vals, sizeof(enet_uint32));
-    return 0;
-}
-
-int enet_address_set_host(ENetAddress *address, const char *name) {
-    struct hostent *hostEntry;
-
-    hostEntry = gethostbyname(name);
-    if (hostEntry == NULL ||
-      hostEntry->h_addrtype != AF_INET)
-    {
-        return enet_address_set_host_ip(address, name);
-    }
-
-    address->host = *(enet_uint32 *) hostEntry->h_addr_list [0];
-
-    return 0;
-}
-
-int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-    char *addr = inet_ntoa(*(struct in_addr *) &address->host);
-
-    if (addr == NULL) {
-        return -1;
-    } else {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, addr, addrLen + 1);
-    }
-    return 0;
-}
-
-int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-    struct in_addr in;
-    struct hostent *hostEntry;
-
-    in.s_addr = address->host;
-
-    hostEntry = gethostbyaddr((char *) &in, sizeof(struct in_addr), AF_INET);
-    if (hostEntry == NULL) {
-        return enet_address_get_host_ip(address, name, nameLength);
-    } else {
-        size_t hostLen = strlen(hostEntry->h_name);
-        if (hostLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, hostEntry->h_name, hostLen + 1);
-    }
-
-    return 0;
-}
-
-int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL) {
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    } else {
-        sin.sin_port        = 0;
-        sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind(socket,
-             (struct sockaddr *) &sin,
-             sizeof(struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
-}
-
-int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-    struct sockaddr_in sin;
-    int sinLength = sizeof(struct sockaddr_in);
-
-    if (getsockname(socket, (struct sockaddr *) &sin, &sinLength) == -1) {
-        return -1;
-    }
-
-    address->host = (enet_uint32) sin.sin_addr.s_addr;
-    address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-
-    return 0;
-}
-
-int enet_socket_listen(ENetSocket socket, int backlog) {
-    return listen(socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
-}
-
-ENetSocket enet_socket_create(ENetSocketType type) {
-    return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-    int result = SOCKET_ERROR;
-
-    switch (option) {
-        case ENET_SOCKOPT_NONBLOCK: {
-            u_long nonBlocking = (u_long) value;
-            result = ioctlsocket(socket, FIONBIO, &nonBlocking);
-            break;
-        }
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDTIMEO:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *) &value, sizeof(int));
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-} // enet_socket_set_option
-
-int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-    int result = SOCKET_ERROR, len;
-
-    switch (option) {
-        case ENET_SOCKOPT_ERROR:
-            len    = sizeof(int);
-            result = getsockopt(socket, SOL_SOCKET, SO_ERROR, (char *) value, &len);
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-    int result;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    result = connect(socket, (struct sockaddr *) &sin, sizeof(struct sockaddr_in));
-    if (result == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) {
-        return -1;
-    }
-
-    return 0;
-}
-
-ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-    SOCKET result;
-    struct sockaddr_in sin;
-    int sinLength = sizeof(struct sockaddr_in);
-
-    result = accept(socket,
-        address != NULL ? (struct sockaddr *) &sin : NULL,
-        address != NULL ? &sinLength : NULL);
-
-    if (result == INVALID_SOCKET) {
-        return ENET_SOCKET_NULL;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return result;
-}
-
-int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-    return shutdown(socket, (int) how) == SOCKET_ERROR ? -1 : 0;
-}
-
-void enet_socket_destroy(ENetSocket socket) {
-    if (socket != INVALID_SOCKET) {
-        closesocket(socket);
-    }
-}
-
-int enet_socket_send(ENetSocket socket,
-  const ENetAddress *           address,
-  const ENetBuffer *            buffers,
-  size_t                        bufferCount) {
-    struct sockaddr_in sin;
-    DWORD sentLength;
-
-    if (address != NULL) {
-        memset(&sin, 0, sizeof(struct sockaddr_in));
-
-        sin.sin_family      = AF_INET;
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    }
-
-    if (WSASendTo(socket,
-      (LPWSABUF) buffers,
-      (DWORD) bufferCount,
-      &sentLength,
-      0,
-      address != NULL ? (struct sockaddr *) &sin : NULL,
-      address != NULL ? sizeof(struct sockaddr_in) : 0,
-      NULL,
-      NULL) == SOCKET_ERROR)
-    {
-        if (WSAGetLastError() == WSAEWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    return (int) sentLength;
-}
-
-int enet_socket_receive(ENetSocket socket,
-  ENetAddress *                    address,
-  ENetBuffer *                     buffers,
-  size_t                           bufferCount) {
-    INT sinLength = sizeof(struct sockaddr_in);
-    DWORD flags   = 0,
-      recvLength;
-    struct sockaddr_in sin;
-
-    if (WSARecvFrom(socket,
-      (LPWSABUF) buffers,
-      (DWORD) bufferCount,
-      &recvLength,
-      &flags,
-      address != NULL ? (struct sockaddr *) &sin : NULL,
-      address != NULL ? &sinLength : NULL,
-      NULL,
-      NULL) == SOCKET_ERROR)
-    {
-        switch (WSAGetLastError()) {
-            case WSAEWOULDBLOCK:
-            case WSAECONNRESET:
-                return 0;
-        }
-
-        return -1;
-    }
-
-    if (flags & MSG_PARTIAL) {
-        return -1;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return (int) recvLength;
-} // enet_socket_receive
-
-int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-    struct timeval timeVal;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-}
-
-int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO(&readSet);
-    FD_ZERO(&writeSet);
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        FD_SET(socket, &writeSet);
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        FD_SET(socket, &readSet);
-    }
-
-    selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
-
-    if (selectCount < 0) {
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0) {
-        return 0;
-    }
-
-    if (FD_ISSET(socket, &writeSet)) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (FD_ISSET(socket, &readSet)) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-} // enet_socket_wait
-
-#  endif // ifdef _WIN32
-#  ifdef __cplusplus
-}
-#  endif
-
-# endif // if defined(ENET_IMPLEMENTATION) && !defined(ENET_IMPLEMENTATION_DONE)
-
-#endif /* __ENET_ENET_H__ */

include/enet/callbacks.h

@@ -1,27 +0,0 @@
-/** 
- @file  callbacks.h
- @brief ENet callbacks
-*/
-#ifndef __ENET_CALLBACKS_H__
-#define __ENET_CALLBACKS_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetCallbacks
-{
-    void * (ENET_CALLBACK * malloc) (size_t size);
-    void (ENET_CALLBACK * free) (void * memory);
-    void (ENET_CALLBACK * no_memory) (void);
-} ENetCallbacks;
-
-/** @defgroup callbacks ENet internal callbacks
-    @{
-    @ingroup private
-*/
-extern void * enet_malloc (size_t);
-extern void   enet_free (void *);
-
-/** @} */
-
-#endif /* __ENET_CALLBACKS_H__ */
-

include/enet/enet.h

@@ -1,610 +0,0 @@
-/** 
- @file  enet.h
- @brief ENet public header file
-*/
-#ifndef __ENET_ENET_H__
-#define __ENET_ENET_H__
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include "enet/win32.h"
-#else
-#include "enet/unix.h"
-#endif
-
-#include "enet/types.h"
-#include "enet/protocol.h"
-#include "enet/list.h"
-#include "enet/time.h"
-#include "enet/utility.h"
-#include "enet/callbacks.h"
-
-#define ENET_VERSION_MAJOR 1
-#define ENET_VERSION_MINOR 4
-#define ENET_VERSION_PATCH 4
-#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
-#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
-#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
-#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
-#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-typedef enet_uint32 ENetVersion;
-
-struct _ENetHost;
-struct _ENetEvent;
-struct _ENetPacket;
-
-typedef enum _ENetSocketType
-{
-   ENET_SOCKET_TYPE_STREAM   = 1,
-   ENET_SOCKET_TYPE_DATAGRAM = 2
-} ENetSocketType;
-
-typedef enum _ENetSocketWait
-{
-   ENET_SOCKET_WAIT_NONE      = 0,
-   ENET_SOCKET_WAIT_SEND      = (1 << 0),
-   ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-   ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-} ENetSocketWait;
-
-typedef enum _ENetSocketOption
-{
-   ENET_SOCKOPT_NONBLOCK  = 1,
-   ENET_SOCKOPT_BROADCAST = 2,
-   ENET_SOCKOPT_RCVBUF    = 3,
-   ENET_SOCKOPT_SNDBUF    = 4,
-   ENET_SOCKOPT_REUSEADDR = 5,
-   ENET_SOCKOPT_RCVTIMEO  = 6,
-   ENET_SOCKOPT_SNDTIMEO  = 7,
-   ENET_SOCKOPT_ERROR     = 8,
-   ENET_SOCKOPT_NODELAY   = 9
-} ENetSocketOption;
-
-typedef enum _ENetSocketShutdown
-{
-    ENET_SOCKET_SHUTDOWN_READ       = 0,
-    ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-} ENetSocketShutdown;
-
-#define ENET_HOST_ANY       0
-#define ENET_HOST_BROADCAST 0xFFFFFFFFU
-#define ENET_PORT_ANY       0
-
-/**
- * Portable internet address structure. 
- *
- * The host must be specified in network byte-order, and the port must be in host 
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default 
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
- */
-typedef struct _ENetAddress
-{
-   enet_uint32 host;
-   enet_uint16 port;
-} ENetAddress;
-
-/**
- * Packet flag bit constants.
- *
- * The host must be specified in network byte-order, and the port must be in
- * host byte-order. The constant ENET_HOST_ANY may be used to specify the
- * default server host.
- 
-   @sa ENetPacket
-*/
-typedef enum _ENetPacketFlag
-{
-   /** packet must be received by the target peer and resend attempts should be
-     * made until the packet is delivered */
-   ENET_PACKET_FLAG_RELIABLE    = (1 << 0),
-   /** packet will not be sequenced with other packets
-     * not supported for reliable packets
-     */
-   ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
-   /** packet will not allocate data, and user must supply it instead */
-   ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
-   /** packet will be fragmented using unreliable (instead of reliable) sends
-     * if it exceeds the MTU */
-   ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-
-   /** whether the packet has been sent from all queues it has been entered into */
-   ENET_PACKET_FLAG_SENT = (1<<8)
-} ENetPacketFlag;
-
-typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
-
-/**
- * ENet packet structure.
- *
- * An ENet data packet that may be sent to or received from a peer. The shown 
- * fields should only be read and never modified. The data field contains the 
- * allocated data for the packet. The dataLength fields specifies the length 
- * of the allocated data.  The flags field is either 0 (specifying no flags), 
- * or a bitwise-or of any combination of the following flags:
- *
- *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
- *    and resend attempts should be made until the packet is delivered
- *
- *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 
- *    (not supported for reliable packets)
- *
- *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
- *
- *    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable
- *    (instead of reliable) sends if it exceeds the MTU
- *
- *    ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into
-   @sa ENetPacketFlag
- */
-typedef struct _ENetPacket
-{
-   size_t                   referenceCount;  /**< internal use only */
-   enet_uint32              flags;           /**< bitwise-or of ENetPacketFlag constants */
-   enet_uint8 *             data;            /**< allocated data for packet */
-   size_t                   dataLength;      /**< length of data */
-   ENetPacketFreeCallback   freeCallback;    /**< function to be called when the packet is no longer in use */
-   void *                   userData;        /**< application private data, may be freely modified */
-} ENetPacket;
-
-typedef struct _ENetAcknowledgement
-{
-   ENetListNode acknowledgementList;
-   enet_uint32  sentTime;
-   ENetProtocol command;
-} ENetAcknowledgement;
-
-typedef struct _ENetOutgoingCommand
-{
-   ENetListNode outgoingCommandList;
-   enet_uint16  reliableSequenceNumber;
-   enet_uint16  unreliableSequenceNumber;
-   enet_uint32  sentTime;
-   enet_uint32  roundTripTimeout;
-   enet_uint32  roundTripTimeoutLimit;
-   enet_uint32  fragmentOffset;
-   enet_uint16  fragmentLength;
-   enet_uint16  sendAttempts;
-   ENetProtocol command;
-   ENetPacket * packet;
-} ENetOutgoingCommand;
-
-typedef struct _ENetIncomingCommand
-{  
-   ENetListNode     incomingCommandList;
-   enet_uint16      reliableSequenceNumber;
-   enet_uint16      unreliableSequenceNumber;
-   ENetProtocol     command;
-   enet_uint32      fragmentCount;
-   enet_uint32      fragmentsRemaining;
-   enet_uint32 *    fragments;
-   ENetPacket *     packet;
-} ENetIncomingCommand;
-
-typedef enum _ENetPeerState
-{
-   ENET_PEER_STATE_DISCONNECTED                = 0,
-   ENET_PEER_STATE_CONNECTING                  = 1,
-   ENET_PEER_STATE_ACKNOWLEDGING_CONNECT       = 2,
-   ENET_PEER_STATE_CONNECTION_PENDING          = 3,
-   ENET_PEER_STATE_CONNECTION_SUCCEEDED        = 4,
-   ENET_PEER_STATE_CONNECTED                   = 5,
-   ENET_PEER_STATE_DISCONNECT_LATER            = 6,
-   ENET_PEER_STATE_DISCONNECTING               = 7,
-   ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT    = 8,
-   ENET_PEER_STATE_ZOMBIE                      = 9 
-} ENetPeerState;
-
-#ifndef ENET_BUFFER_MAXIMUM
-#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-#endif
-
-enum
-{
-   ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-   ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-   ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-   ENET_HOST_DEFAULT_MTU                  = 1400,
-   ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-   ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-
-   ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-   ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-   ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-   ENET_PEER_PACKET_THROTTLE_COUNTER      = 7, 
-   ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-   ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-   ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-   ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-   ENET_PEER_TIMEOUT_LIMIT                = 32,
-   ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-   ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-   ENET_PEER_PING_INTERVAL                = 500,
-   ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-   ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-   ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-   ENET_PEER_RELIABLE_WINDOWS             = 16,
-   ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-   ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-};
-
-typedef struct _ENetChannel
-{
-   enet_uint16  outgoingReliableSequenceNumber;
-   enet_uint16  outgoingUnreliableSequenceNumber;
-   enet_uint16  usedReliableWindows;
-   enet_uint16  reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
-   enet_uint16  incomingReliableSequenceNumber;
-   enet_uint16  incomingUnreliableSequenceNumber;
-   ENetList     incomingReliableCommands;
-   ENetList     incomingUnreliableCommands;
-} ENetChannel;
-
-/**
- * An ENet peer which data packets may be sent or received from. 
- *
- * No fields should be modified unless otherwise specified. 
- */
-typedef struct _ENetPeer
-{ 
-   ENetListNode  dispatchList;
-   struct _ENetHost * host;
-   enet_uint16   outgoingPeerID;
-   enet_uint16   incomingPeerID;
-   enet_uint32   connectID;
-   enet_uint8    outgoingSessionID;
-   enet_uint8    incomingSessionID;
-   ENetAddress   address;            /**< Internet address of the peer */
-   void *        data;               /**< Application private data, may be freely modified */
-   ENetPeerState state;
-   ENetChannel * channels;
-   size_t        channelCount;       /**< Number of channels allocated for communication with peer */
-   enet_uint32   incomingBandwidth;  /**< Downstream bandwidth of the client in bytes/second */
-   enet_uint32   outgoingBandwidth;  /**< Upstream bandwidth of the client in bytes/second */
-   enet_uint32   incomingBandwidthThrottleEpoch;
-   enet_uint32   outgoingBandwidthThrottleEpoch;
-   enet_uint32   incomingDataTotal;
-   enet_uint32   outgoingDataTotal;
-   enet_uint32   lastSendTime;
-   enet_uint32   lastReceiveTime;
-   enet_uint32   nextTimeout;
-   enet_uint32   earliestTimeout;
-   enet_uint32   packetLossEpoch;
-   enet_uint32   packetsSent;
-   enet_uint32   packetsLost;
-   enet_uint32   packetLoss;          /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
-   enet_uint32   packetLossVariance;
-   enet_uint32   packetThrottle;
-   enet_uint32   packetThrottleLimit;
-   enet_uint32   packetThrottleCounter;
-   enet_uint32   packetThrottleEpoch;
-   enet_uint32   packetThrottleAcceleration;
-   enet_uint32   packetThrottleDeceleration;
-   enet_uint32   packetThrottleInterval;
-   enet_uint32   pingInterval;
-   enet_uint32   timeoutLimit;
-   enet_uint32   timeoutMinimum;
-   enet_uint32   timeoutMaximum;
-   enet_uint32   lastRoundTripTime;
-   enet_uint32   lowestRoundTripTime;
-   enet_uint32   lastRoundTripTimeVariance;
-   enet_uint32   highestRoundTripTimeVariance;
-   enet_uint32   roundTripTime;            /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
-   enet_uint32   roundTripTimeVariance;
-   enet_uint32   mtu;
-   enet_uint32   windowSize;
-   enet_uint32   reliableDataInTransit;
-   enet_uint16   outgoingReliableSequenceNumber;
-   ENetList      acknowledgements;
-   ENetList      sentReliableCommands;
-   ENetList      sentUnreliableCommands;
-   ENetList      outgoingReliableCommands;
-   ENetList      outgoingUnreliableCommands;
-   ENetList      dispatchedCommands;
-   int           needsDispatch;
-   enet_uint16   incomingUnsequencedGroup;
-   enet_uint16   outgoingUnsequencedGroup;
-   enet_uint32   unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 
-   enet_uint32   eventData;
-   size_t        totalWaitingData;
-} ENetPeer;
-
-/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
- */
-typedef struct _ENetCompressor
-{
-   /** Context data for the compressor. Must be non-NULL. */
-   void * context;
-   /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
-   void (ENET_CALLBACK * destroy) (void * context);
-} ENetCompressor;
-
-/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
-typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
-
-/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
-typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
- 
-/** An ENet host for communicating with peers.
-  *
-  * No fields should be modified unless otherwise stated.
-
-    @sa enet_host_create()
-    @sa enet_host_destroy()
-    @sa enet_host_connect()
-    @sa enet_host_service()
-    @sa enet_host_flush()
-    @sa enet_host_broadcast()
-    @sa enet_host_compress()
-    @sa enet_host_compress_with_range_coder()
-    @sa enet_host_channel_limit()
-    @sa enet_host_bandwidth_limit()
-    @sa enet_host_bandwidth_throttle()
-  */
-typedef struct _ENetHost
-{
-   ENetSocket           socket;
-   ENetAddress          address;                     /**< Internet address of the host */
-   enet_uint32          incomingBandwidth;           /**< downstream bandwidth of the host */
-   enet_uint32          outgoingBandwidth;           /**< upstream bandwidth of the host */
-   enet_uint32          bandwidthThrottleEpoch;
-   enet_uint32          mtu;
-   enet_uint32          randomSeed;
-   int                  recalculateBandwidthLimits;
-   ENetPeer *           peers;                       /**< array of peers allocated for this host */
-   size_t               peerCount;                   /**< number of peers allocated for this host */
-   size_t               channelLimit;                /**< maximum number of channels allowed for connected peers */
-   enet_uint32          serviceTime;
-   ENetList             dispatchQueue;
-   int                  continueSending;
-   size_t               packetSize;
-   enet_uint16          headerFlags;
-   ENetProtocol         commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-   size_t               commandCount;
-   ENetBuffer           buffers [ENET_BUFFER_MAXIMUM];
-   size_t               bufferCount;
-   ENetChecksumCallback checksum;                    /**< callback the user can set to enable packet checksums for this host */
-   ENetCompressor       compressor;
-   enet_uint8           packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
-   ENetAddress          receivedAddress;
-   enet_uint8 *         receivedData;
-   size_t               receivedDataLength;
-   enet_uint32          totalSentData;               /**< total data sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalSentPackets;            /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedData;           /**< total data received, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedPackets;        /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
-   ENetInterceptCallback intercept;                  /**< callback the user can set to intercept received raw UDP packets */
-   size_t               connectedPeers;
-   size_t               bandwidthLimitedPeers;
-   size_t               duplicatePeers;              /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
-   size_t               maximumPacketSize;           /**< the maximum allowable packet size that may be sent or received on a peer */
-   size_t               maximumWaitingData;          /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
-} ENetHost;
-
-/**
- * An ENet event type, as specified in @ref ENetEvent.
- */
-typedef enum _ENetEventType
-{
-   /** no event occurred within the specified time limit */
-   ENET_EVENT_TYPE_NONE       = 0,  
-
-   /** a connection request initiated by enet_host_connect has completed.  
-     * The peer field contains the peer which successfully connected. 
-     */
-   ENET_EVENT_TYPE_CONNECT    = 1,  
-
-   /** 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 intialized 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.
-     */
-   ENET_EVENT_TYPE_DISCONNECT = 2,  
-
-   /** 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.
-     */
-   ENET_EVENT_TYPE_RECEIVE    = 3
-} ENetEventType;
-
-/**
- * An ENet event as returned by enet_host_service().
-   
-   @sa enet_host_service
- */
-typedef struct _ENetEvent 
-{
-   ENetEventType        type;      /**< type of the event */
-   ENetPeer *           peer;      /**< peer that generated a connect, disconnect or receive event */
-   enet_uint8           channelID; /**< channel on the peer that generated the event, if appropriate */
-   enet_uint32          data;      /**< data associated with the event, if appropriate */
-   ENetPacket *         packet;    /**< packet associated with the event, if appropriate */
-} ENetEvent;
-
-/** @defgroup global ENet global functions
-    @{ 
-*/
-
-/** 
-  Initializes ENet globally.  Must be called prior to using any functions in
-  ENet.
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize (void);
-
-/** 
-  Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
-
-  @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
-  @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
-
-/** 
-  Shuts down ENet globally.  Should be called when a program that has
-  initialized ENet exits.
-*/
-ENET_API void enet_deinitialize (void);
-
-/**
-  Gives the linked version of the ENet library.
-  @returns the version number 
-*/
-ENET_API ENetVersion enet_linked_version (void);
-
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
-/**
-  Returns the wall-time in milliseconds.  Its initial value is unspecified
-  unless otherwise set.
-  */
-ENET_API enet_uint64 enet_time_get (void);
-/**
-  Sets the current wall-time in milliseconds.
-  */
-ENET_API void enet_time_set (enet_uint64);
-
-/** @defgroup socket ENet socket functions
-    @{
-*/
-ENET_API ENetSocket enet_socket_create (ENetSocketType);
-ENET_API int        enet_socket_bind (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_get_address (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_listen (ENetSocket, int);
-ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_connect (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-ENET_API int        enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-ENET_API int        enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint64);
-ENET_API int        enet_socket_set_option (ENetSocket, ENetSocketOption, int);
-ENET_API int        enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
-ENET_API int        enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
-ENET_API void       enet_socket_destroy (ENetSocket);
-ENET_API int        enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-/** @} */
-
-/** @defgroup Address ENet address functions
-    @{
-*/
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
-    and sets the host field in the address parameter if successful.
-    @param address destination to store the parsed IP address
-    @param hostName IP address to parse
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostName);
-
-/** Attempts to resolve the host named by the parameter hostName and sets
-    the host field in the address parameter if successful.
-    @param address destination to store resolved address
-    @param hostName host name to lookup
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
-    @param address    address printed
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
-    @param address    address used for reverse lookup
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** @} */
-
-ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
-ENET_API ENetPacket * enet_packet_create_offset (const void *, size_t, size_t, enet_uint32);
-ENET_API void         enet_packet_destroy (ENetPacket *);
-ENET_API int          enet_packet_resize  (ENetPacket *, size_t);
-ENET_API enet_uint32  enet_crc32 (const ENetBuffer *, size_t);
-
-ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-ENET_API void       enet_host_destroy (ENetHost *);
-ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
-ENET_API int        enet_host_check_events (ENetHost *, ENetEvent *);
-ENET_API int        enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
-ENET_API void       enet_host_flush (ENetHost *);
-ENET_API void       enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
-ENET_API void       enet_host_compress (ENetHost *, const ENetCompressor *);
-ENET_API int        enet_host_compress_with_range_coder (ENetHost * host);
-ENET_API void       enet_host_channel_limit (ENetHost *, size_t);
-ENET_API void       enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
-extern   void       enet_host_bandwidth_throttle (ENetHost *);
-extern  enet_uint64 enet_host_random_seed (void);
-
-ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
-ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
-ENET_API void                enet_peer_ping (ENetPeer *);
-ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-ENET_API void                enet_peer_reset (ENetPeer *);
-ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
-extern void                  enet_peer_reset_queues (ENetPeer *);
-extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
-extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
-extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
-extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
-extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
-extern void                  enet_peer_on_connect (ENetPeer *);
-extern void                  enet_peer_on_disconnect (ENetPeer *);
-
-ENET_API void * enet_range_coder_create (void);
-ENET_API void   enet_range_coder_destroy (void *);
-ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
-ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
-   
-extern size_t enet_protocol_command_size (enet_uint8);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __ENET_ENET_H__ */
-

include/enet/enet.h.us.c

@@ -1,626 +0,0 @@
-/**
- * @file  enet.h
- * @brief ENet public header file
- */
-#ifndef __ENET_ENET_H__
-# define __ENET_ENET_H__
-
-# ifdef __cplusplus
-extern "C"
-{
-# endif
-
-# include <stdlib.h>
-
-# ifdef _WIN32
-#  include "enet/win32.h"
-# else
-#  include "enet/unix.h"
-# endif
-
-# include "enet/types.h"
-# include "enet/protocol.h"
-# include "enet/list.h"
-# include "enet/time.h"
-# include "enet/utility.h"
-# include "enet/callbacks.h"
-
-# define ENET_VERSION_MAJOR 1
-# define ENET_VERSION_MINOR 4
-# define ENET_VERSION_PATCH 4
-# define ENET_VERSION_CREATE(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
-# define ENET_VERSION_GET_MAJOR(version)          (((version) >> 16) & 0xFF)
-# define ENET_VERSION_GET_MINOR(version)          (((version) >> 8) & 0xFF)
-# define ENET_VERSION_GET_PATCH(version)          ((version) & 0xFF)
-# define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-typedef enet_uint32 ENetVersion;
-
-struct _ENetHost;
-struct _ENetEvent;
-struct _ENetPacket;
-
-typedef enum _ENetSocketType {
-    ENET_SOCKET_TYPE_STREAM   = 1,
-    ENET_SOCKET_TYPE_DATAGRAM = 2
-} ENetSocketType;
-
-typedef enum _ENetSocketWait {
-    ENET_SOCKET_WAIT_NONE      = 0,
-    ENET_SOCKET_WAIT_SEND      = (1 << 0),
-    ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-    ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-} ENetSocketWait;
-
-typedef enum _ENetSocketOption {
-    ENET_SOCKOPT_NONBLOCK  = 1,
-    ENET_SOCKOPT_BROADCAST = 2,
-    ENET_SOCKOPT_RCVBUF    = 3,
-    ENET_SOCKOPT_SNDBUF    = 4,
-    ENET_SOCKOPT_REUSEADDR = 5,
-    ENET_SOCKOPT_RCVTIMEO  = 6,
-    ENET_SOCKOPT_SNDTIMEO  = 7,
-    ENET_SOCKOPT_ERROR     = 8,
-    ENET_SOCKOPT_NODELAY   = 9
-} ENetSocketOption;
-
-typedef enum _ENetSocketShutdown {
-    ENET_SOCKET_SHUTDOWN_READ       = 0,
-    ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-} ENetSocketShutdown;
-
-# define ENET_HOST_ANY       0
-# define ENET_HOST_BROADCAST 0xFFFFFFFFU
-# define ENET_PORT_ANY       0
-
-/**
- * Portable internet address structure.
- *
- * The host must be specified in network byte-order, and the port must be in host
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
- */
-typedef struct _ENetAddress {
-    enet_uint32 host;
-    enet_uint16 port;
-} ENetAddress;
-
-/**
- * Packet flag bit constants.
- *
- * The host must be specified in network byte-order, and the port must be in
- * host byte-order. The constant ENET_HOST_ANY may be used to specify the
- * default server host.
- *
- * @sa ENetPacket
- */
-typedef enum _ENetPacketFlag {
-    /** packet must be received by the target peer and resend attempts should be
-     * made until the packet is delivered */
-    ENET_PACKET_FLAG_RELIABLE            = (1 << 0),
-
-    /** packet will not be sequenced with other packets
-     * not supported for reliable packets
-     */
-    ENET_PACKET_FLAG_UNSEQUENCED         = (1 << 1),
-    /** packet will not allocate data, and user must supply it instead */
-    ENET_PACKET_FLAG_NO_ALLOCATE         = (1 << 2),
-
-    /** packet will be fragmented using unreliable (instead of reliable) sends
-     * if it exceeds the MTU */
-    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-
-    /** whether the packet has been sent from all queues it has been entered into */
-    ENET_PACKET_FLAG_SENT                = (1 << 8)
-} ENetPacketFlag;
-
-typedef void (ENET_CALLBACK * ENetPacketFreeCallback)(struct _ENetPacket *);
-
-/**
- * ENet packet structure.
- *
- * An ENet data packet that may be sent to or received from a peer. The shown
- * fields should only be read and never modified. The data field contains the
- * allocated data for the packet. The dataLength fields specifies the length
- * of the allocated data.  The flags field is either 0 (specifying no flags),
- * or a bitwise-or of any combination of the following flags:
- *
- *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
- *    and resend attempts should be made until the packet is delivered
- *
- *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets
- *    (not supported for reliable packets)
- *
- *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
- *
- *    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable
- *    (instead of reliable) sends if it exceeds the MTU
- *
- *    ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into
- * @sa ENetPacketFlag
- */
-typedef struct _ENetPacket {
-    size_t                 referenceCount; /**< internal use only */
-    enet_uint32            flags;          /**< bitwise-or of ENetPacketFlag constants */
-    enet_uint8 *           data;           /**< allocated data for packet */
-    size_t                 dataLength;     /**< length of data */
-    ENetPacketFreeCallback freeCallback;   /**< function to be called when the packet is no longer in use */
-    void *                 userData;       /**< application private data, may be freely modified */
-} ENetPacket;
-
-typedef struct _ENetAcknowledgement {
-    ENetListNode acknowledgementList;
-    enet_uint32  sentTime;
-    ENetProtocol command;
-} ENetAcknowledgement;
-
-typedef struct _ENetOutgoingCommand {
-    ENetListNode outgoingCommandList;
-    enet_uint16  reliableSequenceNumber;
-    enet_uint16  unreliableSequenceNumber;
-    enet_uint32  sentTime;
-    enet_uint32  roundTripTimeout;
-    enet_uint32  roundTripTimeoutLimit;
-    enet_uint32  fragmentOffset;
-    enet_uint16  fragmentLength;
-    enet_uint16  sendAttempts;
-    ENetProtocol command;
-    ENetPacket * packet;
-} ENetOutgoingCommand;
-
-typedef struct _ENetIncomingCommand {
-    ENetListNode incomingCommandList;
-    enet_uint16  reliableSequenceNumber;
-    enet_uint16  unreliableSequenceNumber;
-    ENetProtocol command;
-    enet_uint32  fragmentCount;
-    enet_uint32  fragmentsRemaining;
-    enet_uint32 *fragments;
-    ENetPacket * packet;
-} ENetIncomingCommand;
-
-typedef enum _ENetPeerState {
-    ENET_PEER_STATE_DISCONNECTED             = 0,
-    ENET_PEER_STATE_CONNECTING               = 1,
-    ENET_PEER_STATE_ACKNOWLEDGING_CONNECT    = 2,
-    ENET_PEER_STATE_CONNECTION_PENDING       = 3,
-    ENET_PEER_STATE_CONNECTION_SUCCEEDED     = 4,
-    ENET_PEER_STATE_CONNECTED                = 5,
-    ENET_PEER_STATE_DISCONNECT_LATER         = 6,
-    ENET_PEER_STATE_DISCONNECTING            = 7,
-    ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
-    ENET_PEER_STATE_ZOMBIE                   = 9
-} ENetPeerState;
-
-# ifndef ENET_BUFFER_MAXIMUM
-#  define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-# endif
-
-enum {
-    ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-    ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-    ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-    ENET_HOST_DEFAULT_MTU                  = 1400,
-    ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-    ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-
-    ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-    ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-    ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-    ENET_PEER_PACKET_THROTTLE_COUNTER      = 7,
-    ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-    ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-    ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-    ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-    ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-    ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-    ENET_PEER_TIMEOUT_LIMIT                = 32,
-    ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-    ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-    ENET_PEER_PING_INTERVAL                = 500,
-    ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-    ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-    ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-    ENET_PEER_RELIABLE_WINDOWS             = 16,
-    ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-    ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-};
-
-typedef struct _ENetChannel {
-    enet_uint16 outgoingReliableSequenceNumber;
-    enet_uint16 outgoingUnreliableSequenceNumber;
-    enet_uint16 usedReliableWindows;
-    enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
-    enet_uint16 incomingReliableSequenceNumber;
-    enet_uint16 incomingUnreliableSequenceNumber;
-    ENetList    incomingReliableCommands;
-    ENetList    incomingUnreliableCommands;
-} ENetChannel;
-
-/**
- * An ENet peer which data packets may be sent or received from.
- *
- * No fields should be modified unless otherwise specified.
- */
-typedef struct _ENetPeer {
-    ENetListNode      dispatchList;
-    struct _ENetHost *host;
-    enet_uint16       outgoingPeerID;
-    enet_uint16       incomingPeerID;
-    enet_uint32       connectID;
-    enet_uint8        outgoingSessionID;
-    enet_uint8        incomingSessionID;
-    ENetAddress       address; /**< Internet address of the peer */
-    void *            data;    /**< Application private data, may be freely modified */
-    ENetPeerState     state;
-    ENetChannel *     channels;
-    size_t            channelCount;      /**< Number of channels allocated for communication with peer */
-    enet_uint32       incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
-    enet_uint32       outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
-    enet_uint32       incomingBandwidthThrottleEpoch;
-    enet_uint32       outgoingBandwidthThrottleEpoch;
-    enet_uint32       incomingDataTotal;
-    enet_uint32       outgoingDataTotal;
-    enet_uint32       lastSendTime;
-    enet_uint32       lastReceiveTime;
-    enet_uint32       nextTimeout;
-    enet_uint32       earliestTimeout;
-    enet_uint32       packetLossEpoch;
-    enet_uint32       packetsSent;
-    enet_uint32       packetsLost;
-    enet_uint32       packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
-    enet_uint32       packetLossVariance;
-    enet_uint32       packetThrottle;
-    enet_uint32       packetThrottleLimit;
-    enet_uint32       packetThrottleCounter;
-    enet_uint32       packetThrottleEpoch;
-    enet_uint32       packetThrottleAcceleration;
-    enet_uint32       packetThrottleDeceleration;
-    enet_uint32       packetThrottleInterval;
-    enet_uint32       pingInterval;
-    enet_uint32       timeoutLimit;
-    enet_uint32       timeoutMinimum;
-    enet_uint32       timeoutMaximum;
-    enet_uint32       lastRoundTripTime;
-    enet_uint32       lowestRoundTripTime;
-    enet_uint32       lastRoundTripTimeVariance;
-    enet_uint32       highestRoundTripTimeVariance;
-    enet_uint32       roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
-    enet_uint32       roundTripTimeVariance;
-    enet_uint32       mtu;
-    enet_uint32       windowSize;
-    enet_uint32       reliableDataInTransit;
-    enet_uint16       outgoingReliableSequenceNumber;
-    ENetList          acknowledgements;
-    ENetList          sentReliableCommands;
-    ENetList          sentUnreliableCommands;
-    ENetList          outgoingReliableCommands;
-    ENetList          outgoingUnreliableCommands;
-    ENetList          dispatchedCommands;
-    int               needsDispatch;
-    enet_uint16       incomingUnsequencedGroup;
-    enet_uint16       outgoingUnsequencedGroup;
-    enet_uint32       unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
-    enet_uint32       eventData;
-    size_t            totalWaitingData;
-} ENetPeer;
-
-/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
- */
-typedef struct _ENetCompressor {
-    /** Context data for the compressor. Must be non-NULL. */
-    void *context;
-    /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-    size_t(ENET_CALLBACK * compress) (void *context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit,
-    enet_uint8 * outData, size_t outLimit);
-    /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-    size_t(ENET_CALLBACK * decompress) (void *context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData,
-    size_t outLimit);
-    /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
-    void (ENET_CALLBACK * destroy)(void *context);
-} ENetCompressor;
-
-/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
-typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback)(const ENetBuffer *buffers, size_t bufferCount);
-
-/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
-typedef int (ENET_CALLBACK * ENetInterceptCallback)(struct _ENetHost *host, struct _ENetEvent *event);
-
-/** An ENet host for communicating with peers.
- *
- * No fields should be modified unless otherwise stated.
- *
- *  @sa enet_host_create()
- *  @sa enet_host_destroy()
- *  @sa enet_host_connect()
- *  @sa enet_host_service()
- *  @sa enet_host_flush()
- *  @sa enet_host_broadcast()
- *  @sa enet_host_compress()
- *  @sa enet_host_compress_with_range_coder()
- *  @sa enet_host_channel_limit()
- *  @sa enet_host_bandwidth_limit()
- *  @sa enet_host_bandwidth_throttle()
- */
-typedef struct _ENetHost {
-    ENetSocket            socket;
-    ENetAddress           address;           /**< Internet address of the host */
-    enet_uint32           incomingBandwidth; /**< downstream bandwidth of the host */
-    enet_uint32           outgoingBandwidth; /**< upstream bandwidth of the host */
-    enet_uint32           bandwidthThrottleEpoch;
-    enet_uint32           mtu;
-    enet_uint32           randomSeed;
-    int                   recalculateBandwidthLimits;
-    ENetPeer *            peers;        /**< array of peers allocated for this host */
-    size_t                peerCount;    /**< number of peers allocated for this host */
-    size_t                channelLimit; /**< maximum number of channels allowed for connected peers */
-    enet_uint32           serviceTime;
-    ENetList              dispatchQueue;
-    int                   continueSending;
-    size_t                packetSize;
-    enet_uint16           headerFlags;
-    ENetProtocol          commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-    size_t                commandCount;
-    ENetBuffer            buffers [ENET_BUFFER_MAXIMUM];
-    size_t                bufferCount;
-    ENetChecksumCallback  checksum; /**< callback the user can set to enable packet checksums for this host */
-    ENetCompressor        compressor;
-    enet_uint8            packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
-    ENetAddress           receivedAddress;
-    enet_uint8 *          receivedData;
-    size_t                receivedDataLength;
-    enet_uint32           totalSentData;        /**< total data sent, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalSentPackets;     /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalReceivedData;    /**< total data received, user should reset to 0 as needed to prevent overflow */
-    enet_uint32           totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
-    ENetInterceptCallback intercept;            /**< callback the user can set to intercept received raw UDP packets */
-    size_t                connectedPeers;
-    size_t                bandwidthLimitedPeers;
-    size_t                duplicatePeers;     /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
-    size_t                maximumPacketSize;  /**< the maximum allowable packet size that may be sent or received on a peer */
-    size_t                maximumWaitingData; /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
-} ENetHost;
-
-/**
- * An ENet event type, as specified in @ref ENetEvent.
- */
-typedef enum _ENetEventType {
-    /** no event occurred within the specified time limit */
-    ENET_EVENT_TYPE_NONE       = 0,
-
-    /** a connection request initiated by enet_host_connect has completed.
-     * The peer field contains the peer which successfully connected.
-     */
-    ENET_EVENT_TYPE_CONNECT    = 1,
-
-    /** 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 intialized 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.
-     */
-    ENET_EVENT_TYPE_DISCONNECT = 2,
-
-    /** 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.
-     */
-    ENET_EVENT_TYPE_RECEIVE    = 3
-} ENetEventType;
-
-/**
- * An ENet event as returned by enet_host_service().
- *
- * @sa enet_host_service
- */
-typedef struct _ENetEvent {
-    ENetEventType type;      /**< type of the event */
-    ENetPeer *    peer;      /**< peer that generated a connect, disconnect or receive event */
-    enet_uint8    channelID; /**< channel on the peer that generated the event, if appropriate */
-    enet_uint32   data;      /**< data associated with the event, if appropriate */
-    ENetPacket *  packet;    /**< packet associated with the event, if appropriate */
-} ENetEvent;
-
-/** @defgroup global ENet global functions
- *  @{
- */
-
-/**
- * Initializes ENet globally.  Must be called prior to using any functions in
- * ENet.
- * @returns 0 on success, < 0 on failure
- */
-ENET_API int
-enet_initialize(void);
-
-/**
- * Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
- *
- * @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
- * @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
- * @returns 0 on success, < 0 on failure
- */
-ENET_API int
-enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits);
-
-/**
- * Shuts down ENet globally.  Should be called when a program that has
- * initialized ENet exits.
- */
-ENET_API void
-enet_deinitialize(void);
-
-/**
- * Gives the linked version of the ENet library.
- * @returns the version number
- */
-ENET_API ENetVersion
-enet_linked_version(void);
-
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
-/**
- * Returns the wall-time in milliseconds.  Its initial value is unspecified
- * unless otherwise set.
- */
-ENET_API enet_uint64
-enet_time_get(void);
-
-/**
- * Sets the current wall-time in milliseconds.
- */
-ENET_API void enet_time_set(enet_uint64);
-
-/** @defgroup socket ENet socket functions
- *  @{
- */
-ENET_API ENetSocket enet_socket_create(ENetSocketType);
-ENET_API int enet_socket_bind(ENetSocket, const ENetAddress *);
-ENET_API int enet_socket_get_address(ENetSocket, ENetAddress *);
-ENET_API int enet_socket_listen(ENetSocket, int);
-ENET_API ENetSocket enet_socket_accept(ENetSocket, ENetAddress *);
-ENET_API int enet_socket_connect(ENetSocket, const ENetAddress *);
-ENET_API int enet_socket_send(ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-ENET_API int enet_socket_receive(ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-ENET_API int enet_socket_wait(ENetSocket, enet_uint32 *, enet_uint64);
-ENET_API int enet_socket_set_option(ENetSocket, ENetSocketOption, int);
-ENET_API int enet_socket_get_option(ENetSocket, ENetSocketOption, int *);
-ENET_API int enet_socket_shutdown(ENetSocket, ENetSocketShutdown);
-ENET_API void enet_socket_destroy(ENetSocket);
-ENET_API int enet_socketset_select(ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-/** @} */
-
-/** @defgroup Address ENet address functions
- *  @{
- */
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
- *  and sets the host field in the address parameter if successful.
- *  @param address destination to store the parsed IP address
- *  @param hostName IP address to parse
- *  @retval 0 on success
- *  @retval < 0 on failure
- *  @returns the address of the given hostName in address on success
- */
-ENET_API int
-enet_address_set_host_ip(ENetAddress *address, const char *hostName);
-
-/** Attempts to resolve the host named by the parameter hostName and sets
- *  the host field in the address parameter if successful.
- *  @param address destination to store resolved address
- *  @param hostName host name to lookup
- *  @retval 0 on success
- *  @retval < 0 on failure
- *  @returns the address of the given hostName in address on success
- */
-ENET_API int
-enet_address_set_host(ENetAddress *address, const char *hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
- *  @param address    address printed
- *  @param hostName   destination for name, must not be NULL
- *  @param nameLength maximum length of hostName.
- *  @returns the null-terminated name of the host in hostName on success
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-ENET_API int
-enet_address_get_host_ip(const ENetAddress *address, char *hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
- *  @param address    address used for reverse lookup
- *  @param hostName   destination for name, must not be NULL
- *  @param nameLength maximum length of hostName.
- *  @returns the null-terminated name of the host in hostName on success
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-ENET_API int
-enet_address_get_host(const ENetAddress *address, char *hostName, size_t nameLength);
-
-/** @} */
-
-ENET_API ENetPacket *enet_packet_create(const void *, size_t, enet_uint32);
-ENET_API ENetPacket *enet_packet_create_offset(const void *, size_t, size_t, enet_uint32);
-ENET_API void
-enet_packet_destroy(ENetPacket *);
-ENET_API int enet_packet_resize(ENetPacket *, size_t);
-ENET_API enet_uint32 enet_crc32(const ENetBuffer *, size_t);
-
-ENET_API ENetHost *enet_host_create(const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-ENET_API void
-enet_host_destroy(ENetHost *);
-ENET_API ENetPeer *enet_host_connect(ENetHost *, const ENetAddress *, size_t, enet_uint32);
-ENET_API int
-enet_host_check_events(ENetHost *, ENetEvent *);
-ENET_API int enet_host_service(ENetHost *, ENetEvent *, enet_uint32);
-ENET_API void
-enet_host_flush(ENetHost *);
-ENET_API void enet_host_broadcast(ENetHost *, enet_uint8, ENetPacket *);
-ENET_API void
-enet_host_compress(ENetHost *, const ENetCompressor *);
-ENET_API int
-enet_host_compress_with_range_coder(ENetHost *host);
-ENET_API void enet_host_channel_limit(ENetHost *, size_t);
-ENET_API void enet_host_bandwidth_limit(ENetHost *, enet_uint32, enet_uint32);
-extern void
-enet_host_bandwidth_throttle(ENetHost *);
-extern enet_uint64
-enet_host_random_seed(void);
-
-ENET_API int enet_peer_send(ENetPeer *, enet_uint8, ENetPacket *);
-ENET_API ENetPacket *
-enet_peer_receive(ENetPeer *, enet_uint8 *channelID);
-ENET_API void
-enet_peer_ping(ENetPeer *);
-ENET_API void enet_peer_ping_interval(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_timeout(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-ENET_API void
-enet_peer_reset(ENetPeer *);
-ENET_API void enet_peer_disconnect(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_disconnect_now(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_disconnect_later(ENetPeer *, enet_uint32);
-ENET_API void enet_peer_throttle_configure(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-extern int enet_peer_throttle(ENetPeer *, enet_uint32);
-extern void
-enet_peer_reset_queues(ENetPeer *);
-extern void
-enet_peer_setup_outgoing_command(ENetPeer *, ENetOutgoingCommand *);
-extern ENetOutgoingCommand *enet_peer_queue_outgoing_command(ENetPeer *, const ENetProtocol *, ENetPacket *,
-  enet_uint32, enet_uint16);
-extern ENetIncomingCommand *enet_peer_queue_incoming_command(ENetPeer *, const ENetProtocol *, const void *, size_t,
-  enet_uint32, enet_uint32);
-extern ENetAcknowledgement *enet_peer_queue_acknowledgement(ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void
-enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *, ENetChannel *);
-extern void
-enet_peer_dispatch_incoming_reliable_commands(ENetPeer *, ENetChannel *);
-extern void
-enet_peer_on_connect(ENetPeer *);
-extern void
-enet_peer_on_disconnect(ENetPeer *);
-
-ENET_API void *
-enet_range_coder_create(void);
-ENET_API void
-enet_range_coder_destroy(void *);
-ENET_API size_t enet_range_coder_compress(void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
-ENET_API size_t enet_range_coder_decompress(void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
-
-extern size_t enet_protocol_command_size(enet_uint8);
-
-# ifdef __cplusplus
-}
-# endif
-
-#endif /* __ENET_ENET_H__ */

include/enet/list.h

@@ -1,43 +0,0 @@
-/** 
- @file  list.h
- @brief ENet list management 
-*/
-#ifndef __ENET_LIST_H__
-#define __ENET_LIST_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetListNode
-{
-   struct _ENetListNode * next;
-   struct _ENetListNode * previous;
-} ENetListNode;
-
-typedef ENetListNode * ENetListIterator;
-
-typedef struct _ENetList
-{
-   ENetListNode sentinel;
-} ENetList;
-
-extern void enet_list_clear (ENetList *);
-
-extern ENetListIterator enet_list_insert (ENetListIterator, void *);
-extern void * enet_list_remove (ENetListIterator);
-extern ENetListIterator enet_list_move (ENetListIterator, void *, void *);
-
-extern size_t enet_list_size (ENetList *);
-
-#define enet_list_begin(list) ((list) -> sentinel.next)
-#define enet_list_end(list) (& (list) -> sentinel)
-
-#define enet_list_empty(list) (enet_list_begin (list) == enet_list_end (list))
-
-#define enet_list_next(iterator) ((iterator) -> next)
-#define enet_list_previous(iterator) ((iterator) -> previous)
-
-#define enet_list_front(list) ((void *) (list) -> sentinel.next)
-#define enet_list_back(list) ((void *) (list) -> sentinel.previous)
-
-#endif /* __ENET_LIST_H__ */
-

include/enet/protocol.h

@@ -1,198 +0,0 @@
-/** 
- @file  protocol.h
- @brief ENet protocol
-*/
-#ifndef __ENET_PROTOCOL_H__
-#define __ENET_PROTOCOL_H__
-
-#include "enet/types.h"
-
-enum
-{
-   ENET_PROTOCOL_MINIMUM_MTU             = 576,
-   ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-   ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-   ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-   ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-   ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-   ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-   ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-   ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-};
-
-typedef enum _ENetProtocolCommand
-{
-   ENET_PROTOCOL_COMMAND_NONE               = 0,
-   ENET_PROTOCOL_COMMAND_ACKNOWLEDGE        = 1,
-   ENET_PROTOCOL_COMMAND_CONNECT            = 2,
-   ENET_PROTOCOL_COMMAND_VERIFY_CONNECT     = 3,
-   ENET_PROTOCOL_COMMAND_DISCONNECT         = 4,
-   ENET_PROTOCOL_COMMAND_PING               = 5,
-   ENET_PROTOCOL_COMMAND_SEND_RELIABLE      = 6,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE    = 7,
-   ENET_PROTOCOL_COMMAND_SEND_FRAGMENT      = 8,
-   ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED   = 9,
-   ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT    = 10,
-   ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-   ENET_PROTOCOL_COMMAND_COUNT              = 13,
-
-   ENET_PROTOCOL_COMMAND_MASK               = 0x0F
-} ENetProtocolCommand;
-
-typedef enum _ENetProtocolFlag
-{
-   ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-   ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-
-   ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14),
-   ENET_PROTOCOL_HEADER_FLAG_SENT_TIME  = (1 << 15),
-   ENET_PROTOCOL_HEADER_FLAG_MASK       = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-
-   ENET_PROTOCOL_HEADER_SESSION_MASK    = (3 << 12),
-   ENET_PROTOCOL_HEADER_SESSION_SHIFT   = 12
-} ENetProtocolFlag;
-
-#ifdef _MSC_VER
-#pragma pack(push, 1)
-#define ENET_PACKED
-#elif defined(__GNUC__) || defined(__clang__)
-#define ENET_PACKED __attribute__ ((packed))
-#else
-#define ENET_PACKED
-#endif
-
-typedef struct _ENetProtocolHeader
-{
-   enet_uint16 peerID;
-   enet_uint16 sentTime;
-} ENET_PACKED ENetProtocolHeader;
-
-typedef struct _ENetProtocolCommandHeader
-{
-   enet_uint8 command;
-   enet_uint8 channelID;
-   enet_uint16 reliableSequenceNumber;
-} ENET_PACKED ENetProtocolCommandHeader;
-
-typedef struct _ENetProtocolAcknowledge
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 receivedReliableSequenceNumber;
-   enet_uint16 receivedSentTime;
-} ENET_PACKED ENetProtocolAcknowledge;
-
-typedef struct _ENetProtocolConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolConnect;
-
-typedef struct _ENetProtocolVerifyConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-} ENET_PACKED ENetProtocolVerifyConnect;
-
-typedef struct _ENetProtocolBandwidthLimit
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-} ENET_PACKED ENetProtocolBandwidthLimit;
-
-typedef struct _ENetProtocolThrottleConfigure
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-} ENET_PACKED ENetProtocolThrottleConfigure;
-
-typedef struct _ENetProtocolDisconnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolDisconnect;
-
-typedef struct _ENetProtocolPing
-{
-   ENetProtocolCommandHeader header;
-} ENET_PACKED ENetProtocolPing;
-
-typedef struct _ENetProtocolSendReliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendReliable;
-
-typedef struct _ENetProtocolSendUnreliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unreliableSequenceNumber;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnreliable;
-
-typedef struct _ENetProtocolSendUnsequenced
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unsequencedGroup;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnsequenced;
-
-typedef struct _ENetProtocolSendFragment
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 startSequenceNumber;
-   enet_uint16 dataLength;
-   enet_uint32 fragmentCount;
-   enet_uint32 fragmentNumber;
-   enet_uint32 totalLength;
-   enet_uint32 fragmentOffset;
-} ENET_PACKED ENetProtocolSendFragment;
-
-typedef union _ENetProtocol
-{
-   ENetProtocolCommandHeader header;
-   ENetProtocolAcknowledge acknowledge;
-   ENetProtocolConnect connect;
-   ENetProtocolVerifyConnect verifyConnect;
-   ENetProtocolDisconnect disconnect;
-   ENetProtocolPing ping;
-   ENetProtocolSendReliable sendReliable;
-   ENetProtocolSendUnreliable sendUnreliable;
-   ENetProtocolSendUnsequenced sendUnsequenced;
-   ENetProtocolSendFragment sendFragment;
-   ENetProtocolBandwidthLimit bandwidthLimit;
-   ENetProtocolThrottleConfigure throttleConfigure;
-} ENET_PACKED ENetProtocol;
-
-#ifdef _MSC_VER
-#pragma pack(pop)
-#endif
-
-#endif /* __ENET_PROTOCOL_H__ */
-

include/enet/protocol.h.us.c

@@ -1,180 +0,0 @@
-/**
- * @file  protocol.h
- * @brief ENet protocol
- */
-#ifndef __ENET_PROTOCOL_H__
-#define __ENET_PROTOCOL_H__
-
-#include "enet/types.h"
-
-enum {
-    ENET_PROTOCOL_MINIMUM_MTU             = 576,
-    ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-    ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-    ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-    ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-    ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-    ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-    ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-    ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-};
-
-typedef enum _ENetProtocolCommand {
-    ENET_PROTOCOL_COMMAND_NONE                     = 0,
-    ENET_PROTOCOL_COMMAND_ACKNOWLEDGE              = 1,
-    ENET_PROTOCOL_COMMAND_CONNECT                  = 2,
-    ENET_PROTOCOL_COMMAND_VERIFY_CONNECT           = 3,
-    ENET_PROTOCOL_COMMAND_DISCONNECT               = 4,
-    ENET_PROTOCOL_COMMAND_PING                     = 5,
-    ENET_PROTOCOL_COMMAND_SEND_RELIABLE            = 6,
-    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE          = 7,
-    ENET_PROTOCOL_COMMAND_SEND_FRAGMENT            = 8,
-    ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED         = 9,
-    ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT          = 10,
-    ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE       = 11,
-    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-    ENET_PROTOCOL_COMMAND_COUNT                    = 13,
-
-    ENET_PROTOCOL_COMMAND_MASK                     = 0x0F
-} ENetProtocolCommand;
-
-typedef enum _ENetProtocolFlag {
-    ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-    ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-
-    ENET_PROTOCOL_HEADER_FLAG_COMPRESSED   = (1 << 14),
-    ENET_PROTOCOL_HEADER_FLAG_SENT_TIME    = (1 << 15),
-    ENET_PROTOCOL_HEADER_FLAG_MASK         = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-
-    ENET_PROTOCOL_HEADER_SESSION_MASK      = (3 << 12),
-    ENET_PROTOCOL_HEADER_SESSION_SHIFT     = 12
-} ENetProtocolFlag;
-
-#ifdef _MSC_VER
-# pragma pack(push, 1)
-# define ENET_PACKED
-#elif defined(__GNUC__) || defined(__clang__)
-# define ENET_PACKED __attribute__((packed))
-#else
-# define ENET_PACKED
-#endif
-
-typedef struct _ENetProtocolHeader {
-    enet_uint16 peerID;
-    enet_uint16 sentTime;
-} ENET_PACKED ENetProtocolHeader;
-
-typedef struct _ENetProtocolCommandHeader {
-    enet_uint8  command;
-    enet_uint8  channelID;
-    enet_uint16 reliableSequenceNumber;
-} ENET_PACKED ENetProtocolCommandHeader;
-
-typedef struct _ENetProtocolAcknowledge {
-    ENetProtocolCommandHeader header;
-    enet_uint16               receivedReliableSequenceNumber;
-    enet_uint16               receivedSentTime;
-} ENET_PACKED ENetProtocolAcknowledge;
-
-typedef struct _ENetProtocolConnect {
-    ENetProtocolCommandHeader header;
-    enet_uint16               outgoingPeerID;
-    enet_uint8                incomingSessionID;
-    enet_uint8                outgoingSessionID;
-    enet_uint32               mtu;
-    enet_uint32               windowSize;
-    enet_uint32               channelCount;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-    enet_uint32               connectID;
-    enet_uint32               data;
-} ENET_PACKED ENetProtocolConnect;
-
-typedef struct _ENetProtocolVerifyConnect {
-    ENetProtocolCommandHeader header;
-    enet_uint16               outgoingPeerID;
-    enet_uint8                incomingSessionID;
-    enet_uint8                outgoingSessionID;
-    enet_uint32               mtu;
-    enet_uint32               windowSize;
-    enet_uint32               channelCount;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-    enet_uint32               connectID;
-} ENET_PACKED ENetProtocolVerifyConnect;
-
-typedef struct _ENetProtocolBandwidthLimit {
-    ENetProtocolCommandHeader header;
-    enet_uint32               incomingBandwidth;
-    enet_uint32               outgoingBandwidth;
-} ENET_PACKED ENetProtocolBandwidthLimit;
-
-typedef struct _ENetProtocolThrottleConfigure {
-    ENetProtocolCommandHeader header;
-    enet_uint32               packetThrottleInterval;
-    enet_uint32               packetThrottleAcceleration;
-    enet_uint32               packetThrottleDeceleration;
-} ENET_PACKED ENetProtocolThrottleConfigure;
-
-typedef struct _ENetProtocolDisconnect {
-    ENetProtocolCommandHeader header;
-    enet_uint32               data;
-} ENET_PACKED ENetProtocolDisconnect;
-
-typedef struct _ENetProtocolPing {
-    ENetProtocolCommandHeader header;
-} ENET_PACKED ENetProtocolPing;
-
-typedef struct _ENetProtocolSendReliable {
-    ENetProtocolCommandHeader header;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendReliable;
-
-typedef struct _ENetProtocolSendUnreliable {
-    ENetProtocolCommandHeader header;
-    enet_uint16               unreliableSequenceNumber;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendUnreliable;
-
-typedef struct _ENetProtocolSendUnsequenced {
-    ENetProtocolCommandHeader header;
-    enet_uint16               unsequencedGroup;
-    enet_uint16               dataLength;
-} ENET_PACKED ENetProtocolSendUnsequenced;
-
-typedef struct _ENetProtocolSendFragment {
-    ENetProtocolCommandHeader header;
-    enet_uint16               startSequenceNumber;
-    enet_uint16               dataLength;
-    enet_uint32               fragmentCount;
-    enet_uint32               fragmentNumber;
-    enet_uint32               totalLength;
-    enet_uint32               fragmentOffset;
-} ENET_PACKED ENetProtocolSendFragment;
-
-typedef union _ENetProtocol {
-    ENetProtocolCommandHeader     header;
-    ENetProtocolAcknowledge       acknowledge;
-    ENetProtocolConnect           connect;
-    ENetProtocolVerifyConnect     verifyConnect;
-    ENetProtocolDisconnect        disconnect;
-    ENetProtocolPing              ping;
-    ENetProtocolSendReliable      sendReliable;
-    ENetProtocolSendUnreliable    sendUnreliable;
-    ENetProtocolSendUnsequenced   sendUnsequenced;
-    ENetProtocolSendFragment      sendFragment;
-    ENetProtocolBandwidthLimit    bandwidthLimit;
-    ENetProtocolThrottleConfigure throttleConfigure;
-} ENET_PACKED ENetProtocol;
-
-#ifdef _MSC_VER
-# pragma pack(pop)
-#endif
-
-#endif /* __ENET_PROTOCOL_H__ */

include/enet/time.h

@@ -1,18 +0,0 @@
-/** 
- @file  time.h
- @brief ENet time constants and macros
-*/
-#ifndef __ENET_TIME_H__
-#define __ENET_TIME_H__
-
-#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))
-
-#endif /* __ENET_TIME_H__ */
-

include/enet/types.h

@@ -1,16 +0,0 @@
-/** 
- @file  types.h
- @brief type definitions for ENet
-*/
-#ifndef __ENET_TYPES_H__
-#define __ENET_TYPES_H__
-
-#include <stdint.h>
-
-typedef unsigned char enet_uint8;       /**< unsigned 8-bit type  */
-typedef unsigned short enet_uint16;     /**< unsigned 16-bit type */
-typedef unsigned int enet_uint32;      /**< unsigned 32-bit type */
-typedef uint64_t enet_uint64;
-
-#endif /* __ENET_TYPES_H__ */
-

include/enet/unix.h

@@ -1,47 +0,0 @@
-/** 
- @file  unix.h
- @brief ENet Unix header
-*/
-#ifndef __ENET_UNIX_H__
-#define __ENET_UNIX_H__
-
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <unistd.h>
-
-#ifdef MSG_MAXIOVLEN
-#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
-#endif
-
-typedef int ENetSocket;
-
-#define ENET_SOCKET_NULL -1
-
-#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
-#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value)) /**< macro that converts net to host byte-order of a 16-bit value */
-#define ENET_NET_TO_HOST_32(value) (ntohl (value)) /**< macro that converts net to host byte-order of a 32-bit value */
-
-typedef struct
-{
-    void * data;
-    size_t dataLength;
-} ENetBuffer;
-
-#define ENET_CALLBACK
-
-#define ENET_API extern
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-    
-#endif /* __ENET_UNIX_H__ */
-

include/enet/utility.h

@@ -1,12 +0,0 @@
-/** 
- @file  utility.h
- @brief ENet utility header
-*/
-#ifndef __ENET_UTILITY_H__
-#define __ENET_UTILITY_H__
-
-#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
-#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-
-#endif /* __ENET_UTILITY_H__ */
-

include/enet/win32.h

@@ -1,57 +0,0 @@
-/** 
- @file  win32.h
- @brief ENet Win32 header
-*/
-#ifndef __ENET_WIN32_H__
-#define __ENET_WIN32_H__
-
-#ifdef _MSC_VER
-#ifdef ENET_BUILDING_LIB
-#pragma warning (disable: 4267) // size_t to int conversion
-#pragma warning (disable: 4244) // 64bit to 32bit int
-#pragma warning (disable: 4018) // signed/unsigned mismatch
-#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
-#endif
-#endif
-
-#include <stdlib.h>
-#include <winsock2.h>
-
-typedef SOCKET ENetSocket;
-
-#define ENET_SOCKET_NULL INVALID_SOCKET
-
-#define ENET_HOST_TO_NET_16(value) (htons (value))
-#define ENET_HOST_TO_NET_32(value) (htonl (value))
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value))
-#define ENET_NET_TO_HOST_32(value) (ntohl (value))
-
-typedef struct
-{
-    size_t dataLength;
-    void * data;
-} ENetBuffer;
-
-#define ENET_CALLBACK __cdecl
-
-#ifdef ENET_DLL
-#ifdef ENET_BUILDING_LIB
-#define ENET_API __declspec( dllexport )
-#else
-#define ENET_API __declspec( dllimport )
-#endif /* ENET_BUILDING_LIB */
-#else /* !ENET_DLL */
-#define ENET_API extern
-#endif /* ENET_DLL */
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-
-#endif /* __ENET_WIN32_H__ */
-
-

src/callbacks.c

@@ -1,53 +0,0 @@
-/** 
- @file callbacks.c
- @brief ENet callback functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-static ENetCallbacks callbacks = { malloc, free, abort };
-
-int
-enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits)
-{
-   if (version < ENET_VERSION_CREATE (1, 3, 0))
-     return -1;
-
-   if (inits -> malloc != NULL || inits -> free != NULL)
-   {
-      if (inits -> malloc == NULL || inits -> free == NULL)
-        return -1;
-
-      callbacks.malloc = inits -> malloc;
-      callbacks.free = inits -> free;
-   }
-      
-   if (inits -> no_memory != NULL)
-     callbacks.no_memory = inits -> no_memory;
-
-   return enet_initialize ();
-}
-
-ENetVersion
-enet_linked_version (void)
-{
-    return ENET_VERSION;
-}
-           
-void *
-enet_malloc (size_t size)
-{
-   void * memory = callbacks.malloc (size);
-
-   if (memory == NULL)
-     callbacks.no_memory ();
-
-   return memory;
-}
-
-void
-enet_free (void * memory)
-{
-   callbacks.free (memory);
-}
-

src/callbacks.c.us.c

@@ -1,47 +0,0 @@
-/**
- * @file callbacks.c
- * @brief ENet callback functions
- */
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-static ENetCallbacks callbacks = { malloc, free, abort };
-
-int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits) {
-    if (version < ENET_VERSION_CREATE(1, 3, 0)) {
-        return -1;
-    }
-
-    if (inits->malloc != NULL || inits->free != NULL) {
-        if (inits->malloc == NULL || inits->free == NULL) {
-            return -1;
-        }
-
-        callbacks.malloc = inits->malloc;
-        callbacks.free   = inits->free;
-    }
-
-    if (inits->no_memory != NULL) {
-        callbacks.no_memory = inits->no_memory;
-    }
-
-    return enet_initialize();
-}
-
-ENetVersion enet_linked_version(void) {
-    return ENET_VERSION;
-}
-
-void * enet_malloc(size_t size) {
-    void *memory = callbacks.malloc(size);
-
-    if (memory == NULL) {
-        callbacks.no_memory();
-    }
-
-    return memory;
-}
-
-void enet_free(void *memory) {
-    callbacks.free(memory);
-}

src/compress.c

@@ -1,654 +0,0 @@
-/** 
- @file compress.c
- @brief An adaptive order-2 PPM range coder
-*/
-#define ENET_BUILDING_LIB 1
-#include <string.h>
-#include "enet/enet.h"
-
-typedef struct _ENetSymbol
-{
-    /* binary indexed tree of symbols */
-    enet_uint8 value;
-    enet_uint8 count;
-    enet_uint16 under;
-    enet_uint16 left, right;
-
-    /* context defined by this symbol */
-    enet_uint16 symbols;
-    enet_uint16 escapes;
-    enet_uint16 total;
-    enet_uint16 parent; 
-} ENetSymbol;
-
-/* adaptation constants tuned aggressively for small packet sizes rather than large file compression */
-enum
-{
-    ENET_RANGE_CODER_TOP    = 1<<24,
-    ENET_RANGE_CODER_BOTTOM = 1<<16,
-
-    ENET_CONTEXT_SYMBOL_DELTA = 3,
-    ENET_CONTEXT_SYMBOL_MINIMUM = 1,
-    ENET_CONTEXT_ESCAPE_MINIMUM = 1,
-
-    ENET_SUBCONTEXT_ORDER = 2,
-    ENET_SUBCONTEXT_SYMBOL_DELTA = 2,
-    ENET_SUBCONTEXT_ESCAPE_DELTA = 5
-};
-
-/* context exclusion roughly halves compression speed, so disable for now */
-#undef ENET_CONTEXT_EXCLUSION
-
-typedef struct _ENetRangeCoder
-{
-    /* only allocate enough symbols for reasonable MTUs, would need to be larger for large file compression */
-    ENetSymbol symbols[4096];
-} ENetRangeCoder;
-
-void *
-enet_range_coder_create (void)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) enet_malloc (sizeof (ENetRangeCoder));
-    if (rangeCoder == NULL)
-      return NULL;
-
-    return rangeCoder;
-}
-
-void
-enet_range_coder_destroy (void * context)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    if (rangeCoder == NULL)
-      return;
-
-    enet_free (rangeCoder);
-}
-
-#define ENET_SYMBOL_CREATE(symbol, value_, count_) \
-{ \
-    symbol = & rangeCoder -> symbols [nextSymbol ++]; \
-    symbol -> value = value_; \
-    symbol -> count = count_; \
-    symbol -> under = count_; \
-    symbol -> left = 0; \
-    symbol -> right = 0; \
-    symbol -> symbols = 0; \
-    symbol -> escapes = 0; \
-    symbol -> total = 0; \
-    symbol -> parent = 0; \
-}
-
-#define ENET_CONTEXT_CREATE(context, escapes_, minimum) \
-{ \
-    ENET_SYMBOL_CREATE (context, 0, 0); \
-    (context) -> escapes = escapes_; \
-    (context) -> total = escapes_ + 256*minimum; \
-    (context) -> symbols = 0; \
-}
-
-static enet_uint16
-enet_symbol_rescale (ENetSymbol * symbol)
-{
-    enet_uint16 total = 0;
-    for (;;)
-    {
-        symbol -> count -= symbol->count >> 1;
-        symbol -> under = symbol -> count;
-        if (symbol -> left)
-          symbol -> under += enet_symbol_rescale (symbol + symbol -> left);
-        total += symbol -> under;
-        if (! symbol -> right) break;
-        symbol += symbol -> right;
-    } 
-    return total;
-}
-
-#define ENET_CONTEXT_RESCALE(context, minimum) \
-{ \
-    (context) -> total = (context) -> symbols ? enet_symbol_rescale ((context) + (context) -> symbols) : 0; \
-    (context) -> escapes -= (context) -> escapes >> 1; \
-    (context) -> total += (context) -> escapes + 256*minimum; \
-}
-
-#define ENET_RANGE_CODER_OUTPUT(value) \
-{ \
-    if (outData >= outEnd) \
-      return 0; \
-    * outData ++ = value; \
-}
-
-#define ENET_RANGE_CODER_ENCODE(under, count, total) \
-{ \
-    encodeRange /= (total); \
-    encodeLow += (under) * encodeRange; \
-    encodeRange *= (count); \
-    for (;;) \
-    { \
-        if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
-        { \
-            if(encodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
-            encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-        } \
-        ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \
-        encodeRange <<= 8; \
-        encodeLow <<= 8; \
-    } \
-}
-
-#define ENET_RANGE_CODER_FLUSH \
-{ \
-    while (encodeLow) \
-    { \
-        ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \
-        encodeLow <<= 8; \
-    } \
-}
-
-#define ENET_RANGE_CODER_FREE_SYMBOLS \
-{ \
-    if (nextSymbol >= sizeof (rangeCoder -> symbols) / sizeof (ENetSymbol) - ENET_SUBCONTEXT_ORDER ) \
-    { \
-        nextSymbol = 0; \
-        ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
-        predicted = 0; \
-        order = 0; \
-    } \
-}
-
-#define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update, minimum) \
-{ \
-    under_ = value*minimum; \
-    count_ = minimum; \
-    if (! (context) -> symbols) \
-    { \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        (context) -> symbols = symbol_ - (context); \
-    } \
-    else \
-    { \
-        ENetSymbol * node = (context) + (context) -> symbols; \
-        for (;;) \
-        { \
-            if (value_ < node -> value) \
-            { \
-                node -> under += update; \
-                if (node -> left) { node += node -> left; continue; } \
-                ENET_SYMBOL_CREATE (symbol_, value_, update); \
-                node -> left = symbol_ - node; \
-            } \
-            else \
-            if (value_ > node -> value) \
-            { \
-                under_ += node -> under; \
-                if (node -> right) { node += node -> right; continue; } \
-                ENET_SYMBOL_CREATE (symbol_, value_, update); \
-                node -> right = symbol_ - node; \
-            } \
-            else \
-            { \
-                count_ += node -> count; \
-                under_ += node -> under - node -> count; \
-                node -> under += update; \
-                node -> count += update; \
-                symbol_ = node; \
-            } \
-            break; \
-        } \
-    } \
-}
-
-#ifdef ENET_CONTEXT_EXCLUSION
-static const ENetSymbol emptyContext = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-#define ENET_CONTEXT_WALK(context, body) \
-{ \
-    const ENetSymbol * node = (context) + (context) -> symbols; \
-    const ENetSymbol * stack [256]; \
-    size_t stackSize = 0; \
-    while (node -> left) \
-    { \
-        stack [stackSize ++] = node; \
-        node += node -> left; \
-    } \
-    for (;;) \
-    { \
-        body; \
-        if (node -> right) \
-        { \
-            node += node -> right; \
-            while (node -> left) \
-            { \
-                stack [stackSize ++] = node; \
-                node += node -> left; \
-            } \
-        } \
-        else \
-        if (stackSize <= 0) \
-            break; \
-        else \
-            node = stack [-- stackSize]; \
-    } \
-}
-
-#define ENET_CONTEXT_ENCODE_EXCLUDE(context, value_, under, total, minimum) \
-ENET_CONTEXT_WALK(context, { \
-    if (node -> value != value_) \
-    { \
-        enet_uint16 parentCount = rangeCoder -> symbols [node -> parent].count + minimum; \
-        if (node -> value < value_) \
-          under -= parentCount; \
-        total -= parentCount; \
-    } \
-})
-#endif
-
-size_t
-enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
-    const enet_uint8 * inData, * inEnd;
-    enet_uint32 encodeLow = 0, encodeRange = ~0;
-    ENetSymbol * root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0)
-      return 0;
-
-    inData = (const enet_uint8 *) inBuffers -> data;
-    inEnd = & inData [inBuffers -> dataLength];
-    inBuffers ++;
-    inBufferCount --;
-
-    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    for (;;)
-    {
-        ENetSymbol * subcontext, * symbol;
-#ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol * childContext = & emptyContext;
-#endif
-        enet_uint8 value;
-        enet_uint16 count, under, * parent = & predicted, total;
-        if (inData >= inEnd)
-        {
-            if (inBufferCount <= 0)
-              break;
-            inData = (const enet_uint8 *) inBuffers -> data;
-            inEnd = & inData [inBuffers -> dataLength];
-            inBuffers ++;
-            inBufferCount --;
-        }
-        value = * inData ++;
-    
-        for (subcontext = & rangeCoder -> symbols [predicted]; 
-             subcontext != root; 
-#ifdef ENET_CONTEXT_EXCLUSION
-             childContext = subcontext, 
-#endif
-                subcontext = & rangeCoder -> symbols [subcontext -> parent])
-        {
-            ENET_CONTEXT_ENCODE (subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            * parent = symbol - rangeCoder -> symbols;
-            parent = & symbol -> parent;
-            total = subcontext -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA)
-              ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, 0);
-#endif
-            if (count > 0)
-            {
-                ENET_RANGE_CODER_ENCODE (subcontext -> escapes + under, count, total);
-            }
-            else
-            {
-                if (subcontext -> escapes > 0 && subcontext -> escapes < total) 
-                    ENET_RANGE_CODER_ENCODE (0, subcontext -> escapes, total); 
-                subcontext -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                subcontext -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (subcontext, 0);
-            if (count > 0) goto nextInput;
-        }
-
-        ENET_CONTEXT_ENCODE (root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
-        * parent = symbol - rangeCoder -> symbols;
-        parent = & symbol -> parent;
-        total = root -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA)
-          ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, ENET_CONTEXT_SYMBOL_MINIMUM); 
-#endif
-        ENET_RANGE_CODER_ENCODE (root -> escapes + under, count, total);
-        root -> total += ENET_CONTEXT_SYMBOL_DELTA; 
-        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    nextInput:
-        if (order >= ENET_SUBCONTEXT_ORDER) 
-          predicted = rangeCoder -> symbols [predicted].parent;
-        else 
-          order ++;
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    ENET_RANGE_CODER_FLUSH;
-
-    return (size_t) (outData - outStart);
-}
-
-#define ENET_RANGE_CODER_SEED \
-{ \
-    if (inData < inEnd) decodeCode |= * inData ++ << 24; \
-    if (inData < inEnd) decodeCode |= * inData ++ << 16; \
-    if (inData < inEnd) decodeCode |= * inData ++ << 8; \
-    if (inData < inEnd) decodeCode |= * inData ++; \
-}
-
-#define ENET_RANGE_CODER_READ(total) ((decodeCode - decodeLow) / (decodeRange /= (total)))
-
-#define ENET_RANGE_CODER_DECODE(under, count, total) \
-{ \
-    decodeLow += (under) * decodeRange; \
-    decodeRange *= (count); \
-    for (;;) \
-    { \
-        if((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \
-        { \
-            if(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
-            decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-        } \
-        decodeCode <<= 8; \
-        if (inData < inEnd) \
-          decodeCode |= * inData ++; \
-        decodeRange <<= 8; \
-        decodeLow <<= 8; \
-    } \
-}
-
-#define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, createRoot, visitNode, createRight, createLeft) \
-{ \
-    under_ = 0; \
-    count_ = minimum; \
-    if (! (context) -> symbols) \
-    { \
-        createRoot; \
-    } \
-    else \
-    { \
-        ENetSymbol * node = (context) + (context) -> symbols; \
-        for (;;) \
-        { \
-            enet_uint16 after = under_ + node -> under + (node -> value + 1)*minimum, before = node -> count + minimum; \
-            visitNode; \
-            if (code >= after) \
-            { \
-                under_ += node -> under; \
-                if (node -> right) { node += node -> right; continue; } \
-                createRight; \
-            } \
-            else \
-            if (code < after - before) \
-            { \
-                node -> under += update; \
-                if (node -> left) { node += node -> left; continue; } \
-                createLeft; \
-            } \
-            else \
-            { \
-                value_ = node -> value; \
-                count_ += node -> count; \
-                under_ = after - before; \
-                node -> under += update; \
-                node -> count += update; \
-                symbol_ = node; \
-            } \
-            break; \
-        } \
-    } \
-}
-
-#define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, return 0, exclude (node -> value, after, before), return 0, return 0)
-
-#define ENET_CONTEXT_ROOT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, \
-    { \
-        value_ = code / minimum; \
-        under_ = code - code%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        (context) -> symbols = symbol_ - (context); \
-    }, \
-    exclude (node -> value, after, before), \
-    { \
-        value_ = node->value + 1 + (code - after)/minimum; \
-        under_ = code - (code - after)%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        node -> right = symbol_ - node; \
-    }, \
-    { \
-        value_ = node->value - 1 - (after - before - code - 1)/minimum; \
-        under_ = code - (after - before - code - 1)%minimum; \
-        ENET_SYMBOL_CREATE (symbol_, value_, update); \
-        node -> left = symbol_ - node; \
-    }) \
-
-#ifdef ENET_CONTEXT_EXCLUSION
-typedef struct _ENetExclude
-{
-    enet_uint8 value;
-    enet_uint16 under;
-} ENetExclude;
-
-#define ENET_CONTEXT_DECODE_EXCLUDE(context, total, minimum) \
-{ \
-    enet_uint16 under = 0; \
-    nextExclude = excludes; \
-    ENET_CONTEXT_WALK (context, { \
-        under += rangeCoder -> symbols [node -> parent].count + minimum; \
-        nextExclude -> value = node -> value; \
-        nextExclude -> under = under; \
-        nextExclude ++; \
-    }); \
-    total -= under; \
-}
-
-#define ENET_CONTEXT_EXCLUDED(value_, after, before) \
-{ \
-    size_t low = 0, high = nextExclude - excludes; \
-    for(;;) \
-    { \
-        size_t mid = (low + high) >> 1; \
-        const ENetExclude * exclude = & excludes [mid]; \
-        if (value_ < exclude -> value) \
-        { \
-            if (low + 1 < high) \
-            { \
-                high = mid; \
-                continue; \
-            } \
-            if (exclude > excludes) \
-              after -= exclude [-1].under; \
-        } \
-        else \
-        { \
-            if (value_ > exclude -> value) \
-            { \
-                if (low + 1 < high) \
-                { \
-                    low = mid; \
-                    continue; \
-                } \
-            } \
-            else \
-              before = 0; \
-            after -= exclude -> under; \
-        } \
-        break; \
-    } \
-}
-#endif
-
-#define ENET_CONTEXT_NOT_EXCLUDED(value_, after, before)
-
-size_t
-enet_range_coder_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit)
-{
-    ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
-    const enet_uint8 * inEnd = & inData [inLimit];
-    enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0;
-    ENetSymbol * root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-#ifdef ENET_CONTEXT_EXCLUSION
-    ENetExclude excludes [256];
-    ENetExclude * nextExclude = excludes;
-#endif
-  
-    if (rangeCoder == NULL || inLimit <= 0)
-      return 0;
-
-    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    ENET_RANGE_CODER_SEED;
-
-    for (;;)
-    {
-        ENetSymbol * subcontext, * symbol, * patch;
-#ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol * childContext = & emptyContext;
-#endif
-        enet_uint8 value = 0;
-        enet_uint16 code, under, count, bottom, * parent = & predicted, total;
-
-        for (subcontext = & rangeCoder -> symbols [predicted];
-             subcontext != root;
-#ifdef ENET_CONTEXT_EXCLUSION
-             childContext = subcontext, 
-#endif
-                subcontext = & rangeCoder -> symbols [subcontext -> parent])
-        {
-            if (subcontext -> escapes <= 0)
-              continue;
-            total = subcontext -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > 0) 
-              ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, 0); 
-#endif
-            if (subcontext -> escapes >= total)
-              continue;
-            code = ENET_RANGE_CODER_READ (total);
-            if (code < subcontext -> escapes) 
-            {
-                ENET_RANGE_CODER_DECODE (0, subcontext -> escapes, total); 
-                continue;
-            }
-            code -= subcontext -> escapes;
-#ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext -> total > 0)
-            {
-                ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_EXCLUDED); 
-            }
-            else
-#endif
-            {
-                ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_NOT_EXCLUDED); 
-            }
-            bottom = symbol - rangeCoder -> symbols;
-            ENET_RANGE_CODER_DECODE (subcontext -> escapes + under, count, total);
-            subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (subcontext, 0);
-            goto patchContexts;
-        }
-
-        total = root -> total;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > 0)
-          ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, ENET_CONTEXT_SYMBOL_MINIMUM);  
-#endif
-        code = ENET_RANGE_CODER_READ (total);
-        if (code < root -> escapes)
-        {
-            ENET_RANGE_CODER_DECODE (0, root -> escapes, total);
-            break;
-        }
-        code -= root -> escapes;
-#ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext -> total > 0)
-        {
-            ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_EXCLUDED); 
-        }
-        else
-#endif
-        {
-            ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_NOT_EXCLUDED); 
-        }
-        bottom = symbol - rangeCoder -> symbols;
-        ENET_RANGE_CODER_DECODE (root -> escapes + under, count, total);
-        root -> total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    patchContexts:
-        for (patch = & rangeCoder -> symbols [predicted];
-             patch != subcontext;
-             patch = & rangeCoder -> symbols [patch -> parent])
-        {
-            ENET_CONTEXT_ENCODE (patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            * parent = symbol - rangeCoder -> symbols;
-            parent = & symbol -> parent;
-            if (count <= 0)
-            {
-                patch -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                patch -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            patch -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 
-            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || patch -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_CONTEXT_RESCALE (patch, 0);
-        }
-        * parent = bottom;
-
-        ENET_RANGE_CODER_OUTPUT (value);
-
-        if (order >= ENET_SUBCONTEXT_ORDER)
-          predicted = rangeCoder -> symbols [predicted].parent;
-        else
-          order ++;
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-                        
-    return (size_t) (outData - outStart);
-}
-
-/** @defgroup host ENet host functions
-    @{
-*/
-
-/** Sets the packet compressor the host should use to the default range coder.
-    @param host host to enable the range coder for
-    @returns 0 on success, < 0 on failure
-*/
-int
-enet_host_compress_with_range_coder (ENetHost * host)
-{
-    ENetCompressor compressor;
-    memset (& compressor, 0, sizeof (compressor));
-    compressor.context = enet_range_coder_create();
-    if (compressor.context == NULL)
-      return -1;
-    compressor.compress = enet_range_coder_compress;
-    compressor.decompress = enet_range_coder_decompress;
-    compressor.destroy = enet_range_coder_destroy;
-    enet_host_compress (host, & compressor);
-    return 0;
-}
-    
-/** @} */
-    
-     

src/compress.c.us.c

@@ -1,661 +0,0 @@
-/**
- * @file compress.c
- * @brief An adaptive order-2 PPM range coder
- */
-#define ENET_BUILDING_LIB 1
-#include <string.h>
-#include "enet/enet.h"
-
-typedef struct _ENetSymbol {
-    /* binary indexed tree of symbols */
-    enet_uint8  value;
-    enet_uint8  count;
-    enet_uint16 under;
-    enet_uint16 left, right;
-
-    /* context defined by this symbol */
-    enet_uint16 symbols;
-    enet_uint16 escapes;
-    enet_uint16 total;
-    enet_uint16 parent;
-} ENetSymbol;
-
-/* adaptation constants tuned aggressively for small packet sizes rather than large file compression */
-enum {
-    ENET_RANGE_CODER_TOP         = 1 << 24,
-    ENET_RANGE_CODER_BOTTOM      = 1 << 16,
-
-    ENET_CONTEXT_SYMBOL_DELTA    = 3,
-    ENET_CONTEXT_SYMBOL_MINIMUM  = 1,
-    ENET_CONTEXT_ESCAPE_MINIMUM  = 1,
-
-    ENET_SUBCONTEXT_ORDER        = 2,
-    ENET_SUBCONTEXT_SYMBOL_DELTA = 2,
-    ENET_SUBCONTEXT_ESCAPE_DELTA = 5
-};
-
-/* context exclusion roughly halves compression speed, so disable for now */
-#undef ENET_CONTEXT_EXCLUSION
-
-typedef struct _ENetRangeCoder {
-    /* only allocate enough symbols for reasonable MTUs, would need to be larger for large file compression */
-    ENetSymbol symbols[4096];
-} ENetRangeCoder;
-
-void * enet_range_coder_create(void) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) enet_malloc(sizeof(ENetRangeCoder));
-
-    if (rangeCoder == NULL) {
-        return NULL;
-    }
-
-    return rangeCoder;
-}
-
-void enet_range_coder_destroy(void *context) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-
-    if (rangeCoder == NULL) {
-        return;
-    }
-
-    enet_free(rangeCoder);
-}
-
-#define ENET_SYMBOL_CREATE(symbol, value_, count_) \
-    { \
-        symbol          = &rangeCoder->symbols [nextSymbol++]; \
-        symbol->value   = value_; \
-        symbol->count   = count_; \
-        symbol->under   = count_; \
-        symbol->left    = 0; \
-        symbol->right   = 0; \
-        symbol->symbols = 0; \
-        symbol->escapes = 0; \
-        symbol->total   = 0; \
-        symbol->parent  = 0; \
-    }
-
-#define ENET_CONTEXT_CREATE(context, escapes_, minimum) \
-    { \
-        ENET_SYMBOL_CREATE(context, 0, 0); \
-        (context)->escapes = escapes_; \
-        (context)->total   = escapes_ + 256 * minimum; \
-        (context)->symbols = 0; \
-    }
-
-static enet_uint16 enet_symbol_rescale(ENetSymbol *symbol) {
-    enet_uint16 total = 0;
-
-    for (;;) {
-        symbol->count -= symbol->count >> 1;
-        symbol->under  = symbol->count;
-        if (symbol->left) {
-            symbol->under += enet_symbol_rescale(symbol + symbol->left);
-        }
-        total += symbol->under;
-        if (!symbol->right) { break; }
-        symbol += symbol->right;
-    }
-    return total;
-}
-
-#define ENET_CONTEXT_RESCALE(context, minimum) \
-    { \
-        (context)->total    = (context)->symbols ? enet_symbol_rescale((context) + (context)->symbols) : 0; \
-        (context)->escapes -= (context)->escapes >> 1; \
-        (context)->total   += (context)->escapes + 256 * minimum; \
-    }
-
-#define ENET_RANGE_CODER_OUTPUT(value) \
-    { \
-        if (outData >= outEnd) { \
-            return 0; } \
-        *outData++ = value; \
-    }
-
-#define ENET_RANGE_CODER_ENCODE(under, count, total) \
-    { \
-        encodeRange /= (total); \
-        encodeLow   += (under) * encodeRange; \
-        encodeRange *= (count); \
-        for (;;) \
-        { \
-            if ((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
-            { \
-                if (encodeRange >= ENET_RANGE_CODER_BOTTOM) { break; } \
-                encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-            } \
-            ENET_RANGE_CODER_OUTPUT(encodeLow >> 24); \
-            encodeRange <<= 8; \
-            encodeLow   <<= 8; \
-        } \
-    }
-
-#define ENET_RANGE_CODER_FLUSH \
-    { \
-        while (encodeLow) \
-        { \
-            ENET_RANGE_CODER_OUTPUT(encodeLow >> 24); \
-            encodeLow <<= 8; \
-        } \
-    }
-
-#define ENET_RANGE_CODER_FREE_SYMBOLS \
-    { \
-        if (nextSymbol >= sizeof(rangeCoder->symbols) / sizeof(ENetSymbol) - ENET_SUBCONTEXT_ORDER) \
-        { \
-            nextSymbol = 0; \
-            ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
-            predicted = 0; \
-            order     = 0; \
-        } \
-    }
-
-#define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update, minimum) \
-    { \
-        under_ = value * minimum; \
-        count_ = minimum; \
-        if (!(context)->symbols) \
-        { \
-            ENET_SYMBOL_CREATE(symbol_, value_, update); \
-            (context)->symbols = symbol_ - (context); \
-        } \
-        else \
-        { \
-            ENetSymbol *node = (context) + (context)->symbols; \
-            for (;;) \
-            { \
-                if (value_ < node->value) \
-                { \
-                    node->under += update; \
-                    if (node->left) { node += node->left; continue; } \
-                    ENET_SYMBOL_CREATE(symbol_, value_, update); \
-                    node->left = symbol_ - node; \
-                } \
-                else if (value_ > node->value) \
-                { \
-                    under_ += node->under; \
-                    if (node->right) { node += node->right; continue; } \
-                    ENET_SYMBOL_CREATE(symbol_, value_, update); \
-                    node->right = symbol_ - node; \
-                } \
-                else \
-                { \
-                    count_      += node->count; \
-                    under_      += node->under - node->count; \
-                    node->under += update; \
-                    node->count += update; \
-                    symbol_      = node; \
-                } \
-                break; \
-            } \
-        } \
-    }
-
-#ifdef ENET_CONTEXT_EXCLUSION
-static const ENetSymbol emptyContext = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-# define ENET_CONTEXT_WALK(context, body) \
-    { \
-        const ENetSymbol *node = (context) + (context)->symbols; \
-        const ENetSymbol *stack [256]; \
-        size_t stackSize = 0; \
-        while (node->left) \
-        { \
-            stack [stackSize++] = node; \
-            node += node->left; \
-        } \
-        for (;;) \
-        { \
-            body; \
-            if (node->right) \
-            { \
-                node += node->right; \
-                while (node->left) \
-                { \
-                    stack [stackSize++] = node; \
-                    node += node->left; \
-                } \
-            } \
-            else if (stackSize <= 0) { \
-                break; } \
-            else { \
-                node = stack [--stackSize]; } \
-        } \
-    }
-
-# define ENET_CONTEXT_ENCODE_EXCLUDE(context, value_, under, total, minimum) \
-    ENET_CONTEXT_WALK(context, { \
-        if (node->value != value_) \
-        { \
-            enet_uint16 parentCount = rangeCoder->symbols [node->parent].count + minimum; \
-            if (node->value < value_) { \
-                under -= parentCount; } \
-            total -= parentCount; \
-        } \
-    })
-#endif /* ifdef ENET_CONTEXT_EXCLUSION */
-
-size_t enet_range_coder_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit,
-  enet_uint8 *outData, size_t outLimit) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 *outStart = outData, *outEnd = &outData [outLimit];
-    const enet_uint8 *inData, *inEnd;
-    enet_uint32 encodeLow = 0, encodeRange = ~0;
-    ENetSymbol *root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0) {
-        return 0;
-    }
-
-    inData = (const enet_uint8 *) inBuffers->data;
-    inEnd  = &inData [inBuffers->dataLength];
-    inBuffers++;
-    inBufferCount--;
-
-    ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    for (;;) {
-        ENetSymbol *subcontext, *symbol;
-        #ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol *childContext = &emptyContext;
-        #endif
-        enet_uint8 value;
-        enet_uint16 count, under, *parent = &predicted, total;
-        if (inData >= inEnd) {
-            if (inBufferCount <= 0) {
-                break;
-            }
-            inData = (const enet_uint8 *) inBuffers->data;
-            inEnd  = &inData [inBuffers->dataLength];
-            inBuffers++;
-            inBufferCount--;
-        }
-        value = *inData++;
-
-        for (subcontext = &rangeCoder->symbols [predicted];
-          subcontext != root;
-          #ifdef ENET_CONTEXT_EXCLUSION
-          childContext = subcontext,
-          #endif
-          subcontext = &rangeCoder->symbols [subcontext->parent])
-        {
-            ENET_CONTEXT_ENCODE(subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            *parent = symbol - rangeCoder->symbols;
-            parent  = &symbol->parent;
-            total   = subcontext->total;
-            #ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) {
-                ENET_CONTEXT_ENCODE_EXCLUDE(childContext, value, under, total, 0);
-            }
-            #endif
-            if (count > 0) {
-                ENET_RANGE_CODER_ENCODE(subcontext->escapes + under, count, total);
-            } else {
-                if (subcontext->escapes > 0 && subcontext->escapes < total) {
-                    ENET_RANGE_CODER_ENCODE(0, subcontext->escapes, total);
-                }
-                subcontext->escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                subcontext->total   += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            subcontext->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA ||
-              subcontext->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-            {
-                ENET_CONTEXT_RESCALE(subcontext, 0);
-            }
-            if (count > 0) { goto nextInput; }
-        }
-
-        ENET_CONTEXT_ENCODE(root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
-        *parent = symbol - rangeCoder->symbols;
-        parent  = &symbol->parent;
-        total   = root->total;
-        #ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) {
-            ENET_CONTEXT_ENCODE_EXCLUDE(childContext, value, under, total, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-        #endif
-        ENET_RANGE_CODER_ENCODE(root->escapes + under, count, total);
-        root->total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2 * ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM ||
-          root->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-        {
-            ENET_CONTEXT_RESCALE(root, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-
-nextInput:
-        if (order >= ENET_SUBCONTEXT_ORDER) {
-            predicted = rangeCoder->symbols [predicted].parent;
-        } else {
-            order++;
-        }
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    ENET_RANGE_CODER_FLUSH;
-
-    return (size_t) (outData - outStart);
-} /* enet_range_coder_compress */
-
-#define ENET_RANGE_CODER_SEED \
-    { \
-        if (inData < inEnd) { decodeCode |= *inData++ << 24; } \
-        if (inData < inEnd) { decodeCode |= *inData++ << 16; } \
-        if (inData < inEnd) { decodeCode |= *inData++ << 8; } \
-        if (inData < inEnd) { decodeCode |= *inData++; } \
-    }
-
-#define ENET_RANGE_CODER_READ(total) ((decodeCode - decodeLow) / (decodeRange /= (total)))
-
-#define ENET_RANGE_CODER_DECODE(under, count, total) \
-    { \
-        decodeLow   += (under) * decodeRange; \
-        decodeRange *= (count); \
-        for (;;) \
-        { \
-            if ((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \
-            { \
-                if (decodeRange >= ENET_RANGE_CODER_BOTTOM) { break; } \
-                decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
-            } \
-            decodeCode <<= 8; \
-            if (inData < inEnd) { \
-                decodeCode |= *inData++; } \
-            decodeRange <<= 8; \
-            decodeLow   <<= 8; \
-        } \
-    }
-
-#define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, createRoot, visitNode, \
-      createRight, createLeft) \
-    { \
-        under_ = 0; \
-        count_ = minimum; \
-        if (!(context)->symbols) \
-        { \
-            createRoot; \
-        } \
-        else \
-        { \
-            ENetSymbol *node = (context) + (context)->symbols; \
-            for (;;) \
-            { \
-                enet_uint16 after = under_ + node->under + (node->value + 1) * minimum, before = node->count + minimum; \
-                visitNode; \
-                if (code >= after) \
-                { \
-                    under_ += node->under; \
-                    if (node->right) { node += node->right; continue; } \
-                    createRight; \
-                } \
-                else if (code < after - before) \
-                { \
-                    node->under += update; \
-                    if (node->left) { node += node->left; continue; } \
-                    createLeft; \
-                } \
-                else \
-                { \
-                    value_       = node->value; \
-                    count_      += node->count; \
-                    under_       = after - before; \
-                    node->under += update; \
-                    node->count += update; \
-                    symbol_      = node; \
-                } \
-                break; \
-            } \
-        } \
-    }
-
-#define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-    ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, return 0, \
-      exclude(node->value, after, before), return 0, return 0)
-
-#define ENET_CONTEXT_ROOT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \
-    ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, \
-    { \
-        value_ = code / minimum; \
-        under_ = code - code % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        (context)->symbols = symbol_ - (context); \
-    }, \
-      exclude(node->value, after, before), \
-    { \
-        value_ = node->value + 1 + (code - after) / minimum; \
-        under_ = code - (code - after) % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        node->right = symbol_ - node; \
-    }, \
-    { \
-        value_ = node->value - 1 - (after - before - code - 1) / minimum; \
-        under_ = code - (after - before - code - 1) % minimum; \
-        ENET_SYMBOL_CREATE(symbol_, value_, update); \
-        node->left = symbol_ - node; \
-    }) \
-
-#ifdef ENET_CONTEXT_EXCLUSION
-typedef struct _ENetExclude {
-    enet_uint8  value;
-    enet_uint16 under;
-} ENetExclude;
-
-# define ENET_CONTEXT_DECODE_EXCLUDE(context, total, minimum) \
-    { \
-        enet_uint16 under = 0; \
-        nextExclude = excludes; \
-        ENET_CONTEXT_WALK(context, { \
-            under += rangeCoder->symbols [node->parent].count + minimum; \
-            nextExclude->value = node->value; \
-            nextExclude->under = under; \
-            nextExclude++; \
-        }); \
-        total -= under; \
-    }
-
-# define ENET_CONTEXT_EXCLUDED(value_, after, before) \
-    { \
-        size_t low = 0, high = nextExclude - excludes; \
-        for (;;) \
-        { \
-            size_t mid = (low + high) >> 1; \
-            const ENetExclude *exclude = &excludes [mid]; \
-            if (value_ < exclude->value) \
-            { \
-                if (low + 1 < high) \
-                { \
-                    high = mid; \
-                    continue; \
-                } \
-                if (exclude > excludes) { \
-                    after -= exclude [-1].under; } \
-            } \
-            else \
-            { \
-                if (value_ > exclude->value) \
-                { \
-                    if (low + 1 < high) \
-                    { \
-                        low = mid; \
-                        continue; \
-                    } \
-                } \
-                else { \
-                    before = 0; } \
-                after -= exclude->under; \
-            } \
-            break; \
-        } \
-    }
-#endif /* ifdef ENET_CONTEXT_EXCLUSION */
-
-#define ENET_CONTEXT_NOT_EXCLUDED(value_, after, before)
-
-size_t enet_range_coder_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData,
-  size_t outLimit) {
-    ENetRangeCoder *rangeCoder = (ENetRangeCoder *) context;
-    enet_uint8 *outStart = outData, *outEnd = &outData [outLimit];
-    const enet_uint8 *inEnd = &inData [inLimit];
-    enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0;
-    ENetSymbol *root;
-    enet_uint16 predicted = 0;
-    size_t order = 0, nextSymbol = 0;
-
-    #ifdef ENET_CONTEXT_EXCLUSION
-    ENetExclude excludes [256];
-    ENetExclude *nextExclude = excludes;
-    #endif
-
-    if (rangeCoder == NULL || inLimit <= 0) {
-        return 0;
-    }
-
-    ENET_CONTEXT_CREATE(root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
-
-    ENET_RANGE_CODER_SEED;
-
-    for (;;) {
-        ENetSymbol *subcontext, *symbol, *patch;
-        #ifdef ENET_CONTEXT_EXCLUSION
-        const ENetSymbol *childContext = &emptyContext;
-        #endif
-        enet_uint8 value = 0;
-        enet_uint16 code, under, count, bottom, *parent = &predicted, total;
-
-        for (subcontext = &rangeCoder->symbols [predicted];
-          subcontext != root;
-          #ifdef ENET_CONTEXT_EXCLUSION
-          childContext = subcontext,
-          #endif
-          subcontext = &rangeCoder->symbols [subcontext->parent])
-        {
-            if (subcontext->escapes <= 0) {
-                continue;
-            }
-            total = subcontext->total;
-            #ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > 0) {
-                ENET_CONTEXT_DECODE_EXCLUDE(childContext, total, 0);
-            }
-            #endif
-            if (subcontext->escapes >= total) {
-                continue;
-            }
-            code = ENET_RANGE_CODER_READ(total);
-            if (code < subcontext->escapes) {
-                ENET_RANGE_CODER_DECODE(0, subcontext->escapes, total);
-                continue;
-            }
-            code -= subcontext->escapes;
-            #ifdef ENET_CONTEXT_EXCLUSION
-            if (childContext->total > 0) {
-                ENET_CONTEXT_TRY_DECODE(subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0,
-                  ENET_CONTEXT_EXCLUDED);
-            } else
-            #endif
-            {
-                ENET_CONTEXT_TRY_DECODE(subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0,
-                  ENET_CONTEXT_NOT_EXCLUDED);
-            }
-            bottom = symbol - rangeCoder->symbols;
-            ENET_RANGE_CODER_DECODE(subcontext->escapes + under, count, total);
-            subcontext->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA ||
-              subcontext->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-            {
-                ENET_CONTEXT_RESCALE(subcontext, 0);
-            }
-            goto patchContexts;
-        }
-
-        total = root->total;
-        #ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > 0) {
-            ENET_CONTEXT_DECODE_EXCLUDE(childContext, total, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-        #endif
-        code = ENET_RANGE_CODER_READ(total);
-        if (code < root->escapes) {
-            ENET_RANGE_CODER_DECODE(0, root->escapes, total);
-            break;
-        }
-        code -= root->escapes;
-        #ifdef ENET_CONTEXT_EXCLUSION
-        if (childContext->total > 0) {
-            ENET_CONTEXT_ROOT_DECODE(root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA,
-              ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_EXCLUDED);
-        } else
-        #endif
-        {
-            ENET_CONTEXT_ROOT_DECODE(root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA,
-              ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_NOT_EXCLUDED);
-        }
-        bottom = symbol - rangeCoder->symbols;
-        ENET_RANGE_CODER_DECODE(root->escapes + under, count, total);
-        root->total += ENET_CONTEXT_SYMBOL_DELTA;
-        if (count > 0xFF - 2 * ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM ||
-          root->total > ENET_RANGE_CODER_BOTTOM - 0x100)
-        {
-            ENET_CONTEXT_RESCALE(root, ENET_CONTEXT_SYMBOL_MINIMUM);
-        }
-
-patchContexts:
-        for (patch = &rangeCoder->symbols [predicted];
-          patch != subcontext;
-          patch = &rangeCoder->symbols [patch->parent])
-        {
-            ENET_CONTEXT_ENCODE(patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0);
-            *parent = symbol - rangeCoder->symbols;
-            parent  = &symbol->parent;
-            if (count <= 0) {
-                patch->escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                patch->total   += ENET_SUBCONTEXT_ESCAPE_DELTA;
-            }
-            patch->total += ENET_SUBCONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2 * ENET_SUBCONTEXT_SYMBOL_DELTA || patch->total > ENET_RANGE_CODER_BOTTOM - 0x100) {
-                ENET_CONTEXT_RESCALE(patch, 0);
-            }
-        }
-        *parent = bottom;
-
-        ENET_RANGE_CODER_OUTPUT(value);
-
-        if (order >= ENET_SUBCONTEXT_ORDER) {
-            predicted = rangeCoder->symbols [predicted].parent;
-        } else {
-            order++;
-        }
-        ENET_RANGE_CODER_FREE_SYMBOLS;
-    }
-
-    return (size_t) (outData - outStart);
-} /* enet_range_coder_decompress */
-
-/** @defgroup host ENet host functions
- *  @{
- */
-
-/** Sets the packet compressor the host should use to the default range coder.
- *  @param host host to enable the range coder for
- *  @returns 0 on success, < 0 on failure
- */
-int enet_host_compress_with_range_coder(ENetHost *host) {
-    ENetCompressor compressor;
-
-    memset(&compressor, 0, sizeof(compressor));
-    compressor.context = enet_range_coder_create();
-    if (compressor.context == NULL) {
-        return -1;
-    }
-    compressor.compress   = enet_range_coder_compress;
-    compressor.decompress = enet_range_coder_decompress;
-    compressor.destroy    = enet_range_coder_destroy;
-    enet_host_compress(host, &compressor);
-    return 0;
-}
-
-/** @} */

src/host.c

@@ -1,492 +0,0 @@
-/** 
- @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 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 && enet_socket_get_address (host -> socket, & host -> address) < 0)   
-      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) (size_t) host;
-    host -> randomSeed += enet_host_random_seed ();
-    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 -> connectedPeers = 0;
-    host -> bandwidthLimitedPeers = 0;
-    host -> duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    host -> maximumPacketSize = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
-    host -> maximumWaitingData = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
-
-    host -> compressor.context = NULL;
-    host -> compressor.compress = NULL;
-    host -> compressor.decompress = NULL;
-    host -> compressor.destroy = NULL;
-
-    host -> intercept = 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;
-
-    if (host == NULL)
-      return;
-
-    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,
-           peersRemaining = (enet_uint32) host -> connectedPeers,
-           dataTotal = ~0,
-           bandwidth = ~0,
-           throttle = 0,
-           bandwidthLimit = 0;
-    int needsAdjustment = host -> bandwidthLimitedPeers > 0 ? 1 : 0;
-    ENetPeer * peer;
-    ENetProtocol command;
-
-    if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
-      return;
-
-    host -> bandwidthThrottleEpoch = timeCurrent;
-
-    if (peersRemaining == 0)
-      return;
-
-    if (host -> outgoingBandwidth != 0)
-    {
-        dataTotal = 0;
-        bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
-
-        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;
-
-            dataTotal += peer -> outgoingDataTotal;
-        }
-    }
-
-    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;
-
-            peer -> incomingDataTotal = 0;
-            peer -> outgoingDataTotal = 0;
-
-            needsAdjustment = 1;
-            -- peersRemaining;
-            bandwidth -= peerBandwidth;
-            dataTotal -= peerBandwidth;
-        }
-    }
-
-    if (peersRemaining > 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)
-        {
-            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;
-
-            peer -> incomingDataTotal = 0;
-            peer -> outgoingDataTotal = 0;
-        }
-    }
-
-    if (host -> recalculateBandwidthLimits)
-    {
-       host -> recalculateBandwidthLimits = 0;
-
-       peersRemaining = (enet_uint32) host -> connectedPeers;
-       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);
-       } 
-    }
-}
-    
-/** @} */

src/host.c.us.c

@@ -1,503 +0,0 @@
-/**
- * @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 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 && enet_socket_get_address(host->socket, &host->address) < 0) {
-        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) (size_t) host;
-    host->randomSeed                += enet_host_random_seed();
-    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->connectedPeers        = 0;
-    host->bandwidthLimitedPeers = 0;
-    host->duplicatePeers        = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    host->maximumPacketSize     = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
-    host->maximumWaitingData    = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
-
-    host->compressor.context    = NULL;
-    host->compressor.compress   = NULL;
-    host->compressor.decompress = NULL;
-    host->compressor.destroy    = NULL;
-
-    host->intercept = 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;
-} /* enet_host_create */
-
-/** 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;
-
-    if (host == NULL) {
-        return;
-    }
-
-    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;
-} /* enet_host_connect */
-
-/** 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,
-      peersRemaining    = (enet_uint32) host->connectedPeers,
-      dataTotal         = ~0,
-      bandwidth         = ~0,
-      throttle          = 0,
-      bandwidthLimit    = 0;
-    int needsAdjustment = host->bandwidthLimitedPeers > 0 ? 1 : 0;
-    ENetPeer *peer;
-    ENetProtocol command;
-
-    if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
-        return;
-    }
-
-    host->bandwidthThrottleEpoch = timeCurrent;
-
-    if (peersRemaining == 0) {
-        return;
-    }
-
-    if (host->outgoingBandwidth != 0) {
-        dataTotal = 0;
-        bandwidth = (host->outgoingBandwidth * elapsedTime) / 1000;
-
-        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;
-            }
-
-            dataTotal += peer->outgoingDataTotal;
-        }
-    }
-
-    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;
-
-            peer->incomingDataTotal = 0;
-            peer->outgoingDataTotal = 0;
-
-            needsAdjustment = 1;
-            --peersRemaining;
-            bandwidth -= peerBandwidth;
-            dataTotal -= peerBandwidth;
-        }
-    }
-
-    if (peersRemaining > 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)
-        {
-            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;
-            }
-
-            peer->incomingDataTotal = 0;
-            peer->outgoingDataTotal = 0;
-        }
-    }
-
-    if (host->recalculateBandwidthLimits) {
-        host->recalculateBandwidthLimits = 0;
-
-        peersRemaining  = (enet_uint32) host->connectedPeers;
-        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);
-        }
-    }
-} /* enet_host_bandwidth_throttle */
-
-/** @} */

src/list.c

@@ -1,75 +0,0 @@
-/** 
- @file list.c
- @brief ENet linked list functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** 
-    @defgroup list ENet linked list utility functions
-    @ingroup private
-    @{
-*/
-void
-enet_list_clear (ENetList * list)
-{
-   list -> sentinel.next = & list -> sentinel;
-   list -> sentinel.previous = & list -> sentinel;
-}
-
-ENetListIterator
-enet_list_insert (ENetListIterator position, void * data)
-{
-   ENetListIterator result = (ENetListIterator) data;
-
-   result -> previous = position -> previous;
-   result -> next = position;
-
-   result -> previous -> next = result;
-   position -> previous = result;
-
-   return result;
-}
-
-void *
-enet_list_remove (ENetListIterator position)
-{
-   position -> previous -> next = position -> next;
-   position -> next -> previous = position -> previous;
-
-   return position;
-}
-
-ENetListIterator
-enet_list_move (ENetListIterator position, void * dataFirst, void * dataLast)
-{
-   ENetListIterator first = (ENetListIterator) dataFirst,
-                    last = (ENetListIterator) dataLast;
-
-   first -> previous -> next = last -> next;
-   last -> next -> previous = first -> previous;
-
-   first -> previous = position -> previous;
-   last -> next = position;
-
-   first -> previous -> next = first;
-   position -> previous = last;
-    
-   return first;
-}
-
-size_t
-enet_list_size (ENetList * list)
-{
-   size_t size = 0;
-   ENetListIterator position;
-
-   for (position = enet_list_begin (list);
-        position != enet_list_end (list);
-        position = enet_list_next (position))
-     ++ size;
-   
-   return size;
-}
-
-/** @} */

src/list.c.us.c

@@ -1,65 +0,0 @@
-/**
- * @file list.c
- * @brief ENet linked list functions
- */
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/**
- *  @defgroup list ENet linked list utility functions
- *  @ingroup private
- *  @{
- */
-void enet_list_clear(ENetList *list) {
-    list->sentinel.next     = &list->sentinel;
-    list->sentinel.previous = &list->sentinel;
-}
-
-ENetListIterator enet_list_insert(ENetListIterator position, void *data) {
-    ENetListIterator result = (ENetListIterator) data;
-
-    result->previous = position->previous;
-    result->next     = position;
-
-    result->previous->next = result;
-    position->previous     = result;
-
-    return result;
-}
-
-void * enet_list_remove(ENetListIterator position) {
-    position->previous->next = position->next;
-    position->next->previous = position->previous;
-
-    return position;
-}
-
-ENetListIterator enet_list_move(ENetListIterator position, void *dataFirst, void *dataLast) {
-    ENetListIterator first = (ENetListIterator) dataFirst,
-      last = (ENetListIterator) dataLast;
-
-    first->previous->next = last->next;
-    last->next->previous  = first->previous;
-
-    first->previous = position->previous;
-    last->next      = position;
-
-    first->previous->next = first;
-    position->previous    = last;
-
-    return first;
-}
-
-size_t enet_list_size(ENetList *list) {
-    size_t size = 0;
-    ENetListIterator position;
-
-    for (position = enet_list_begin(list);
-      position != enet_list_end(list);
-      position = enet_list_next(position))
-        ++size;
-
-    return size;
-}
-
-/** @} */

src/packet.c

@@ -1,199 +0,0 @@
-/** 
- @file  packet.c
- @brief ENet packet management functions
-*/
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** @defgroup Packet ENet packet functions 
-    @{ 
-*/
-
-/** Creates a packet that may be sent to a peer.
-    @param data         initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL.
-    @param dataLength   size of the data allocated for this packet
-    @param flags        flags for this packet as described for the ENetPacket structure.
-    @returns the packet on success, NULL on failure
-*/
-ENetPacket *
-enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
-{
-    ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
-    if (packet == NULL)
-      return NULL;
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE)
-      packet -> data = (enet_uint8 *) data;
-    else
-    if (dataLength <= 0)
-      packet -> data = NULL;
-    else
-    {
-       packet -> data = (enet_uint8 *) enet_malloc (dataLength);
-       if (packet -> data == NULL)
-       {
-          enet_free (packet);
-          return NULL;
-       }
-
-       if (data != NULL)
-         memcpy (packet -> data, data, dataLength);
-    }
-
-    packet -> referenceCount = 0;
-    packet -> flags = flags;
-    packet -> dataLength = dataLength;
-    packet -> freeCallback = NULL;
-    packet -> userData = NULL;
-
-    return packet;
-}
-
-ENetPacket *
-enet_packet_create_offset (const void * data, size_t dataLength, size_t dataOffset, enet_uint32 flags)
-{
-    ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
-    if (packet == NULL)
-      return NULL;
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE)
-      packet -> data = (enet_uint8 *) data;
-    else
-    if ((dataLength + dataOffset) <= 0)
-      packet -> data = NULL;
-    else
-    {
-       packet -> data = (enet_uint8 *) enet_malloc (dataLength + dataOffset);
-       if (packet -> data == NULL)
-       {
-          enet_free (packet);
-          return NULL;
-       }
-
-       if (data != NULL)
-         memcpy (packet -> data + dataOffset, data, dataLength);
-    }
-
-    packet -> referenceCount = 0;
-    packet -> flags = flags;
-    packet -> dataLength = dataLength + dataOffset;
-    packet -> freeCallback = NULL;
-    packet -> userData = NULL;
-
-    return packet;
-}
-
-/** Destroys the packet and deallocates its data.
-    @param packet packet to be destroyed
-*/
-void
-enet_packet_destroy (ENetPacket * packet)
-{
-    if (packet == NULL)
-      return;
-
-    if (packet -> freeCallback != NULL)
-      (* packet -> freeCallback) (packet);
-    if (! (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE) &&
-        packet -> data != NULL)
-      enet_free (packet -> data);
-    enet_free (packet);
-}
-
-/** Attempts to resize the data in the packet to length specified in the 
-    dataLength parameter 
-    @param packet packet to resize
-    @param dataLength new size for the packet data
-    @returns 0 on success, < 0 on failure
-*/
-int
-enet_packet_resize (ENetPacket * packet, size_t dataLength)
-{
-    enet_uint8 * newData;
-   
-    if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
-    {
-       packet -> dataLength = dataLength;
-
-       return 0;
-    }
-
-    newData = (enet_uint8 *) enet_malloc (dataLength);
-    if (newData == NULL)
-      return -1;
-
-    memcpy (newData, packet -> data, packet -> dataLength);
-    enet_free (packet -> data);
-    
-    packet -> data = newData;
-    packet -> dataLength = dataLength;
-
-    return 0;
-}
-
-static int initializedCRC32 = 0;
-static enet_uint32 crcTable [256];
-
-static enet_uint32 
-reflect_crc (int val, int bits)
-{
-    int result = 0, bit;
-
-    for (bit = 0; bit < bits; bit ++)
-    {
-        if(val & 1) result |= 1 << (bits - 1 - bit); 
-        val >>= 1;
-    }
-
-    return result;
-}
-
-static void 
-initialize_crc32 (void)
-{
-    int byte;
-
-    for (byte = 0; byte < 256; ++ byte)
-    {
-        enet_uint32 crc = reflect_crc (byte, 8) << 24;
-        int offset;
-
-        for(offset = 0; offset < 8; ++ offset)
-        {
-            if (crc & 0x80000000)
-                crc = (crc << 1) ^ 0x04c11db7;
-            else
-                crc <<= 1;
-        }
-
-        crcTable [byte] = reflect_crc (crc, 32);
-    }
-
-    initializedCRC32 = 1;
-}
-    
-enet_uint32
-enet_crc32 (const ENetBuffer * buffers, size_t bufferCount)
-{
-    enet_uint32 crc = 0xFFFFFFFF;
-    
-    if (! initializedCRC32) initialize_crc32 ();
-
-    while (bufferCount -- > 0)
-    {
-        const enet_uint8 * data = (const enet_uint8 *) buffers -> data,
-                         * dataEnd = & data [buffers -> dataLength];
-
-        while (data < dataEnd)
-        {
-            crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++];        
-        }
-
-        ++ buffers;
-    }
-
-    return ENET_HOST_TO_NET_32 (~ crc);
-}
-
-/** @} */

src/packet.c.us.c

@@ -1,185 +0,0 @@
-/**
- * @file  packet.c
- * @brief ENet packet management functions
- */
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** @defgroup Packet ENet packet functions
- *  @{
- */
-
-/** Creates a packet that may be sent to a peer.
- *  @param data         initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL.
- *  @param dataLength   size of the data allocated for this packet
- *  @param flags        flags for this packet as described for the ENetPacket structure.
- *  @returns the packet on success, NULL on failure
- */
-ENetPacket * enet_packet_create(const void *data, size_t dataLength, enet_uint32 flags) {
-    ENetPacket *packet = (ENetPacket *) enet_malloc(sizeof(ENetPacket));
-
-    if (packet == NULL) {
-        return NULL;
-    }
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-        packet->data = (enet_uint8 *) data;
-    } else if (dataLength <= 0)   {
-        packet->data = NULL;
-    } else {
-        packet->data = (enet_uint8 *) enet_malloc(dataLength);
-        if (packet->data == NULL) {
-            enet_free(packet);
-            return NULL;
-        }
-
-        if (data != NULL) {
-            memcpy(packet->data, data, dataLength);
-        }
-    }
-
-    packet->referenceCount = 0;
-    packet->flags        = flags;
-    packet->dataLength   = dataLength;
-    packet->freeCallback = NULL;
-    packet->userData     = NULL;
-
-    return packet;
-}
-
-ENetPacket * enet_packet_create_offset(const void *data, size_t dataLength, size_t dataOffset, enet_uint32 flags) {
-    ENetPacket *packet = (ENetPacket *) enet_malloc(sizeof(ENetPacket));
-
-    if (packet == NULL) {
-        return NULL;
-    }
-
-    if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-        packet->data = (enet_uint8 *) data;
-    } else if ((dataLength + dataOffset) <= 0)   {
-        packet->data = NULL;
-    } else {
-        packet->data = (enet_uint8 *) enet_malloc(dataLength + dataOffset);
-        if (packet->data == NULL) {
-            enet_free(packet);
-            return NULL;
-        }
-
-        if (data != NULL) {
-            memcpy(packet->data + dataOffset, data, dataLength);
-        }
-    }
-
-    packet->referenceCount = 0;
-    packet->flags        = flags;
-    packet->dataLength   = dataLength + dataOffset;
-    packet->freeCallback = NULL;
-    packet->userData     = NULL;
-
-    return packet;
-}
-
-/** Destroys the packet and deallocates its data.
- *  @param packet packet to be destroyed
- */
-void enet_packet_destroy(ENetPacket *packet) {
-    if (packet == NULL) {
-        return;
-    }
-
-    if (packet->freeCallback != NULL) {
-        (*packet->freeCallback)(packet);
-    }
-    if (!(packet->flags & ENET_PACKET_FLAG_NO_ALLOCATE) &&
-      packet->data != NULL)
-    {
-        enet_free(packet->data);
-    }
-    enet_free(packet);
-}
-
-/** Attempts to resize the data in the packet to length specified in the
- *  dataLength parameter
- *  @param packet packet to resize
- *  @param dataLength new size for the packet data
- *  @returns 0 on success, < 0 on failure
- */
-int enet_packet_resize(ENetPacket *packet, size_t dataLength) {
-    enet_uint8 *newData;
-
-    if (dataLength <= packet->dataLength || (packet->flags & ENET_PACKET_FLAG_NO_ALLOCATE)) {
-        packet->dataLength = dataLength;
-
-        return 0;
-    }
-
-    newData = (enet_uint8 *) enet_malloc(dataLength);
-    if (newData == NULL) {
-        return -1;
-    }
-
-    memcpy(newData, packet->data, packet->dataLength);
-    enet_free(packet->data);
-
-    packet->data       = newData;
-    packet->dataLength = dataLength;
-
-    return 0;
-}
-
-static int initializedCRC32 = 0;
-static enet_uint32 crcTable [256];
-
-static enet_uint32 reflect_crc(int val, int bits) {
-    int result = 0, bit;
-
-    for (bit = 0; bit < bits; bit++) {
-        if (val & 1) { result |= 1 << (bits - 1 - bit); }
-        val >>= 1;
-    }
-
-    return result;
-}
-
-static void initialize_crc32(void) {
-    int byte;
-
-    for (byte = 0; byte < 256; ++byte) {
-        enet_uint32 crc = reflect_crc(byte, 8) << 24;
-        int offset;
-
-        for (offset = 0; offset < 8; ++offset) {
-            if (crc & 0x80000000) {
-                crc = (crc << 1) ^ 0x04c11db7;
-            } else {
-                crc <<= 1;
-            }
-        }
-
-        crcTable [byte] = reflect_crc(crc, 32);
-    }
-
-    initializedCRC32 = 1;
-}
-
-enet_uint32 enet_crc32(const ENetBuffer *buffers, size_t bufferCount) {
-    enet_uint32 crc = 0xFFFFFFFF;
-
-    if (!initializedCRC32) { initialize_crc32(); }
-
-    while (bufferCount-- > 0) {
-        const enet_uint8 *data = (const enet_uint8 *) buffers->data,
-          *dataEnd = &data [buffers->dataLength];
-
-        while (data < dataEnd) {
-            crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++];
-        }
-
-        ++buffers;
-    }
-
-    return ENET_HOST_TO_NET_32(~crc);
-}
-
-/** @} */

src/peer.c

@@ -1,1004 +0,0 @@
-/** 
- @file  peer.c
- @brief ENet peer management functions
-*/
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** @defgroup peer ENet peer functions 
-    @{
-*/
-
-/** Configures throttle parameter for a peer.
-
-    Unreliable packets are dropped by ENet in response to the varying conditions
-    of the Internet connection to the peer.  The throttle represents a probability
-    that an unreliable packet should not be dropped and thus sent by ENet to the peer.
-    The lowest mean round trip time from the sending of a reliable packet to the
-    receipt of its acknowledgement is measured over an amount of time specified by
-    the interval parameter in milliseconds.  If a measured round trip time happens to
-    be significantly less than the mean round trip time measured over the interval, 
-    then the throttle probability is increased to allow more traffic by an amount
-    specified in the acceleration parameter, which is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
-    constant.  If a measured round trip time happens to be significantly greater than
-    the mean round trip time measured over the interval, then the throttle probability
-    is decreased to limit traffic by an amount specified in the deceleration parameter, which
-    is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE constant.  When the throttle has
-    a value of ENET_PEER_PACKET_THROTTLE_SCALE, no unreliable packets are dropped by 
-    ENet, and so 100% of all unreliable packets will be sent.  When the throttle has a
-    value of 0, all unreliable packets are dropped by ENet, and so 0% of all unreliable
-    packets will be sent.  Intermediate values for the throttle represent intermediate
-    probabilities between 0% and 100% of unreliable packets being sent.  The bandwidth
-    limits of the local and foreign hosts are taken into account to determine a 
-    sensible limit for the throttle probability above which it should not raise even in
-    the best of conditions.
-
-    @param peer peer to configure 
-    @param interval interval, in milliseconds, over which to measure lowest mean RTT; the default value is ENET_PEER_PACKET_THROTTLE_INTERVAL.
-    @param acceleration rate at which to increase the throttle probability as mean RTT declines
-    @param deceleration rate at which to decrease the throttle probability as mean RTT increases
-*/
-void
-enet_peer_throttle_configure (ENetPeer * peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration)
-{
-    ENetProtocol command;
-
-    peer -> packetThrottleInterval = interval;
-    peer -> packetThrottleAcceleration = acceleration;
-    peer -> packetThrottleDeceleration = deceleration;
-
-    command.header.command = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-
-    command.throttleConfigure.packetThrottleInterval = ENET_HOST_TO_NET_32 (interval);
-    command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (acceleration);
-    command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (deceleration);
-
-    enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-}
-
-int
-enet_peer_throttle (ENetPeer * peer, enet_uint32 rtt)
-{
-    if (peer -> lastRoundTripTime <= peer -> lastRoundTripTimeVariance)
-    {
-        peer -> packetThrottle = peer -> packetThrottleLimit;
-    }
-    else
-    if (rtt < peer -> lastRoundTripTime)
-    {
-        peer -> packetThrottle += peer -> packetThrottleAcceleration;
-
-        if (peer -> packetThrottle > peer -> packetThrottleLimit)
-          peer -> packetThrottle = peer -> packetThrottleLimit;
-
-        return 1;
-    }
-    else
-    if (rtt > peer -> lastRoundTripTime + 2 * peer -> lastRoundTripTimeVariance)
-    {
-        if (peer -> packetThrottle > peer -> packetThrottleDeceleration)
-          peer -> packetThrottle -= peer -> packetThrottleDeceleration;
-        else
-          peer -> packetThrottle = 0;
-
-        return -1;
-    }
-
-    return 0;
-}
-
-/** Queues a packet to be sent.
-    @param peer destination for the packet
-    @param channelID channel on which to send
-    @param packet packet to send
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-int
-enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet)
-{
-   ENetChannel * channel = & peer -> channels [channelID];
-   ENetProtocol command;
-   size_t fragmentLength;
-
-   if (peer -> state != ENET_PEER_STATE_CONNECTED ||
-       channelID >= peer -> channelCount ||
-       packet -> dataLength > peer -> host -> maximumPacketSize)
-     return -1;
-
-   fragmentLength = peer -> mtu - sizeof (ENetProtocolHeader) - sizeof (ENetProtocolSendFragment);
-   if (peer -> host -> checksum != NULL)
-     fragmentLength -= sizeof(enet_uint32);
-
-   if (packet -> dataLength > fragmentLength)
-   {
-      enet_uint32 fragmentCount = (packet -> dataLength + fragmentLength - 1) / fragmentLength,
-             fragmentNumber,
-             fragmentOffset;
-      enet_uint8 commandNumber;
-      enet_uint16 startSequenceNumber; 
-      ENetList fragments;
-      ENetOutgoingCommand * fragment;
-
-      if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT)
-        return -1;
-
-      if ((packet -> flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT)) == ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT &&
-          channel -> outgoingUnreliableSequenceNumber < 0xFFFF)
-      {
-         commandNumber = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT;
-         startSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingUnreliableSequenceNumber + 1);
-      }
-      else
-      {
-         commandNumber = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-         startSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingReliableSequenceNumber + 1);
-      }
-        
-      enet_list_clear (& fragments);
-
-      for (fragmentNumber = 0,
-             fragmentOffset = 0;
-           fragmentOffset < packet -> dataLength;
-           ++ fragmentNumber,
-             fragmentOffset += fragmentLength)
-      {
-         if (packet -> dataLength - fragmentOffset < fragmentLength)
-           fragmentLength = packet -> dataLength - fragmentOffset;
-
-         fragment = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand));
-         if (fragment == NULL)
-         {
-            while (! enet_list_empty (& fragments))
-            {
-               fragment = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (& fragments));
-               
-               enet_free (fragment);
-            }
-            
-            return -1;
-         }
-         
-         fragment -> fragmentOffset = fragmentOffset;
-         fragment -> fragmentLength = fragmentLength;
-         fragment -> packet = packet;
-         fragment -> command.header.command = commandNumber;
-         fragment -> command.header.channelID = channelID;
-         fragment -> command.sendFragment.startSequenceNumber = startSequenceNumber;
-         fragment -> command.sendFragment.dataLength = ENET_HOST_TO_NET_16 (fragmentLength);
-         fragment -> command.sendFragment.fragmentCount = ENET_HOST_TO_NET_32 (fragmentCount);
-         fragment -> command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32 (fragmentNumber);
-         fragment -> command.sendFragment.totalLength = ENET_HOST_TO_NET_32 (packet -> dataLength);
-         fragment -> command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32 (fragmentOffset);
-        
-         enet_list_insert (enet_list_end (& fragments), fragment);
-      }
-
-      packet -> referenceCount += fragmentNumber;
-
-      while (! enet_list_empty (& fragments))
-      {
-         fragment = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (& fragments));
- 
-         enet_peer_setup_outgoing_command (peer, fragment);
-      }
-
-      return 0;
-   }
-
-   command.header.channelID = channelID;
-
-   if ((packet -> flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) == ENET_PACKET_FLAG_UNSEQUENCED)
-   {
-      command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-      command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
-   }
-   else 
-   if (packet -> flags & ENET_PACKET_FLAG_RELIABLE || channel -> outgoingUnreliableSequenceNumber >= 0xFFFF)
-   {
-      command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-      command.sendReliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
-   }
-   else
-   {
-      command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
-      command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
-   }
-
-   if (enet_peer_queue_outgoing_command (peer, & command, packet, 0, packet -> dataLength) == NULL)
-     return -1;
-
-   return 0;
-}
-
-/** Attempts to dequeue any incoming queued packet.
-    @param peer peer to dequeue packets from
-    @param channelID holds the channel ID of the channel the packet was received on success
-    @returns a pointer to the packet, or NULL if there are no available incoming queued packets
-*/
-ENetPacket *
-enet_peer_receive (ENetPeer * peer, enet_uint8 * channelID)
-{
-   ENetIncomingCommand * incomingCommand;
-   ENetPacket * packet;
-   
-   if (enet_list_empty (& peer -> dispatchedCommands))
-     return NULL;
-
-   incomingCommand = (ENetIncomingCommand *) enet_list_remove (enet_list_begin (& peer -> dispatchedCommands));
-
-   if (channelID != NULL)
-     * channelID = incomingCommand -> command.header.channelID;
-
-   packet = incomingCommand -> packet;
-
-   -- packet -> referenceCount;
-
-   if (incomingCommand -> fragments != NULL)
-     enet_free (incomingCommand -> fragments);
-
-   enet_free (incomingCommand);
-
-   peer -> totalWaitingData -= packet -> dataLength;
-
-   return packet;
-}
-
-static void
-enet_peer_reset_outgoing_commands (ENetList * queue)
-{
-    ENetOutgoingCommand * outgoingCommand;
-
-    while (! enet_list_empty (queue))
-    {
-       outgoingCommand = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (queue));
-
-       if (outgoingCommand -> packet != NULL)
-       {
-          -- outgoingCommand -> packet -> referenceCount;
-
-          if (outgoingCommand -> packet -> referenceCount == 0)
-            enet_packet_destroy (outgoingCommand -> packet);
-       }
-
-       enet_free (outgoingCommand);
-    }
-}
-
-static void
-enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startCommand, ENetListIterator endCommand)
-{
-    ENetListIterator currentCommand;    
-    
-    for (currentCommand = startCommand; currentCommand != endCommand; )
-    {
-       ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-       currentCommand = enet_list_next (currentCommand);
-
-       enet_list_remove (& incomingCommand -> incomingCommandList);
- 
-       if (incomingCommand -> packet != NULL)
-       {
-          -- incomingCommand -> packet -> referenceCount;
-
-          if (incomingCommand -> packet -> referenceCount == 0)
-            enet_packet_destroy (incomingCommand -> packet);
-       }
-
-       if (incomingCommand -> fragments != NULL)
-         enet_free (incomingCommand -> fragments);
-
-       enet_free (incomingCommand);
-    }
-}
-
-static void
-enet_peer_reset_incoming_commands (ENetList * queue)
-{
-    enet_peer_remove_incoming_commands(queue, enet_list_begin (queue), enet_list_end (queue));
-}
- 
-void
-enet_peer_reset_queues (ENetPeer * peer)
-{
-    ENetChannel * channel;
-
-    if (peer -> needsDispatch)
-    {
-       enet_list_remove (& peer -> dispatchList);
-
-       peer -> needsDispatch = 0;
-    }
-
-    while (! enet_list_empty (& peer -> acknowledgements))
-      enet_free (enet_list_remove (enet_list_begin (& peer -> acknowledgements)));
-
-    enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands);
-    enet_peer_reset_outgoing_commands (& peer -> sentUnreliableCommands);
-    enet_peer_reset_outgoing_commands (& peer -> outgoingReliableCommands);
-    enet_peer_reset_outgoing_commands (& peer -> outgoingUnreliableCommands);
-    enet_peer_reset_incoming_commands (& peer -> dispatchedCommands);
-
-    if (peer -> channels != NULL && peer -> channelCount > 0)
-    {
-        for (channel = peer -> channels;
-             channel < & peer -> channels [peer -> channelCount];
-             ++ channel)
-        {
-            enet_peer_reset_incoming_commands (& channel -> incomingReliableCommands);
-            enet_peer_reset_incoming_commands (& channel -> incomingUnreliableCommands);
-        }
-
-        enet_free (peer -> channels);
-    }
-
-    peer -> channels = NULL;
-    peer -> channelCount = 0;
-}
-
-void
-enet_peer_on_connect (ENetPeer * peer)
-{
-    if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-    {
-        if (peer -> incomingBandwidth != 0)
-          ++ peer -> host -> bandwidthLimitedPeers;
-
-        ++ peer -> host -> connectedPeers;
-    }
-}
-
-void
-enet_peer_on_disconnect (ENetPeer * peer)
-{
-    if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
-    {
-        if (peer -> incomingBandwidth != 0)
-          -- peer -> host -> bandwidthLimitedPeers;
-
-        -- peer -> host -> connectedPeers;
-    }
-}
-
-/** Forcefully disconnects a peer.
-    @param peer peer to forcefully disconnect
-    @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
-    on its connection to the local host.
-*/
-void
-enet_peer_reset (ENetPeer * peer)
-{
-    enet_peer_on_disconnect (peer);
-        
-    peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    peer -> connectID = 0;
-
-    peer -> state = ENET_PEER_STATE_DISCONNECTED;
-
-    peer -> incomingBandwidth = 0;
-    peer -> outgoingBandwidth = 0;
-    peer -> incomingBandwidthThrottleEpoch = 0;
-    peer -> outgoingBandwidthThrottleEpoch = 0;
-    peer -> incomingDataTotal = 0;
-    peer -> outgoingDataTotal = 0;
-    peer -> lastSendTime = 0;
-    peer -> lastReceiveTime = 0;
-    peer -> nextTimeout = 0;
-    peer -> earliestTimeout = 0;
-    peer -> packetLossEpoch = 0;
-    peer -> packetsSent = 0;
-    peer -> packetsLost = 0;
-    peer -> packetLoss = 0;
-    peer -> packetLossVariance = 0;
-    peer -> packetThrottle = ENET_PEER_DEFAULT_PACKET_THROTTLE;
-    peer -> packetThrottleLimit = ENET_PEER_PACKET_THROTTLE_SCALE;
-    peer -> packetThrottleCounter = 0;
-    peer -> packetThrottleEpoch = 0;
-    peer -> packetThrottleAcceleration = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
-    peer -> packetThrottleDeceleration = ENET_PEER_PACKET_THROTTLE_DECELERATION;
-    peer -> packetThrottleInterval = ENET_PEER_PACKET_THROTTLE_INTERVAL;
-    peer -> pingInterval = ENET_PEER_PING_INTERVAL;
-    peer -> timeoutLimit = ENET_PEER_TIMEOUT_LIMIT;
-    peer -> timeoutMinimum = ENET_PEER_TIMEOUT_MINIMUM;
-    peer -> timeoutMaximum = ENET_PEER_TIMEOUT_MAXIMUM;
-    peer -> lastRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer -> lowestRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer -> lastRoundTripTimeVariance = 0;
-    peer -> highestRoundTripTimeVariance = 0;
-    peer -> roundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer -> roundTripTimeVariance = 0;
-    peer -> mtu = peer -> host -> mtu;
-    peer -> reliableDataInTransit = 0;
-    peer -> outgoingReliableSequenceNumber = 0;
-    peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    peer -> incomingUnsequencedGroup = 0;
-    peer -> outgoingUnsequencedGroup = 0;
-    peer -> eventData = 0;
-    peer -> totalWaitingData = 0;
-
-    memset (peer -> unsequencedWindow, 0, sizeof (peer -> unsequencedWindow));
-    
-    enet_peer_reset_queues (peer);
-}
-
-/** Sends a ping request to a peer.
-    @param peer destination for the ping request
-    @remarks ping requests factor into the mean round trip time as designated by the 
-    roundTripTime field in the ENetPeer structure.  ENet automatically pings all connected
-    peers at regular intervals, however, this function may be called to ensure more
-    frequent ping requests.
-*/
-void
-enet_peer_ping (ENetPeer * peer)
-{
-    ENetProtocol command;
-
-    if (peer -> state != ENET_PEER_STATE_CONNECTED)
-      return;
-
-    command.header.command = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-   
-    enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-}
-
-/** Sets the interval at which pings will be sent to a peer. 
-    
-    Pings are used both to monitor the liveness of the connection and also to dynamically
-    adjust the throttle during periods of low traffic so that the throttle has reasonable
-    responsiveness during traffic spikes.
-
-    @param peer the peer to adjust
-    @param pingInterval the interval at which to send pings; defaults to ENET_PEER_PING_INTERVAL if 0
-*/
-void
-enet_peer_ping_interval (ENetPeer * peer, enet_uint32 pingInterval)
-{
-    peer -> pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
-}
-
-/** Sets the timeout parameters for a peer.
-
-    The timeout parameter control how and when a peer will timeout from a failure to acknowledge
-    reliable traffic. Timeout values use an exponential backoff mechanism, where if a reliable
-    packet is not acknowledge within some multiple of the average RTT plus a variance tolerance, 
-    the timeout will be doubled until it reaches a set limit. If the timeout is thus at this
-    limit and reliable packets have been sent but not acknowledged within a certain minimum time 
-    period, the peer will be disconnected. Alternatively, if reliable packets have been sent
-    but not acknowledged for a certain maximum time period, the peer will be disconnected regardless
-    of the current timeout limit value.
-    
-    @param peer the peer to adjust
-    @param timeoutLimit the timeout limit; defaults to ENET_PEER_TIMEOUT_LIMIT if 0
-    @param timeoutMinimum the timeout minimum; defaults to ENET_PEER_TIMEOUT_MINIMUM if 0
-    @param timeoutMaximum the timeout maximum; defaults to ENET_PEER_TIMEOUT_MAXIMUM if 0
-*/
-
-void
-enet_peer_timeout (ENetPeer * peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum)
-{
-    peer -> timeoutLimit = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
-    peer -> timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
-    peer -> timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
-}
-
-/** Force an immediate disconnection from a peer.
-    @param peer peer to disconnect
-    @param data data describing the disconnection
-    @remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
-    guaranteed to receive the disconnect notification, and is reset immediately upon
-    return from this function.
-*/
-void
-enet_peer_disconnect_now (ENetPeer * peer, enet_uint32 data)
-{
-    ENetProtocol command;
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECTED)
-      return;
-
-    if (peer -> state != ENET_PEER_STATE_ZOMBIE &&
-        peer -> state != ENET_PEER_STATE_DISCONNECTING)
-    {
-        enet_peer_reset_queues (peer);
-
-        command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        command.header.channelID = 0xFF;
-        command.disconnect.data = ENET_HOST_TO_NET_32 (data);
-
-        enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-
-        enet_host_flush (peer -> host);
-    }
-
-    enet_peer_reset (peer);
-}
-
-/** Request a disconnection from a peer.
-    @param peer peer to request a disconnection
-    @param data data describing the disconnection
-    @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
-    once the disconnection is complete.
-*/
-void
-enet_peer_disconnect (ENetPeer * peer, enet_uint32 data)
-{
-    ENetProtocol command;
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECTING ||
-        peer -> state == ENET_PEER_STATE_DISCONNECTED ||
-        peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
-        peer -> state == ENET_PEER_STATE_ZOMBIE)
-      return;
-
-    enet_peer_reset_queues (peer);
-
-    command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT;
-    command.header.channelID = 0xFF;
-    command.disconnect.data = ENET_HOST_TO_NET_32 (data);
-
-    if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
-      command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    else
-      command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;      
-    
-    enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-
-    if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
-    {
-        enet_peer_on_disconnect (peer);
-
-        peer -> state = ENET_PEER_STATE_DISCONNECTING;
-    }
-    else
-    {
-        enet_host_flush (peer -> host);
-        enet_peer_reset (peer);
-    }
-}
-
-/** Request a disconnection from a peer, but only after all queued outgoing packets are sent.
-    @param peer peer to request a disconnection
-    @param data data describing the disconnection
-    @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
-    once the disconnection is complete.
-*/
-void
-enet_peer_disconnect_later (ENetPeer * peer, enet_uint32 data)
-{   
-    if ((peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) && 
-        ! (enet_list_empty (& peer -> outgoingReliableCommands) &&
-           enet_list_empty (& peer -> outgoingUnreliableCommands) && 
-           enet_list_empty (& peer -> sentReliableCommands)))
-    {
-        peer -> state = ENET_PEER_STATE_DISCONNECT_LATER;
-        peer -> eventData = data;
-    }
-    else
-      enet_peer_disconnect (peer, data);
-}
-
-ENetAcknowledgement *
-enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint16 sentTime)
-{
-    ENetAcknowledgement * acknowledgement;
-
-    if (command -> header.channelID < peer -> channelCount)
-    {
-        ENetChannel * channel = & peer -> channels [command -> header.channelID];
-        enet_uint16 reliableWindow = command -> header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-                    currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (command -> header.reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
-           reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-
-        if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 && reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS)
-          return NULL;
-    }
-
-    acknowledgement = (ENetAcknowledgement *) enet_malloc (sizeof (ENetAcknowledgement));
-    if (acknowledgement == NULL)
-      return NULL;
-
-    peer -> outgoingDataTotal += sizeof (ENetProtocolAcknowledge);
-
-    acknowledgement -> sentTime = sentTime;
-    acknowledgement -> command = * command;
-    
-    enet_list_insert (enet_list_end (& peer -> acknowledgements), acknowledgement);
-    
-    return acknowledgement;
-}
-
-void
-enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoingCommand)
-{
-    ENetChannel * channel = & peer -> channels [outgoingCommand -> command.header.channelID];
-    
-    peer -> outgoingDataTotal += enet_protocol_command_size (outgoingCommand -> command.header.command) + outgoingCommand -> fragmentLength;
-
-    if (outgoingCommand -> command.header.channelID == 0xFF)
-    {
-       ++ peer -> outgoingReliableSequenceNumber;
-
-       outgoingCommand -> reliableSequenceNumber = peer -> outgoingReliableSequenceNumber;
-       outgoingCommand -> unreliableSequenceNumber = 0;
-    }
-    else
-    if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
-    {
-       ++ channel -> outgoingReliableSequenceNumber;
-       channel -> outgoingUnreliableSequenceNumber = 0;
-
-       outgoingCommand -> reliableSequenceNumber = channel -> outgoingReliableSequenceNumber;
-       outgoingCommand -> unreliableSequenceNumber = 0;
-    }
-    else
-    if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED)
-    {
-       ++ peer -> 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 = ENET_HOST_TO_NET_16 (outgoingCommand -> reliableSequenceNumber);
-
-    switch (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK)
-    {
-    case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-        outgoingCommand -> command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16 (outgoingCommand -> unreliableSequenceNumber);
-        break;
-
-    case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-        outgoingCommand -> command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16 (peer -> outgoingUnsequencedGroup);
-        break;
-    
-    default:
-        break;
-    }
-
-    if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
-      enet_list_insert (enet_list_end (& peer -> outgoingReliableCommands), outgoingCommand);
-    else
-      enet_list_insert (enet_list_end (& peer -> outgoingUnreliableCommands), outgoingCommand);
-}
-
-ENetOutgoingCommand *
-enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 offset, enet_uint16 length)
-{
-    ENetOutgoingCommand * outgoingCommand = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand));
-    if (outgoingCommand == NULL)
-      return NULL;
-
-    outgoingCommand -> command = * command;
-    outgoingCommand -> fragmentOffset = offset;
-    outgoingCommand -> fragmentLength = length;
-    outgoingCommand -> packet = packet;
-    if (packet != NULL)
-      ++ packet -> referenceCount;
-
-    enet_peer_setup_outgoing_command (peer, outgoingCommand);
-
-    return outgoingCommand;
-}
-
-void
-enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel * channel)
-{
-    ENetListIterator droppedCommand, startCommand, currentCommand;
-
-    for (droppedCommand = startCommand = currentCommand = enet_list_begin (& channel -> incomingUnreliableCommands);
-         currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);
-         currentCommand = enet_list_next (currentCommand))
-    {
-       ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-       if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
-         continue;
-
-       if (incomingCommand -> reliableSequenceNumber == channel -> incomingReliableSequenceNumber)
-       {
-          if (incomingCommand -> fragmentsRemaining <= 0)
-          {
-             channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber;
-             continue;
-          }
-
-          if (startCommand != currentCommand)
-          {
-             enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));
-
-             if (! peer -> needsDispatch)
-             {
-                enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
-
-                peer -> needsDispatch = 1;
-             }
-
-             droppedCommand = currentCommand;
-          }
-          else
-          if (droppedCommand != currentCommand)
-            droppedCommand = enet_list_previous (currentCommand);
-       }
-       else 
-       {
-          enet_uint16 reliableWindow = incomingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-                      currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-          if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-          if (reliableWindow >= currentWindow && reliableWindow < currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-            break;
-
-          droppedCommand = enet_list_next (currentCommand);
-
-          if (startCommand != currentCommand)
-          {
-             enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));
-
-             if (! peer -> needsDispatch)
-             {
-                enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
-
-                peer -> needsDispatch = 1;
-             }
-          }
-       }
-          
-       startCommand = enet_list_next (currentCommand);
-    }
-
-    if (startCommand != currentCommand)
-    {
-       enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));
-
-       if (! peer -> needsDispatch)
-       {
-           enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
-
-           peer -> needsDispatch = 1;
-       }
-
-       droppedCommand = currentCommand;
-    }
-
-    enet_peer_remove_incoming_commands (& channel -> incomingUnreliableCommands, enet_list_begin (& channel -> incomingUnreliableCommands), droppedCommand);
-}
-
-void
-enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * channel)
-{
-    ENetListIterator currentCommand;
-
-    for (currentCommand = enet_list_begin (& channel -> incomingReliableCommands);
-         currentCommand != enet_list_end (& channel -> incomingReliableCommands);
-         currentCommand = enet_list_next (currentCommand))
-    {
-       ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
-         
-       if (incomingCommand -> fragmentsRemaining > 0 ||
-           incomingCommand -> reliableSequenceNumber != (enet_uint16) (channel -> incomingReliableSequenceNumber + 1))
-         break;
-
-       channel -> incomingReliableSequenceNumber = incomingCommand -> reliableSequenceNumber;
-
-       if (incomingCommand -> fragmentCount > 0)
-         channel -> incomingReliableSequenceNumber += incomingCommand -> fragmentCount - 1;
-    } 
-
-    if (currentCommand == enet_list_begin (& channel -> incomingReliableCommands))
-      return;
-
-    channel -> incomingUnreliableSequenceNumber = 0;
-
-    enet_list_move (enet_list_end (& peer -> dispatchedCommands), enet_list_begin (& channel -> incomingReliableCommands), enet_list_previous (currentCommand));
-
-    if (! peer -> needsDispatch)
-    {
-       enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
-
-       peer -> needsDispatch = 1;
-    }
-
-    if (! enet_list_empty (& channel -> incomingUnreliableCommands))
-       enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
-}
-
-ENetIncomingCommand *
-enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, const void * data, size_t dataLength, enet_uint32 flags, enet_uint32 fragmentCount)
-{
-    static ENetIncomingCommand dummyCommand;
-
-    ENetChannel * channel = & peer -> channels [command -> header.channelID];
-    enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber = 0;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetIncomingCommand * incomingCommand;
-    ENetListIterator currentCommand;
-    ENetPacket * packet = NULL;
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
-      goto discardCommand;
-
-    if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
-    {
-        reliableSequenceNumber = command -> header.reliableSequenceNumber;
-        reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
-           reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-
-        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-          goto discardCommand;
-    }
-                    
-    switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK)
-    {
-    case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-    case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-       if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber)
-         goto discardCommand;
-       
-       for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
-            currentCommand != enet_list_end (& channel -> incomingReliableCommands);
-            currentCommand = enet_list_previous (currentCommand))
-       {
-          incomingCommand = (ENetIncomingCommand *) 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;
-
-             goto discardCommand;
-          }
-       }
-       break;
-
-    case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-    case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-       unreliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendUnreliable.unreliableSequenceNumber);
-
-       if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber && 
-           unreliableSequenceNumber <= channel -> incomingUnreliableSequenceNumber)
-         goto discardCommand;
-
-       for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands));
-            currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);
-            currentCommand = enet_list_previous (currentCommand))
-       {
-          incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-          if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
-            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;
-
-             goto discardCommand;
-          }
-       }
-       break;
-
-    case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-       currentCommand = enet_list_end (& channel -> incomingUnreliableCommands);
-       break;
-
-    default:
-       goto discardCommand;
-    }
-
-    if (peer -> totalWaitingData >= peer -> host -> maximumWaitingData)
-      goto notifyError;
-
-    packet = enet_packet_create (data, dataLength, flags);
-    if (packet == NULL)
-      goto notifyError;
-
-    incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand));
-    if (incomingCommand == NULL)
-      goto notifyError;
-
-    incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber;
-    incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF;
-    incomingCommand -> command = * command;
-    incomingCommand -> fragmentCount = fragmentCount;
-    incomingCommand -> fragmentsRemaining = fragmentCount;
-    incomingCommand -> packet = packet;
-    incomingCommand -> fragments = NULL;
-    
-    if (fragmentCount > 0)
-    { 
-       if (fragmentCount <= ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT)
-         incomingCommand -> fragments = (enet_uint32 *) enet_malloc ((fragmentCount + 31) / 32 * sizeof (enet_uint32));
-       if (incomingCommand -> fragments == NULL)
-       {
-          enet_free (incomingCommand);
-
-          goto notifyError;
-       }
-       memset (incomingCommand -> fragments, 0, (fragmentCount + 31) / 32 * sizeof (enet_uint32));
-    }
-
-    if (packet != NULL)
-    {
-       ++ packet -> referenceCount;
-      
-       peer -> totalWaitingData += packet -> dataLength;
-    }
-
-    enet_list_insert (enet_list_next (currentCommand), incomingCommand);
-
-    switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK)
-    {
-    case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-    case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-       enet_peer_dispatch_incoming_reliable_commands (peer, channel);
-       break;
-
-    default:
-       enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
-       break;
-    }
-
-    return incomingCommand;
-
-discardCommand:
-    if (fragmentCount > 0)
-      goto notifyError;
-
-    if (packet != NULL && packet -> referenceCount == 0)
-      enet_packet_destroy (packet);
-
-    return & dummyCommand;
-
-notifyError:
-    if (packet != NULL && packet -> referenceCount == 0)
-      enet_packet_destroy (packet);
-
-    return NULL;
-}
-
-/** @} */

src/peer.c.us.c

@@ -1,974 +0,0 @@
-/**
- * @file  peer.c
- * @brief ENet peer management functions
- */
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-/** @defgroup peer ENet peer functions
- *  @{
- */
-
-/** Configures throttle parameter for a peer.
- *
- *  Unreliable packets are dropped by ENet in response to the varying conditions
- *  of the Internet connection to the peer.  The throttle represents a probability
- *  that an unreliable packet should not be dropped and thus sent by ENet to the peer.
- *  The lowest mean round trip time from the sending of a reliable packet to the
- *  receipt of its acknowledgement is measured over an amount of time specified by
- *  the interval parameter in milliseconds.  If a measured round trip time happens to
- *  be significantly less than the mean round trip time measured over the interval,
- *  then the throttle probability is increased to allow more traffic by an amount
- *  specified in the acceleration parameter, which is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
- *  constant.  If a measured round trip time happens to be significantly greater than
- *  the mean round trip time measured over the interval, then the throttle probability
- *  is decreased to limit traffic by an amount specified in the deceleration parameter, which
- *  is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE constant.  When the throttle has
- *  a value of ENET_PEER_PACKET_THROTTLE_SCALE, no unreliable packets are dropped by
- *  ENet, and so 100% of all unreliable packets will be sent.  When the throttle has a
- *  value of 0, all unreliable packets are dropped by ENet, and so 0% of all unreliable
- *  packets will be sent.  Intermediate values for the throttle represent intermediate
- *  probabilities between 0% and 100% of unreliable packets being sent.  The bandwidth
- *  limits of the local and foreign hosts are taken into account to determine a
- *  sensible limit for the throttle probability above which it should not raise even in
- *  the best of conditions.
- *
- *  @param peer peer to configure
- *  @param interval interval, in milliseconds, over which to measure lowest mean RTT; the default value is ENET_PEER_PACKET_THROTTLE_INTERVAL.
- *  @param acceleration rate at which to increase the throttle probability as mean RTT declines
- *  @param deceleration rate at which to decrease the throttle probability as mean RTT increases
- */
-void enet_peer_throttle_configure(ENetPeer *peer, enet_uint32 interval, enet_uint32 acceleration,
-  enet_uint32 deceleration) {
-    ENetProtocol command;
-
-    peer->packetThrottleInterval     = interval;
-    peer->packetThrottleAcceleration = acceleration;
-    peer->packetThrottleDeceleration = deceleration;
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-
-    command.throttleConfigure.packetThrottleInterval     = ENET_HOST_TO_NET_32(interval);
-    command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32(acceleration);
-    command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32(deceleration);
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-}
-
-int enet_peer_throttle(ENetPeer *peer, enet_uint32 rtt) {
-    if (peer->lastRoundTripTime <= peer->lastRoundTripTimeVariance) {
-        peer->packetThrottle = peer->packetThrottleLimit;
-    } else if (rtt < peer->lastRoundTripTime) {
-        peer->packetThrottle += peer->packetThrottleAcceleration;
-
-        if (peer->packetThrottle > peer->packetThrottleLimit) {
-            peer->packetThrottle = peer->packetThrottleLimit;
-        }
-
-        return 1;
-    } else if (rtt > peer->lastRoundTripTime + 2 * peer->lastRoundTripTimeVariance) {
-        if (peer->packetThrottle > peer->packetThrottleDeceleration) {
-            peer->packetThrottle -= peer->packetThrottleDeceleration;
-        } else {
-            peer->packetThrottle = 0;
-        }
-
-        return -1;
-    }
-
-    return 0;
-}
-
-/** Queues a packet to be sent.
- *  @param peer destination for the packet
- *  @param channelID channel on which to send
- *  @param packet packet to send
- *  @retval 0 on success
- *  @retval < 0 on failure
- */
-int enet_peer_send(ENetPeer *peer, enet_uint8 channelID, ENetPacket *packet) {
-    ENetChannel *channel = &peer->channels [channelID];
-    ENetProtocol command;
-    size_t fragmentLength;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTED ||
-      channelID >= peer->channelCount ||
-      packet->dataLength > peer->host->maximumPacketSize)
-    {
-        return -1;
-    }
-
-    fragmentLength = peer->mtu - sizeof(ENetProtocolHeader) - sizeof(ENetProtocolSendFragment);
-    if (peer->host->checksum != NULL) {
-        fragmentLength -= sizeof(enet_uint32);
-    }
-
-    if (packet->dataLength > fragmentLength) {
-        enet_uint32 fragmentCount = (packet->dataLength + fragmentLength - 1) / fragmentLength,
-          fragmentNumber,
-          fragmentOffset;
-        enet_uint8 commandNumber;
-        enet_uint16 startSequenceNumber;
-        ENetList fragments;
-        ENetOutgoingCommand *fragment;
-
-        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-            return -1;
-        }
-
-        if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT)) ==
-          ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT &&
-          channel->outgoingUnreliableSequenceNumber < 0xFFFF)
-        {
-            commandNumber       = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT;
-            startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingUnreliableSequenceNumber + 1);
-        } else {
-            commandNumber       = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-            startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingReliableSequenceNumber + 1);
-        }
-
-        enet_list_clear(&fragments);
-
-        for (fragmentNumber = 0,
-          fragmentOffset = 0;
-          fragmentOffset < packet->dataLength;
-          ++fragmentNumber,
-          fragmentOffset += fragmentLength)
-        {
-            if (packet->dataLength - fragmentOffset < fragmentLength) {
-                fragmentLength = packet->dataLength - fragmentOffset;
-            }
-
-            fragment = (ENetOutgoingCommand *) enet_malloc(sizeof(ENetOutgoingCommand));
-            if (fragment == NULL) {
-                while (!enet_list_empty(&fragments)) {
-                    fragment = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(&fragments));
-
-                    enet_free(fragment);
-                }
-
-                return -1;
-            }
-
-            fragment->fragmentOffset           = fragmentOffset;
-            fragment->fragmentLength           = fragmentLength;
-            fragment->packet                   = packet;
-            fragment->command.header.command   = commandNumber;
-            fragment->command.header.channelID = channelID;
-            fragment->command.sendFragment.startSequenceNumber = startSequenceNumber;
-            fragment->command.sendFragment.dataLength     = ENET_HOST_TO_NET_16(fragmentLength);
-            fragment->command.sendFragment.fragmentCount  = ENET_HOST_TO_NET_32(fragmentCount);
-            fragment->command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32(fragmentNumber);
-            fragment->command.sendFragment.totalLength    = ENET_HOST_TO_NET_32(packet->dataLength);
-            fragment->command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32(fragmentOffset);
-
-            enet_list_insert(enet_list_end(&fragments), fragment);
-        }
-
-        packet->referenceCount += fragmentNumber;
-
-        while (!enet_list_empty(&fragments)) {
-            fragment = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(&fragments));
-
-            enet_peer_setup_outgoing_command(peer, fragment);
-        }
-
-        return 0;
-    }
-
-    command.header.channelID = channelID;
-
-    if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) == ENET_PACKET_FLAG_UNSEQUENCED) {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    } else if (packet->flags & ENET_PACKET_FLAG_RELIABLE ||
-      channel->outgoingUnreliableSequenceNumber >= 0xFFFF)
-    {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        command.sendReliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    } else {
-        command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
-        command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-    }
-
-    if (enet_peer_queue_outgoing_command(peer, &command, packet, 0, packet->dataLength) == NULL) {
-        return -1;
-    }
-
-    return 0;
-} /* enet_peer_send */
-
-/** Attempts to dequeue any incoming queued packet.
- *  @param peer peer to dequeue packets from
- *  @param channelID holds the channel ID of the channel the packet was received on success
- *  @returns a pointer to the packet, or NULL if there are no available incoming queued packets
- */
-ENetPacket * enet_peer_receive(ENetPeer *peer, enet_uint8 *channelID) {
-    ENetIncomingCommand *incomingCommand;
-    ENetPacket *packet;
-
-    if (enet_list_empty(&peer->dispatchedCommands)) {
-        return NULL;
-    }
-
-    incomingCommand = (ENetIncomingCommand *) enet_list_remove(enet_list_begin(&peer->dispatchedCommands));
-
-    if (channelID != NULL) {
-        *channelID = incomingCommand->command.header.channelID;
-    }
-
-    packet = incomingCommand->packet;
-
-    --packet->referenceCount;
-
-    if (incomingCommand->fragments != NULL) {
-        enet_free(incomingCommand->fragments);
-    }
-
-    enet_free(incomingCommand);
-
-    peer->totalWaitingData -= packet->dataLength;
-
-    return packet;
-}
-
-static void enet_peer_reset_outgoing_commands(ENetList *queue) {
-    ENetOutgoingCommand *outgoingCommand;
-
-    while (!enet_list_empty(queue)) {
-        outgoingCommand = (ENetOutgoingCommand *) enet_list_remove(enet_list_begin(queue));
-
-        if (outgoingCommand->packet != NULL) {
-            --outgoingCommand->packet->referenceCount;
-
-            if (outgoingCommand->packet->referenceCount == 0) {
-                enet_packet_destroy(outgoingCommand->packet);
-            }
-        }
-
-        enet_free(outgoingCommand);
-    }
-}
-
-static void enet_peer_remove_incoming_commands(ENetList *queue, ENetListIterator startCommand,
-  ENetListIterator endCommand) {
-    ENetListIterator currentCommand;
-
-    for (currentCommand = startCommand; currentCommand != endCommand;) {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        currentCommand = enet_list_next(currentCommand);
-
-        enet_list_remove(&incomingCommand->incomingCommandList);
-
-        if (incomingCommand->packet != NULL) {
-            --incomingCommand->packet->referenceCount;
-
-            if (incomingCommand->packet->referenceCount == 0) {
-                enet_packet_destroy(incomingCommand->packet);
-            }
-        }
-
-        if (incomingCommand->fragments != NULL) {
-            enet_free(incomingCommand->fragments);
-        }
-
-        enet_free(incomingCommand);
-    }
-}
-
-static void enet_peer_reset_incoming_commands(ENetList *queue) {
-    enet_peer_remove_incoming_commands(queue, enet_list_begin(queue), enet_list_end(queue));
-}
-
-void enet_peer_reset_queues(ENetPeer *peer) {
-    ENetChannel *channel;
-
-    if (peer->needsDispatch) {
-        enet_list_remove(&peer->dispatchList);
-
-        peer->needsDispatch = 0;
-    }
-
-    while (!enet_list_empty(&peer->acknowledgements))
-        enet_free(enet_list_remove(enet_list_begin(&peer->acknowledgements)));
-
-    enet_peer_reset_outgoing_commands(&peer->sentReliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->sentUnreliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->outgoingReliableCommands);
-    enet_peer_reset_outgoing_commands(&peer->outgoingUnreliableCommands);
-    enet_peer_reset_incoming_commands(&peer->dispatchedCommands);
-
-    if (peer->channels != NULL && peer->channelCount > 0) {
-        for (channel = peer->channels;
-          channel < &peer->channels [peer->channelCount];
-          ++channel)
-        {
-            enet_peer_reset_incoming_commands(&channel->incomingReliableCommands);
-            enet_peer_reset_incoming_commands(&channel->incomingUnreliableCommands);
-        }
-
-        enet_free(peer->channels);
-    }
-
-    peer->channels     = NULL;
-    peer->channelCount = 0;
-} /* enet_peer_reset_queues */
-
-void enet_peer_on_connect(ENetPeer *peer) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->incomingBandwidth != 0) {
-            ++peer->host->bandwidthLimitedPeers;
-        }
-
-        ++peer->host->connectedPeers;
-    }
-}
-
-void enet_peer_on_disconnect(ENetPeer *peer) {
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->incomingBandwidth != 0) {
-            --peer->host->bandwidthLimitedPeers;
-        }
-
-        --peer->host->connectedPeers;
-    }
-}
-
-/** Forcefully disconnects a peer.
- *  @param peer peer to forcefully disconnect
- *  @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
- *  on its connection to the local host.
- */
-void enet_peer_reset(ENetPeer *peer) {
-    enet_peer_on_disconnect(peer);
-
-    peer->outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-    peer->connectID      = 0;
-
-    peer->state = ENET_PEER_STATE_DISCONNECTED;
-
-    peer->incomingBandwidth = 0;
-    peer->outgoingBandwidth = 0;
-    peer->incomingBandwidthThrottleEpoch = 0;
-    peer->outgoingBandwidthThrottleEpoch = 0;
-    peer->incomingDataTotal            = 0;
-    peer->outgoingDataTotal            = 0;
-    peer->lastSendTime                 = 0;
-    peer->lastReceiveTime              = 0;
-    peer->nextTimeout                  = 0;
-    peer->earliestTimeout              = 0;
-    peer->packetLossEpoch              = 0;
-    peer->packetsSent                  = 0;
-    peer->packetsLost                  = 0;
-    peer->packetLoss                   = 0;
-    peer->packetLossVariance           = 0;
-    peer->packetThrottle               = ENET_PEER_DEFAULT_PACKET_THROTTLE;
-    peer->packetThrottleLimit          = ENET_PEER_PACKET_THROTTLE_SCALE;
-    peer->packetThrottleCounter        = 0;
-    peer->packetThrottleEpoch          = 0;
-    peer->packetThrottleAcceleration   = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
-    peer->packetThrottleDeceleration   = ENET_PEER_PACKET_THROTTLE_DECELERATION;
-    peer->packetThrottleInterval       = ENET_PEER_PACKET_THROTTLE_INTERVAL;
-    peer->pingInterval                 = ENET_PEER_PING_INTERVAL;
-    peer->timeoutLimit                 = ENET_PEER_TIMEOUT_LIMIT;
-    peer->timeoutMinimum               = ENET_PEER_TIMEOUT_MINIMUM;
-    peer->timeoutMaximum               = ENET_PEER_TIMEOUT_MAXIMUM;
-    peer->lastRoundTripTime            = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->lowestRoundTripTime          = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->lastRoundTripTimeVariance    = 0;
-    peer->highestRoundTripTimeVariance = 0;
-    peer->roundTripTime                = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-    peer->roundTripTimeVariance        = 0;
-    peer->mtu = peer->host->mtu;
-    peer->reliableDataInTransit = 0;
-    peer->outgoingReliableSequenceNumber = 0;
-    peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    peer->incomingUnsequencedGroup = 0;
-    peer->outgoingUnsequencedGroup = 0;
-    peer->eventData        = 0;
-    peer->totalWaitingData = 0;
-
-    memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-
-    enet_peer_reset_queues(peer);
-} /* enet_peer_reset */
-
-/** Sends a ping request to a peer.
- *  @param peer destination for the ping request
- *  @remarks ping requests factor into the mean round trip time as designated by the
- *  roundTripTime field in the ENetPeer structure.  ENet automatically pings all connected
- *  peers at regular intervals, however, this function may be called to ensure more
- *  frequent ping requests.
- */
-void enet_peer_ping(ENetPeer *peer) {
-    ENetProtocol command;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTED) {
-        return;
-    }
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    command.header.channelID = 0xFF;
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-}
-
-/** Sets the interval at which pings will be sent to a peer.
- *
- *  Pings are used both to monitor the liveness of the connection and also to dynamically
- *  adjust the throttle during periods of low traffic so that the throttle has reasonable
- *  responsiveness during traffic spikes.
- *
- *  @param peer the peer to adjust
- *  @param pingInterval the interval at which to send pings; defaults to ENET_PEER_PING_INTERVAL if 0
- */
-void enet_peer_ping_interval(ENetPeer *peer, enet_uint32 pingInterval) {
-    peer->pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
-}
-
-/** Sets the timeout parameters for a peer.
- *
- *  The timeout parameter control how and when a peer will timeout from a failure to acknowledge
- *  reliable traffic. Timeout values use an exponential backoff mechanism, where if a reliable
- *  packet is not acknowledge within some multiple of the average RTT plus a variance tolerance,
- *  the timeout will be doubled until it reaches a set limit. If the timeout is thus at this
- *  limit and reliable packets have been sent but not acknowledged within a certain minimum time
- *  period, the peer will be disconnected. Alternatively, if reliable packets have been sent
- *  but not acknowledged for a certain maximum time period, the peer will be disconnected regardless
- *  of the current timeout limit value.
- *
- *  @param peer the peer to adjust
- *  @param timeoutLimit the timeout limit; defaults to ENET_PEER_TIMEOUT_LIMIT if 0
- *  @param timeoutMinimum the timeout minimum; defaults to ENET_PEER_TIMEOUT_MINIMUM if 0
- *  @param timeoutMaximum the timeout maximum; defaults to ENET_PEER_TIMEOUT_MAXIMUM if 0
- */
-
-void enet_peer_timeout(ENetPeer *peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum,
-  enet_uint32 timeoutMaximum) {
-    peer->timeoutLimit   = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
-    peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
-    peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
-}
-
-/** Force an immediate disconnection from a peer.
- *  @param peer peer to disconnect
- *  @param data data describing the disconnection
- *  @remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
- *  guaranteed to receive the disconnect notification, and is reset immediately upon
- *  return from this function.
- */
-void enet_peer_disconnect_now(ENetPeer *peer, enet_uint32 data) {
-    ENetProtocol command;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED) {
-        return;
-    }
-
-    if (peer->state != ENET_PEER_STATE_ZOMBIE &&
-      peer->state != ENET_PEER_STATE_DISCONNECTING)
-    {
-        enet_peer_reset_queues(peer);
-
-        command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        command.header.channelID = 0xFF;
-        command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-
-        enet_host_flush(peer->host);
-    }
-
-    enet_peer_reset(peer);
-}
-
-/** Request a disconnection from a peer.
- *  @param peer peer to request a disconnection
- *  @param data data describing the disconnection
- *  @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
- *  once the disconnection is complete.
- */
-void enet_peer_disconnect(ENetPeer *peer, enet_uint32 data) {
-    ENetProtocol command;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTING ||
-      peer->state == ENET_PEER_STATE_DISCONNECTED ||
-      peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
-      peer->state == ENET_PEER_STATE_ZOMBIE)
-    {
-        return;
-    }
-
-    enet_peer_reset_queues(peer);
-
-    command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT;
-    command.header.channelID = 0xFF;
-    command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    } else {
-        command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-    }
-
-    enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        enet_peer_on_disconnect(peer);
-
-        peer->state = ENET_PEER_STATE_DISCONNECTING;
-    } else {
-        enet_host_flush(peer->host);
-        enet_peer_reset(peer);
-    }
-} /* enet_peer_disconnect */
-
-/** Request a disconnection from a peer, but only after all queued outgoing packets are sent.
- *  @param peer peer to request a disconnection
- *  @param data data describing the disconnection
- *  @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
- *  once the disconnection is complete.
- */
-void enet_peer_disconnect_later(ENetPeer *peer, enet_uint32 data) {
-    if ((peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) &&
-      !(enet_list_empty(&peer->outgoingReliableCommands) &&
-      enet_list_empty(&peer->outgoingUnreliableCommands) &&
-      enet_list_empty(&peer->sentReliableCommands)))
-    {
-        peer->state     = ENET_PEER_STATE_DISCONNECT_LATER;
-        peer->eventData = data;
-    } else {
-        enet_peer_disconnect(peer, data);
-    }
-}
-
-ENetAcknowledgement * enet_peer_queue_acknowledgement(ENetPeer *peer, const ENetProtocol *command,
-  enet_uint16 sentTime) {
-    ENetAcknowledgement *acknowledgement;
-
-    if (command->header.channelID < peer->channelCount) {
-        ENetChannel *channel       = &peer->channels [command->header.channelID];
-        enet_uint16 reliableWindow = command->header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-          currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (command->header.reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 &&
-          reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS)
-        {
-            return NULL;
-        }
-    }
-
-    acknowledgement = (ENetAcknowledgement *) enet_malloc(sizeof(ENetAcknowledgement));
-    if (acknowledgement == NULL) {
-        return NULL;
-    }
-
-    peer->outgoingDataTotal += sizeof(ENetProtocolAcknowledge);
-
-    acknowledgement->sentTime = sentTime;
-    acknowledgement->command  = *command;
-
-    enet_list_insert(enet_list_end(&peer->acknowledgements), acknowledgement);
-
-    return acknowledgement;
-}
-
-void enet_peer_setup_outgoing_command(ENetPeer *peer, ENetOutgoingCommand *outgoingCommand) {
-    ENetChannel *channel = &peer->channels [outgoingCommand->command.header.channelID];
-
-    peer->outgoingDataTotal += enet_protocol_command_size(outgoingCommand->command.header.command)
-      + outgoingCommand->fragmentLength;
-
-    if (outgoingCommand->command.header.channelID == 0xFF) {
-        ++peer->outgoingReliableSequenceNumber;
-
-        outgoingCommand->reliableSequenceNumber   = peer->outgoingReliableSequenceNumber;
-        outgoingCommand->unreliableSequenceNumber = 0;
-    } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        ++channel->outgoingReliableSequenceNumber;
-        channel->outgoingUnreliableSequenceNumber = 0;
-
-        outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
-        outgoingCommand->unreliableSequenceNumber = 0;
-    } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) {
-        ++peer->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 =
-      ENET_HOST_TO_NET_16(outgoingCommand->reliableSequenceNumber);
-
-    switch (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-            outgoingCommand->command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16(
-                outgoingCommand->unreliableSequenceNumber);
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-            outgoingCommand->command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16(
-                peer->outgoingUnsequencedGroup);
-            break;
-
-        default:
-            break;
-    }
-
-    if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        enet_list_insert(enet_list_end(&peer->outgoingReliableCommands), outgoingCommand);
-    } else {
-        enet_list_insert(enet_list_end(&peer->outgoingUnreliableCommands), outgoingCommand);
-    }
-} /* enet_peer_setup_outgoing_command */
-
-ENetOutgoingCommand * enet_peer_queue_outgoing_command(ENetPeer *peer, const ENetProtocol *command, ENetPacket *packet,
-  enet_uint32 offset, enet_uint16 length) {
-    ENetOutgoingCommand *outgoingCommand = (ENetOutgoingCommand *) enet_malloc(sizeof(ENetOutgoingCommand));
-
-    if (outgoingCommand == NULL) {
-        return NULL;
-    }
-
-    outgoingCommand->command        = *command;
-    outgoingCommand->fragmentOffset = offset;
-    outgoingCommand->fragmentLength = length;
-    outgoingCommand->packet         = packet;
-    if (packet != NULL) {
-        ++packet->referenceCount;
-    }
-
-    enet_peer_setup_outgoing_command(peer, outgoingCommand);
-
-    return outgoingCommand;
-}
-
-void enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *peer, ENetChannel *channel) {
-    ENetListIterator droppedCommand, startCommand, currentCommand;
-
-    for (droppedCommand = startCommand = currentCommand = enet_list_begin(&channel->incomingUnreliableCommands);
-      currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) ==
-          ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
-        {
-            continue;
-        }
-
-        if (incomingCommand->reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-            if (incomingCommand->fragmentsRemaining <= 0) {
-                channel->incomingUnreliableSequenceNumber = incomingCommand->unreliableSequenceNumber;
-                continue;
-            }
-
-            if (startCommand != currentCommand) {
-                enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(
-                      currentCommand));
-
-                if (!peer->needsDispatch) {
-                    enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-                    peer->needsDispatch = 1;
-                }
-
-                droppedCommand = currentCommand;
-            } else if (droppedCommand != currentCommand) {
-                droppedCommand = enet_list_previous(currentCommand);
-            }
-        } else {
-            enet_uint16 reliableWindow = incomingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
-              currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-            if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-            }
-            if (reliableWindow >= currentWindow &&
-              reliableWindow < currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-            {
-                break;
-            }
-
-            droppedCommand = enet_list_next(currentCommand);
-
-            if (startCommand != currentCommand) {
-                enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(
-                      currentCommand));
-
-                if (!peer->needsDispatch) {
-                    enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-                    peer->needsDispatch = 1;
-                }
-            }
-        }
-
-        startCommand = enet_list_next(currentCommand);
-    }
-
-    if (startCommand != currentCommand) {
-        enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
-
-        if (!peer->needsDispatch) {
-            enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-            peer->needsDispatch = 1;
-        }
-
-        droppedCommand = currentCommand;
-    }
-
-    enet_peer_remove_incoming_commands(&channel->incomingUnreliableCommands,
-      enet_list_begin(&channel->incomingUnreliableCommands), droppedCommand);
-} /* enet_peer_dispatch_incoming_unreliable_commands */
-
-void enet_peer_dispatch_incoming_reliable_commands(ENetPeer *peer, ENetChannel *channel) {
-    ENetListIterator currentCommand;
-
-    for (currentCommand = enet_list_begin(&channel->incomingReliableCommands);
-      currentCommand != enet_list_end(&channel->incomingReliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if (incomingCommand->fragmentsRemaining > 0 ||
-          incomingCommand->reliableSequenceNumber != (enet_uint16) (channel->incomingReliableSequenceNumber + 1))
-        {
-            break;
-        }
-
-        channel->incomingReliableSequenceNumber = incomingCommand->reliableSequenceNumber;
-
-        if (incomingCommand->fragmentCount > 0) {
-            channel->incomingReliableSequenceNumber += incomingCommand->fragmentCount - 1;
-        }
-    }
-
-    if (currentCommand == enet_list_begin(&channel->incomingReliableCommands)) {
-        return;
-    }
-
-    channel->incomingUnreliableSequenceNumber = 0;
-
-    enet_list_move(enet_list_end(&peer->dispatchedCommands), enet_list_begin(
-          &channel->incomingReliableCommands), enet_list_previous(currentCommand));
-
-    if (!peer->needsDispatch) {
-        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-
-        peer->needsDispatch = 1;
-    }
-
-    if (!enet_list_empty(&channel->incomingUnreliableCommands)) {
-        enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-    }
-} /* enet_peer_dispatch_incoming_reliable_commands */
-
-ENetIncomingCommand * enet_peer_queue_incoming_command(ENetPeer *peer, const ENetProtocol *command, const void *data,
-  size_t dataLength, enet_uint32 flags,
-  enet_uint32 fragmentCount) {
-    static ENetIncomingCommand dummyCommand;
-
-    ENetChannel *channel = &peer->channels [command->header.channelID];
-    enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber = 0;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetIncomingCommand *incomingCommand;
-    ENetListIterator currentCommand;
-    ENetPacket *packet = NULL;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        goto discardCommand;
-    }
-
-    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-        reliableSequenceNumber = command->header.reliableSequenceNumber;
-        reliableWindow         = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-            goto discardCommand;
-        }
-    }
-
-    switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-        case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-            if (reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-                goto discardCommand;
-            }
-
-            for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-              currentCommand != enet_list_end(&channel->incomingReliableCommands);
-              currentCommand = enet_list_previous(currentCommand))
-            {
-                incomingCommand = (ENetIncomingCommand *) 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;
-                    }
-
-                    goto discardCommand;
-                }
-            }
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-            unreliableSequenceNumber = ENET_NET_TO_HOST_16(command->sendUnreliable.unreliableSequenceNumber);
-
-            if (reliableSequenceNumber == channel->incomingReliableSequenceNumber &&
-              unreliableSequenceNumber <= channel->incomingUnreliableSequenceNumber)
-            {
-                goto discardCommand;
-            }
-
-            for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-              currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-              currentCommand = enet_list_previous(currentCommand))
-            {
-                incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-                if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-                    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;
-                    }
-
-                    goto discardCommand;
-                }
-            }
-            break;
-
-        case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-            currentCommand = enet_list_end(&channel->incomingUnreliableCommands);
-            break;
-
-        default:
-            goto discardCommand;
-    }
-
-    if (peer->totalWaitingData >= peer->host->maximumWaitingData) {
-        goto notifyError;
-    }
-
-    packet = enet_packet_create(data, dataLength, flags);
-    if (packet == NULL) {
-        goto notifyError;
-    }
-
-    incomingCommand = (ENetIncomingCommand *) enet_malloc(sizeof(ENetIncomingCommand));
-    if (incomingCommand == NULL) {
-        goto notifyError;
-    }
-
-    incomingCommand->reliableSequenceNumber   = command->header.reliableSequenceNumber;
-    incomingCommand->unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF;
-    incomingCommand->command            = *command;
-    incomingCommand->fragmentCount      = fragmentCount;
-    incomingCommand->fragmentsRemaining = fragmentCount;
-    incomingCommand->packet    = packet;
-    incomingCommand->fragments = NULL;
-
-    if (fragmentCount > 0) {
-        if (fragmentCount <= ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-            incomingCommand->fragments = (enet_uint32 *) enet_malloc((fragmentCount + 31) / 32 * sizeof(enet_uint32));
-        }
-        if (incomingCommand->fragments == NULL) {
-            enet_free(incomingCommand);
-
-            goto notifyError;
-        }
-        memset(incomingCommand->fragments, 0, (fragmentCount + 31) / 32 * sizeof(enet_uint32));
-    }
-
-    if (packet != NULL) {
-        ++packet->referenceCount;
-
-        peer->totalWaitingData += packet->dataLength;
-    }
-
-    enet_list_insert(enet_list_next(currentCommand), incomingCommand);
-
-    switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-        case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-        case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-            enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-            break;
-
-        default:
-            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-            break;
-    }
-
-    return incomingCommand;
-
-discardCommand:
-    if (fragmentCount > 0) {
-        goto notifyError;
-    }
-
-    if (packet != NULL && packet->referenceCount == 0) {
-        enet_packet_destroy(packet);
-    }
-
-    return &dummyCommand;
-
-notifyError:
-    if (packet != NULL && packet->referenceCount == 0) {
-        enet_packet_destroy(packet);
-    }
-
-    return NULL;
-} /* enet_peer_queue_incoming_command */
-
-/** @} */

src/protocol.c

@@ -1,1913 +0,0 @@
-/** 
- @file  protocol.c
- @brief ENet protocol functions
-*/
-#include <stdio.h>
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/utility.h"
-#include "enet/time.h"
-#include "enet/enet.h"
-
-static size_t commandSizes [ENET_PROTOCOL_COMMAND_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)
-};
-
-size_t
-enet_protocol_command_size (enet_uint8 commandNumber)
-{
-    return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK];
-}
-
-static void
-enet_protocol_change_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
-{
-    if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER)
-      enet_peer_on_connect (peer);
-    else
-      enet_peer_on_disconnect (peer);
-
-    peer -> state = state;
-}
-
-static void
-enet_protocol_dispatch_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
-{
-    enet_protocol_change_state (host, peer, state);
-
-    if (! peer -> needsDispatch)
-    {
-       enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);
-
-       peer -> needsDispatch = 1;
-    }
-}
-
-static int
-enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
-{
-    while (! enet_list_empty (& host -> dispatchQueue))
-    {
-       ENetPeer * peer = (ENetPeer *) enet_list_remove (enet_list_begin (& host -> dispatchQueue));
-
-       peer -> needsDispatch = 0;
-
-       switch (peer -> state)
-       {
-       case ENET_PEER_STATE_CONNECTION_PENDING:
-       case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
-           enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
-
-           event -> type = ENET_EVENT_TYPE_CONNECT;
-           event -> peer = peer;
-           event -> data = peer -> eventData;
-
-           return 1;
-           
-       case ENET_PEER_STATE_ZOMBIE:
-           host -> recalculateBandwidthLimits = 1;
-
-           event -> type = ENET_EVENT_TYPE_DISCONNECT;
-           event -> peer = peer;
-           event -> data = peer -> eventData;
-
-           enet_peer_reset (peer);
-
-           return 1;
-
-       case ENET_PEER_STATE_CONNECTED:
-           if (enet_list_empty (& peer -> dispatchedCommands))
-             continue;
-
-           event -> packet = enet_peer_receive (peer, & event -> channelID);
-           if (event -> packet == NULL)
-             continue;
-             
-           event -> type = ENET_EVENT_TYPE_RECEIVE;
-           event -> peer = peer;
-
-           if (! enet_list_empty (& peer -> dispatchedCommands))
-           {
-              peer -> needsDispatch = 1;
-         
-              enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);
-           }
-
-           return 1;
-
-       default:
-           break;
-       }
-    }
-
-    return 0;
-}
-
-static void
-enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
-{
-    host -> recalculateBandwidthLimits = 1;
-
-    if (event != NULL)
-    {
-        enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
-
-        event -> type = ENET_EVENT_TYPE_CONNECT;
-        event -> peer = peer;
-        event -> data = peer -> eventData;
-    }
-    else 
-        enet_protocol_dispatch_state (host, peer, peer -> state == ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING);
-}
-
-static void
-enet_protocol_notify_disconnect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
-{
-    if (peer -> state >= ENET_PEER_STATE_CONNECTION_PENDING)
-       host -> recalculateBandwidthLimits = 1;
-
-    if (peer -> state != ENET_PEER_STATE_CONNECTING && peer -> state < ENET_PEER_STATE_CONNECTION_SUCCEEDED)
-        enet_peer_reset (peer);
-    else
-    if (event != NULL)
-    {
-        event -> type = ENET_EVENT_TYPE_DISCONNECT;
-        event -> peer = peer;
-        event -> data = 0;
-
-        enet_peer_reset (peer);
-    }
-    else 
-    {
-        peer -> eventData = 0;
-
-        enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
-    }
-}
-
-static void
-enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
-{
-    ENetOutgoingCommand * outgoingCommand;
-
-    while (! enet_list_empty (& peer -> sentUnreliableCommands))
-    {
-        outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands);
-        
-        enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
-        if (outgoingCommand -> packet != NULL)
-        {
-           -- outgoingCommand -> packet -> referenceCount;
-
-           if (outgoingCommand -> packet -> referenceCount == 0)
-           {
-              outgoingCommand -> packet -> flags |= ENET_PACKET_FLAG_SENT;
- 
-              enet_packet_destroy (outgoingCommand -> packet);
-           }
-        }
-
-        enet_free (outgoingCommand);
-    }
-}
-
-static ENetProtocolCommand
-enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID)
-{
-    ENetOutgoingCommand * outgoingCommand = NULL;
-    ENetListIterator currentCommand;
-    ENetProtocolCommand commandNumber;
-    int wasSent = 1;
-
-    for (currentCommand = enet_list_begin (& peer -> sentReliableCommands);
-         currentCommand != enet_list_end (& peer -> sentReliableCommands);
-         currentCommand = enet_list_next (currentCommand))
-    {
-       outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-        
-       if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
-           outgoingCommand -> command.header.channelID == channelID)
-         break;
-    }
-
-    if (currentCommand == enet_list_end (& peer -> sentReliableCommands))
-    {
-       for (currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
-            currentCommand != enet_list_end (& peer -> outgoingReliableCommands);
-            currentCommand = enet_list_next (currentCommand))
-       {
-          outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-          if (outgoingCommand -> sendAttempts < 1) return ENET_PROTOCOL_COMMAND_NONE;
-
-          if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
-              outgoingCommand -> command.header.channelID == channelID)
-            break;
-       }
-
-       if (currentCommand == enet_list_end (& peer -> outgoingReliableCommands))
-         return ENET_PROTOCOL_COMMAND_NONE;
-
-       wasSent = 0;
-    }
-
-    if (outgoingCommand == NULL)
-      return ENET_PROTOCOL_COMMAND_NONE;
-
-    if (channelID < peer -> channelCount)
-    {
-       ENetChannel * channel = & peer -> channels [channelID];
-       enet_uint16 reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-       if (channel -> reliableWindows [reliableWindow] > 0)
-       {
-          -- channel -> reliableWindows [reliableWindow];
-          if (! channel -> reliableWindows [reliableWindow])
-            channel -> usedReliableWindows &= ~ (1 << reliableWindow);
-       }
-    }
-
-    commandNumber = (ENetProtocolCommand) (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK);
-    
-    enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
-    if (outgoingCommand -> packet != NULL)
-    {
-       if (wasSent)
-         peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
-
-       -- outgoingCommand -> packet -> referenceCount;
-
-       if (outgoingCommand -> packet -> referenceCount == 0)
-       {
-          outgoingCommand -> packet -> flags |= ENET_PACKET_FLAG_SENT;
-
-          enet_packet_destroy (outgoingCommand -> packet);
-       }
-    }
-
-    enet_free (outgoingCommand);
-
-    if (enet_list_empty (& peer -> sentReliableCommands))
-      return commandNumber;
-    
-    outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentReliableCommands);
-    
-    peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
-
-    return commandNumber;
-} 
-
-static ENetPeer *
-enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENetProtocol * command)
-{
-    enet_uint8 incomingSessionID, outgoingSessionID;
-    enet_uint32 mtu, windowSize;
-    ENetChannel * channel;
-    size_t channelCount, duplicatePeers = 0;
-    ENetPeer * currentPeer, * peer = NULL;
-    ENetProtocol verifyCommand;
-
-    channelCount = ENET_NET_TO_HOST_32 (command -> connect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||
-        channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-      return NULL;
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-        if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
-        {
-            if (peer == NULL)
-              peer = currentPeer;
-        }
-        else 
-        if (currentPeer -> state != ENET_PEER_STATE_CONNECTING &&
-            currentPeer -> address.host == host -> receivedAddress.host)
-        {
-            if (currentPeer -> address.port == host -> receivedAddress.port &&
-                currentPeer -> connectID == command -> connect.connectID)
-              return NULL;
-
-            ++ duplicatePeers;
-        }
-    }
-
-    if (peer == NULL || duplicatePeers >= host -> duplicatePeers)
-      return NULL;
-
-    if (channelCount > host -> channelLimit)
-      channelCount = host -> channelLimit;
-    peer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
-    if (peer -> channels == NULL)
-      return NULL;
-    peer -> channelCount = channelCount;
-    peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
-    peer -> connectID = command -> connect.connectID;
-    peer -> address = host -> receivedAddress;
-    peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
-    peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
-    peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
-    peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);
-    peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);
-    peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);
-    peer -> eventData = ENET_NET_TO_HOST_32 (command -> connect.data);
-
-    incomingSessionID = command -> connect.incomingSessionID == 0xFF ? peer -> outgoingSessionID : command -> connect.incomingSessionID;
-    incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (incomingSessionID == peer -> outgoingSessionID)
-      incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    peer -> outgoingSessionID = incomingSessionID;
-
-    outgoingSessionID = command -> connect.outgoingSessionID == 0xFF ? peer -> incomingSessionID : command -> connect.outgoingSessionID;
-    outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (outgoingSessionID == peer -> incomingSessionID)
-      outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    peer -> incomingSessionID = outgoingSessionID;
-
-    for (channel = peer -> channels;
-         channel < & peer -> 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));
-    }
-
-    mtu = ENET_NET_TO_HOST_32 (command -> connect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
-      mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    else
-    if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
-      mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-
-    peer -> mtu = mtu;
-
-    if (host -> outgoingBandwidth == 0 &&
-        peer -> incomingBandwidth == 0)
-      peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    else
-    if (host -> outgoingBandwidth == 0 ||
-        peer -> incomingBandwidth == 0)
-      peer -> windowSize = (ENET_MAX (host -> outgoingBandwidth, peer -> incomingBandwidth) /
-                                    ENET_PEER_WINDOW_SIZE_SCALE) *
-                                      ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-      peer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, peer -> incomingBandwidth) /
-                                    ENET_PEER_WINDOW_SIZE_SCALE) * 
-                                      ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
-    if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
-      peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-    if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
-      peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
-    if (host -> incomingBandwidth == 0)
-      windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    else
-      windowSize = (host -> incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) *
-                     ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
-    if (windowSize > ENET_NET_TO_HOST_32 (command -> connect.windowSize))
-      windowSize = ENET_NET_TO_HOST_32 (command -> connect.windowSize);
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
-      windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-    if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
-      windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
-    verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    verifyCommand.header.channelID = 0xFF;
-    verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (peer -> incomingPeerID);
-    verifyCommand.verifyConnect.incomingSessionID = incomingSessionID;
-    verifyCommand.verifyConnect.outgoingSessionID = outgoingSessionID;
-    verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_32 (peer -> mtu);
-    verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize);
-    verifyCommand.verifyConnect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
-    verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
-    verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
-    verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (peer -> packetThrottleInterval);
-    verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleAcceleration);
-    verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleDeceleration);
-    verifyCommand.verifyConnect.connectID = peer -> connectID;
-
-    enet_peer_queue_outgoing_command (peer, & verifyCommand, NULL, 0, 0);
-
-    return peer;
-}
-
-static int
-enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData)
-{
-    size_t dataLength;
-
-    if (command -> header.channelID >= peer -> channelCount ||
-        (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER))
-      return -1;
-
-    dataLength = ENET_NET_TO_HOST_16 (command -> sendReliable.dataLength);
-    * currentData += dataLength;
-    if (dataLength > host -> maximumPacketSize ||
-        * currentData < host -> receivedData ||
-        * currentData > & host -> receivedData [host -> receivedDataLength])
-      return -1;
-
-    if (enet_peer_queue_incoming_command (peer, command, (const enet_uint8 *) command + sizeof (ENetProtocolSendReliable), dataLength, ENET_PACKET_FLAG_RELIABLE, 0) == NULL)
-      return -1;
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData)
-{
-    enet_uint32 unsequencedGroup, index;
-    size_t dataLength;
-
-    if (command -> header.channelID >= peer -> channelCount ||
-        (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER))
-      return -1;
-
-    dataLength = ENET_NET_TO_HOST_16 (command -> sendUnsequenced.dataLength);
-    * currentData += dataLength;
-    if (dataLength > host -> maximumPacketSize ||
-        * currentData < host -> receivedData ||
-        * currentData > & host -> receivedData [host -> receivedDataLength])
-      return -1; 
-
-    unsequencedGroup = ENET_NET_TO_HOST_16 (command -> sendUnsequenced.unsequencedGroup);
-    index = unsequencedGroup % ENET_PEER_UNSEQUENCED_WINDOW_SIZE;
-   
-    if (unsequencedGroup < peer -> incomingUnsequencedGroup)
-      unsequencedGroup += 0x10000;
-
-    if (unsequencedGroup >= (enet_uint32) peer -> incomingUnsequencedGroup + ENET_PEER_FREE_UNSEQUENCED_WINDOWS * ENET_PEER_UNSEQUENCED_WINDOW_SIZE)
-      return 0;
-
-    unsequencedGroup &= 0xFFFF;
-
-    if (unsequencedGroup - index != peer -> incomingUnsequencedGroup)
-    {
-        peer -> incomingUnsequencedGroup = unsequencedGroup - index;
-
-        memset (peer -> unsequencedWindow, 0, sizeof (peer -> unsequencedWindow));
-    }
-    else
-    if (peer -> unsequencedWindow [index / 32] & (1 << (index % 32)))
-      return 0;
-      
-    if (enet_peer_queue_incoming_command (peer, command, (const enet_uint8 *) command + sizeof (ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED, 0) == NULL)
-      return -1;
-   
-    peer -> unsequencedWindow [index / 32] |= 1 << (index % 32);
- 
-    return 0;
-}
-
-static int
-enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData)
-{
-    size_t dataLength;
-
-    if (command -> header.channelID >= peer -> channelCount ||
-        (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER))
-      return -1;
-
-    dataLength = ENET_NET_TO_HOST_16 (command -> sendUnreliable.dataLength);
-    * currentData += dataLength;
-    if (dataLength > host -> maximumPacketSize ||
-        * currentData < host -> receivedData ||
-        * currentData > & host -> receivedData [host -> receivedDataLength])
-      return -1;
-
-    if (enet_peer_queue_incoming_command (peer, command, (const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable), dataLength, 0, 0) == NULL)
-      return -1;
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData)
-{
-    enet_uint32 fragmentNumber,
-           fragmentCount,
-           fragmentOffset,
-           fragmentLength,
-           startSequenceNumber,
-           totalLength;
-    ENetChannel * channel;
-    enet_uint16 startWindow, currentWindow;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand * startCommand = NULL;
-
-    if (command -> header.channelID >= peer -> channelCount ||
-        (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER))
-      return -1;
-
-    fragmentLength = ENET_NET_TO_HOST_16 (command -> sendFragment.dataLength);
-    * currentData += fragmentLength;
-    if (fragmentLength > host -> maximumPacketSize ||
-        * currentData < host -> receivedData ||
-        * currentData > & host -> receivedData [host -> receivedDataLength])
-      return -1;
-
-    channel = & peer -> channels [command -> header.channelID];
-    startSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendFragment.startSequenceNumber);
-    startWindow = startSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (startSequenceNumber < channel -> incomingReliableSequenceNumber)
-      startWindow += ENET_PEER_RELIABLE_WINDOWS;
-
-    if (startWindow < currentWindow || startWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-      return 0;
-
-    fragmentNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentNumber);
-    fragmentCount = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentOffset);
-    totalLength = ENET_NET_TO_HOST_32 (command -> sendFragment.totalLength);
-    
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-        fragmentNumber >= fragmentCount ||
-        totalLength > host -> maximumPacketSize ||
-        fragmentOffset >= totalLength ||
-        fragmentLength > totalLength - fragmentOffset)
-      return -1;
- 
-    for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
-         currentCommand != enet_list_end (& channel -> incomingReliableCommands);
-         currentCommand = enet_list_previous (currentCommand))
-    {
-       ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-       if (startSequenceNumber >= channel -> incomingReliableSequenceNumber)
-       {
-          if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
-            continue;
-       }
-       else
-       if (incomingCommand -> reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)
-         break;
-
-       if (incomingCommand -> reliableSequenceNumber <= startSequenceNumber)
-       {
-          if (incomingCommand -> reliableSequenceNumber < startSequenceNumber)
-            break;
-        
-          if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_FRAGMENT ||
-              totalLength != incomingCommand -> packet -> dataLength ||
-              fragmentCount != incomingCommand -> fragmentCount)
-            return -1;
-
-          startCommand = incomingCommand;
-          break;
-       }
-    }
- 
-    if (startCommand == NULL)
-    {
-       ENetProtocol hostCommand = * command;
-
-       hostCommand.header.reliableSequenceNumber = startSequenceNumber;
-
-       startCommand = enet_peer_queue_incoming_command (peer, & hostCommand, NULL, totalLength, ENET_PACKET_FLAG_RELIABLE, fragmentCount);
-       if (startCommand == NULL)
-         return -1;
-    }
-    
-    if ((startCommand -> fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0)
-    {
-       -- startCommand -> fragmentsRemaining;
-
-       startCommand -> fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-       if (fragmentOffset + fragmentLength > startCommand -> packet -> dataLength)
-         fragmentLength = startCommand -> packet -> dataLength - fragmentOffset;
-
-       memcpy (startCommand -> packet -> data + fragmentOffset,
-               (enet_uint8 *) command + sizeof (ENetProtocolSendFragment),
-               fragmentLength);
-
-        if (startCommand -> fragmentsRemaining <= 0)
-          enet_peer_dispatch_incoming_reliable_commands (peer, channel);
-    }
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_send_unreliable_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData)
-{
-    enet_uint32 fragmentNumber,
-           fragmentCount,
-           fragmentOffset,
-           fragmentLength,
-           reliableSequenceNumber,
-           startSequenceNumber,
-           totalLength;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetChannel * channel;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand * startCommand = NULL;
-
-    if (command -> header.channelID >= peer -> channelCount ||
-        (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER))
-      return -1;
-
-    fragmentLength = ENET_NET_TO_HOST_16 (command -> sendFragment.dataLength);
-    * currentData += fragmentLength;
-    if (fragmentLength > host -> maximumPacketSize ||
-        * currentData < host -> receivedData ||
-        * currentData > & host -> receivedData [host -> receivedDataLength])
-      return -1;
-
-    channel = & peer -> channels [command -> header.channelID];
-    reliableSequenceNumber = command -> header.reliableSequenceNumber;
-    startSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendFragment.startSequenceNumber);
-
-    reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
-      reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-
-    if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
-      return 0;
-
-    if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber &&
-        startSequenceNumber <= channel -> incomingUnreliableSequenceNumber)
-      return 0;
-
-    fragmentNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentNumber);
-    fragmentCount = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentOffset);
-    totalLength = ENET_NET_TO_HOST_32 (command -> sendFragment.totalLength);
-
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-        fragmentNumber >= fragmentCount ||
-        totalLength > host -> maximumPacketSize ||
-        fragmentOffset >= totalLength ||
-        fragmentLength > totalLength - fragmentOffset)
-      return -1;
-
-    for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands));
-         currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);
-         currentCommand = enet_list_previous (currentCommand))
-    {
-       ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-       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 <= startSequenceNumber)
-       {
-          if (incomingCommand -> unreliableSequenceNumber < startSequenceNumber)
-            break;
-
-          if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT ||
-              totalLength != incomingCommand -> packet -> dataLength ||
-              fragmentCount != incomingCommand -> fragmentCount)
-            return -1;
-
-          startCommand = incomingCommand;
-          break;
-       }
-    }
-
-    if (startCommand == NULL)
-    {
-       startCommand = enet_peer_queue_incoming_command (peer, command, NULL, totalLength, ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT, fragmentCount);
-       if (startCommand == NULL)
-         return -1;
-    }
-
-    if ((startCommand -> fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0)
-    {
-       -- startCommand -> fragmentsRemaining;
-
-       startCommand -> fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-       if (fragmentOffset + fragmentLength > startCommand -> packet -> dataLength)
-         fragmentLength = startCommand -> packet -> dataLength - fragmentOffset;
-
-       memcpy (startCommand -> packet -> data + fragmentOffset,
-               (enet_uint8 *) command + sizeof (ENetProtocolSendFragment),
-               fragmentLength);
-
-        if (startCommand -> fragmentsRemaining <= 0)
-          enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
-    }
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{
-    if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-      return -1;
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{
-    if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-      return -1;
-
-    if (peer -> incomingBandwidth != 0)
-      -- host -> bandwidthLimitedPeers;
-
-    peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.incomingBandwidth);
-    peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth);
-
-    if (peer -> incomingBandwidth != 0)
-      ++ host -> bandwidthLimitedPeers;
-
-    if (peer -> incomingBandwidth == 0 && host -> outgoingBandwidth == 0)
-      peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    else
-    if (peer -> incomingBandwidth == 0 || host -> outgoingBandwidth == 0)
-      peer -> windowSize = (ENET_MAX (peer -> incomingBandwidth, host -> outgoingBandwidth) /
-                             ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-      peer -> windowSize = (ENET_MIN (peer -> incomingBandwidth, host -> outgoingBandwidth) /
-                             ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
-    if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
-      peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    else
-    if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
-      peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{
-    if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-      return -1;
-
-    peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleInterval);
-    peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration);
-    peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleDeceleration);
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{
-    if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE || peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT)
-      return 0;
-
-    enet_peer_reset_queues (peer);
-
-    if (peer -> state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer -> state == ENET_PEER_STATE_DISCONNECTING || peer -> state == ENET_PEER_STATE_CONNECTING)
-        enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
-    else
-    if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
-    {
-        if (peer -> state == ENET_PEER_STATE_CONNECTION_PENDING) host -> recalculateBandwidthLimits = 1;
-
-        enet_peer_reset (peer);
-    }
-    else
-    if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
-      enet_protocol_change_state (host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
-    else
-      enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
-
-    if (peer -> state != ENET_PEER_STATE_DISCONNECTED)
-      peer -> eventData = ENET_NET_TO_HOST_32 (command -> disconnect.data);
-
-    return 0;
-}
-
-static int
-enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
-{
-    enet_uint32 roundTripTime,
-           receivedSentTime,
-           receivedReliableSequenceNumber;
-    ENetProtocolCommand commandNumber;
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE)
-      return 0;
-
-    receivedSentTime = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedSentTime);
-    receivedSentTime |= host -> serviceTime & 0xFFFF0000;
-    if ((receivedSentTime & 0x8000) > (host -> serviceTime & 0x8000))
-        receivedSentTime -= 0x10000;
-
-    if (ENET_TIME_LESS (host -> serviceTime, receivedSentTime))
-      return 0;
-
-    peer -> lastReceiveTime = host -> serviceTime;
-    peer -> earliestTimeout = 0;
-
-    roundTripTime = ENET_TIME_DIFFERENCE (host -> serviceTime, receivedSentTime);
-
-    enet_peer_throttle (peer, roundTripTime);
-
-    peer -> roundTripTimeVariance -= peer -> roundTripTimeVariance / 4;
-
-    if (roundTripTime >= peer -> roundTripTime)
-    {
-       peer -> roundTripTime += (roundTripTime - peer -> roundTripTime) / 8;
-       peer -> roundTripTimeVariance += (roundTripTime - peer -> roundTripTime) / 4;
-    }
-    else
-    {
-       peer -> roundTripTime -= (peer -> roundTripTime - roundTripTime) / 8;
-       peer -> roundTripTimeVariance += (peer -> roundTripTime - roundTripTime) / 4;
-    }
-
-    if (peer -> roundTripTime < peer -> lowestRoundTripTime)
-      peer -> lowestRoundTripTime = peer -> roundTripTime;
-
-    if (peer -> roundTripTimeVariance > peer -> highestRoundTripTimeVariance) 
-      peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
-
-    if (peer -> packetThrottleEpoch == 0 ||
-        ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> packetThrottleEpoch) >= peer -> packetThrottleInterval)
-    {
-        peer -> lastRoundTripTime = peer -> lowestRoundTripTime;
-        peer -> lastRoundTripTimeVariance = peer -> highestRoundTripTimeVariance;
-        peer -> lowestRoundTripTime = peer -> roundTripTime;
-        peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
-        peer -> packetThrottleEpoch = host -> serviceTime;
-    }
-
-    receivedReliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedReliableSequenceNumber);
-
-    commandNumber = enet_protocol_remove_sent_reliable_command (peer, receivedReliableSequenceNumber, command -> header.channelID);
-
-    switch (peer -> state)
-    {
-    case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-       if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT)
-         return -1;
-
-       enet_protocol_notify_connect (host, peer, event);
-       break;
-
-    case ENET_PEER_STATE_DISCONNECTING:
-       if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT)
-         return -1;
-
-       enet_protocol_notify_disconnect (host, peer, event);
-       break;
-
-    case ENET_PEER_STATE_DISCONNECT_LATER:
-       if (enet_list_empty (& peer -> outgoingReliableCommands) &&
-           enet_list_empty (& peer -> outgoingUnreliableCommands) &&   
-           enet_list_empty (& peer -> sentReliableCommands))
-         enet_peer_disconnect (peer, peer -> eventData);
-       break;
-
-    default:
-       break;
-    }
-   
-    return 0;
-}
-
-static int
-enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
-{
-    enet_uint32 mtu, windowSize;
-    size_t channelCount;
-
-    if (peer -> state != ENET_PEER_STATE_CONNECTING)
-      return 0;
-
-    channelCount = ENET_NET_TO_HOST_32 (command -> verifyConnect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT ||
-        ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleInterval) != peer -> packetThrottleInterval ||
-        ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleAcceleration) != peer -> packetThrottleAcceleration ||
-        ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleDeceleration) != peer -> packetThrottleDeceleration ||
-        command -> verifyConnect.connectID != peer -> connectID)
-    {
-        peer -> eventData = 0;
-
-        enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
-
-        return -1;
-    }
-
-    enet_protocol_remove_sent_reliable_command (peer, 1, 0xFF);
-    
-    if (channelCount < peer -> channelCount)
-      peer -> channelCount = channelCount;
-
-    peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> verifyConnect.outgoingPeerID);
-    peer -> incomingSessionID = command -> verifyConnect.incomingSessionID;
-    peer -> outgoingSessionID = command -> verifyConnect.outgoingSessionID;
-
-    mtu = ENET_NET_TO_HOST_32 (command -> verifyConnect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
-      mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    else 
-    if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
-      mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-
-    if (mtu < peer -> mtu)
-      peer -> mtu = mtu;
-
-    windowSize = ENET_NET_TO_HOST_32 (command -> verifyConnect.windowSize);
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
-      windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
-    if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
-      windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
-    if (windowSize < peer -> windowSize)
-      peer -> windowSize = windowSize;
-
-    peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.incomingBandwidth);
-    peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.outgoingBandwidth);
-
-    enet_protocol_notify_connect (host, peer, event);
-    return 0;
-}
-
-static int
-enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
-{
-    ENetProtocolHeader * header;
-    ENetProtocol * command;
-    ENetPeer * peer;
-    enet_uint8 * currentData;
-    size_t headerSize;
-    enet_uint16 peerID, flags;
-    enet_uint8 sessionID;
-
-    if (host -> receivedDataLength < (size_t) & ((ENetProtocolHeader *) 0) -> sentTime)
-      return 0;
-
-    header = (ENetProtocolHeader *) host -> receivedData;
-
-    peerID = ENET_NET_TO_HOST_16 (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;
-    }
- 
-    if (flags & ENET_PROTOCOL_HEADER_FLAG_COMPRESSED)
-    {
-        size_t originalSize;
-        if (host -> compressor.context == NULL || host -> compressor.decompress == NULL)
-          return 0;
-
-        originalSize = host -> compressor.decompress (host -> compressor.context,
-                                    host -> receivedData + headerSize, 
-                                    host -> receivedDataLength - headerSize, 
-                                    host -> packetData [1] + headerSize, 
-                                    sizeof (host -> packetData [1]) - headerSize);
-        if (originalSize <= 0 || originalSize > sizeof (host -> packetData [1]) - headerSize)
-          return 0;
-
-        memcpy (host -> packetData [1], header, headerSize);
-        host -> receivedData = host -> packetData [1];
-        host -> receivedDataLength = headerSize + originalSize;
-    }
-
-    if (host -> checksum != NULL)
-    {
-        enet_uint32 * checksum = (enet_uint32 *) & host -> receivedData [headerSize - sizeof (enet_uint32)],
-                    desiredChecksum = * checksum;
-        ENetBuffer buffer;
-
-        * checksum = peer != NULL ? peer -> connectID : 0;
-
-        buffer.data = host -> receivedData;
-        buffer.dataLength = host -> receivedDataLength;
-
-        if (host -> checksum (& buffer, 1) != desiredChecksum)
-          return 0;
-    }
-       
-    if (peer != NULL)
-    {
-       peer -> address.host = host -> receivedAddress.host;
-       peer -> address.port = host -> receivedAddress.port;
-       peer -> incomingDataTotal += host -> receivedDataLength;
-    }
-    
-    currentData = host -> receivedData + headerSize;
-  
-    while (currentData < & host -> receivedData [host -> receivedDataLength])
-    {
-       enet_uint8 commandNumber;
-       size_t commandSize;
-
-       command = (ENetProtocol *) currentData;
-
-       if (currentData + sizeof (ENetProtocolCommandHeader) > & host -> receivedData [host -> receivedDataLength])
-         break;
-
-       commandNumber = command -> header.command & ENET_PROTOCOL_COMMAND_MASK;
-       if (commandNumber >= ENET_PROTOCOL_COMMAND_COUNT) 
-         break;
-       
-       commandSize = commandSizes [commandNumber];
-       if (commandSize == 0 || currentData + commandSize > & host -> receivedData [host -> receivedDataLength])
-         break;
-
-       currentData += commandSize;
-
-       if (peer == NULL && commandNumber != ENET_PROTOCOL_COMMAND_CONNECT)
-         break;
-         
-       command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> header.reliableSequenceNumber);
-
-       switch (commandNumber)
-       {
-       case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
-          if (enet_protocol_handle_acknowledge (host, event, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_CONNECT:
-          if (peer != NULL)
-            goto commandError;
-          peer = enet_protocol_handle_connect (host, header, command);
-          if (peer == NULL)
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
-          if (enet_protocol_handle_verify_connect (host, event, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_DISCONNECT:
-          if (enet_protocol_handle_disconnect (host, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_PING:
-          if (enet_protocol_handle_ping (host, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-          if (enet_protocol_handle_send_reliable (host, peer, command, & currentData))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-          if (enet_protocol_handle_send_unreliable (host, peer, command, & currentData))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-          if (enet_protocol_handle_send_unsequenced (host, peer, command, & currentData))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-          if (enet_protocol_handle_send_fragment (host, peer, command, & currentData))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
-          if (enet_protocol_handle_bandwidth_limit (host, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
-          if (enet_protocol_handle_throttle_configure (host, peer, command))
-            goto commandError;
-          break;
-
-       case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-          if (enet_protocol_handle_send_unreliable_fragment (host, peer, command, & currentData))
-            goto commandError;
-          break;
-
-       default:
-          goto commandError;
-       }
-
-       if (peer != NULL &&
-           (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0)
-       {
-           enet_uint16 sentTime;
-
-           if (! (flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME))
-             break;
-
-           sentTime = ENET_NET_TO_HOST_16 (header -> sentTime);
-
-           switch (peer -> state)
-           {
-           case ENET_PEER_STATE_DISCONNECTING:
-           case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-           case ENET_PEER_STATE_DISCONNECTED:
-           case ENET_PEER_STATE_ZOMBIE:
-              break;
-
-           case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
-              if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT)
-                enet_peer_queue_acknowledgement (peer, command, sentTime);
-              break;
-
-           default:   
-              enet_peer_queue_acknowledgement (peer, command, sentTime);        
-              break;
-           }
-       }
-    }
-
-commandError:
-    if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
-      return 1;
-
-    return 0;
-}
- 
-static int
-enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
-{
-    int packets;
-
-    for (packets = 0; packets < 256; ++ packets)
-    {
-       int receivedLength;
-       ENetBuffer buffer;
-
-       buffer.data = host -> packetData [0];
-       buffer.dataLength = sizeof (host -> packetData [0]);
-
-       receivedLength = enet_socket_receive (host -> socket,
-                                             & host -> receivedAddress,
-                                             & buffer,
-                                             1);
-
-       if (receivedLength < 0)
-         return -1;
-
-       if (receivedLength == 0)
-         return 0;
-
-       host -> receivedData = host -> packetData [0];
-       host -> receivedDataLength = receivedLength;
-      
-       host -> totalReceivedData += receivedLength;
-       host -> totalReceivedPackets ++;
-
-       if (host -> intercept != NULL)
-       {
-          switch (host -> intercept (host, event))
-          {
-          case 1:
-             if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
-               return 1;
-
-             continue;
-          
-          case -1:
-             return -1;
-        
-          default:
-             break;
-          }
-       }
-        
-       switch (enet_protocol_handle_incoming_commands (host, event))
-       {
-       case 1:
-          return 1;
-       
-       case -1:
-          return -1;
-
-       default:
-          break;
-       }
-    }
-
-    return -1;
-}
-
-static void
-enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
-{
-    ENetProtocol * command = & host -> commands [host -> commandCount];
-    ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
-    ENetAcknowledgement * acknowledgement;
-    ENetListIterator currentAcknowledgement;
-    enet_uint16 reliableSequenceNumber;
- 
-    currentAcknowledgement = enet_list_begin (& peer -> acknowledgements);
-         
-    while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements))
-    {
-       if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
-           buffer >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
-           peer -> mtu - host -> packetSize < sizeof (ENetProtocolAcknowledge))
-       {
-          host -> continueSending = 1;
-
-          break;
-       }
-
-       acknowledgement = (ENetAcknowledgement *) currentAcknowledgement;
- 
-       currentAcknowledgement = enet_list_next (currentAcknowledgement);
-
-       buffer -> data = command;
-       buffer -> dataLength = sizeof (ENetProtocolAcknowledge);
-
-       host -> packetSize += buffer -> dataLength;
-
-       reliableSequenceNumber = ENET_HOST_TO_NET_16 (acknowledgement -> command.header.reliableSequenceNumber);
-  
-       command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
-       command -> header.channelID = acknowledgement -> command.header.channelID;
-       command -> header.reliableSequenceNumber = reliableSequenceNumber;
-       command -> acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
-       command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_16 (acknowledgement -> sentTime);
-  
-       if ((acknowledgement -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT)
-         enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
-
-       enet_list_remove (& acknowledgement -> acknowledgementList);
-       enet_free (acknowledgement);
-
-       ++ command;
-       ++ buffer;
-    }
-
-    host -> commandCount = command - host -> commands;
-    host -> bufferCount = buffer - host -> buffers;
-}
-
-static void
-enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
-{
-    ENetProtocol * command = & host -> commands [host -> commandCount];
-    ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
-    ENetOutgoingCommand * outgoingCommand;
-    ENetListIterator currentCommand;
-
-    currentCommand = enet_list_begin (& peer -> outgoingUnreliableCommands);
-    
-    while (currentCommand != enet_list_end (& peer -> outgoingUnreliableCommands))
-    {
-       size_t commandSize;
-
-       outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-       commandSize = commandSizes [outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-
-       if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
-           buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
-           peer -> mtu - host -> packetSize < commandSize ||
-           (outgoingCommand -> packet != NULL &&
-             peer -> mtu - host -> packetSize < commandSize + outgoingCommand -> fragmentLength))
-       {
-          host -> continueSending = 1;
-
-          break;
-       }
-
-       currentCommand = enet_list_next (currentCommand);
-
-       if (outgoingCommand -> packet != NULL && outgoingCommand -> fragmentOffset == 0)
-       {
-          peer -> packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
-          peer -> packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-          
-          if (peer -> packetThrottleCounter > peer -> packetThrottle)
-          {
-             enet_uint16 reliableSequenceNumber = outgoingCommand -> reliableSequenceNumber,
-                         unreliableSequenceNumber = outgoingCommand -> unreliableSequenceNumber;
-             for (;;)
-             {
-                -- outgoingCommand -> packet -> referenceCount;
-
-                if (outgoingCommand -> packet -> referenceCount == 0)
-                  enet_packet_destroy (outgoingCommand -> packet);
-         
-                enet_list_remove (& outgoingCommand -> outgoingCommandList);
-                enet_free (outgoingCommand);
-
-                if (currentCommand == enet_list_end (& peer -> outgoingUnreliableCommands))
-                  break;
-
-                outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-                if (outgoingCommand -> reliableSequenceNumber != reliableSequenceNumber ||
-                    outgoingCommand -> unreliableSequenceNumber != unreliableSequenceNumber)
-                  break;
-
-                currentCommand = enet_list_next (currentCommand);
-             }
-           
-             continue;
-          }
-       }
-
-       buffer -> data = command;
-       buffer -> dataLength = commandSize;
-      
-       host -> packetSize += buffer -> dataLength;
-
-       * command = outgoingCommand -> command;
-       
-       enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
-       if (outgoingCommand -> packet != NULL)
-       {
-          ++ buffer;
-          
-          buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset;
-          buffer -> dataLength = outgoingCommand -> fragmentLength;
-
-          host -> packetSize += buffer -> dataLength;
-
-          enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
-       }
-       else
-         enet_free (outgoingCommand);
-
-       ++ command;
-       ++ buffer;
-    } 
-
-    host -> commandCount = command - host -> commands;
-    host -> bufferCount = buffer - host -> buffers;
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER && 
-        enet_list_empty (& peer -> outgoingReliableCommands) &&
-        enet_list_empty (& peer -> outgoingUnreliableCommands) && 
-        enet_list_empty (& peer -> sentReliableCommands))
-      enet_peer_disconnect (peer, peer -> eventData);
-}
-
-static int
-enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * event)
-{
-    ENetOutgoingCommand * outgoingCommand;
-    ENetListIterator currentCommand, insertPosition;
-
-    currentCommand = enet_list_begin (& peer -> sentReliableCommands);
-    insertPosition = enet_list_begin (& peer -> outgoingReliableCommands);
-
-    while (currentCommand != enet_list_end (& peer -> sentReliableCommands))
-    {
-       outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-       currentCommand = enet_list_next (currentCommand);
-
-       if (ENET_TIME_DIFFERENCE (host -> serviceTime, outgoingCommand -> sentTime) < outgoingCommand -> roundTripTimeout)
-         continue;
-
-       if (peer -> earliestTimeout == 0 ||
-           ENET_TIME_LESS (outgoingCommand -> sentTime, peer -> earliestTimeout))
-         peer -> earliestTimeout = outgoingCommand -> sentTime;
-
-       if (peer -> earliestTimeout != 0 &&
-             (ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> earliestTimeout) >= peer -> timeoutMaximum ||
-               (outgoingCommand -> roundTripTimeout >= outgoingCommand -> roundTripTimeoutLimit &&
-                 ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> earliestTimeout) >= peer -> timeoutMinimum)))
-       {
-          enet_protocol_notify_disconnect (host, peer, event);
-
-          return 1;
-       }
-
-       if (outgoingCommand -> packet != NULL)
-         peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
-          
-       ++ peer -> packetsLost;
-
-       outgoingCommand -> roundTripTimeout *= 2;
-
-       enet_list_insert (insertPosition, enet_list_remove (& outgoingCommand -> outgoingCommandList));
-
-       if (currentCommand == enet_list_begin (& peer -> sentReliableCommands) &&
-           ! enet_list_empty (& peer -> sentReliableCommands))
-       {
-          outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-          peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
-       }
-    }
-    
-    return 0;
-}
-
-static int
-enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
-{
-    ENetProtocol * command = & host -> commands [host -> commandCount];
-    ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
-    ENetOutgoingCommand * outgoingCommand;
-    ENetListIterator currentCommand;
-    ENetChannel *channel;
-    enet_uint16 reliableWindow;
-    size_t commandSize;
-    int windowExceeded = 0, windowWrap = 0, canPing = 1;
-
-    currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
-    
-    while (currentCommand != enet_list_end (& peer -> outgoingReliableCommands))
-    {
-       outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-       channel = outgoingCommand -> command.header.channelID < peer -> channelCount ? & peer -> channels [outgoingCommand -> command.header.channelID] : NULL;
-       reliableWindow = outgoingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-       if (channel != NULL)
-       {
-           if (! windowWrap &&      
-               outgoingCommand -> sendAttempts < 1 && 
-               ! (outgoingCommand -> reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
-               (channel -> reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1) % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
-                 channel -> usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow) | 
-                   (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
-             windowWrap = 1;
-          if (windowWrap)
-          {
-             currentCommand = enet_list_next (currentCommand);
- 
-             continue;
-          }
-       }
- 
-       if (outgoingCommand -> packet != NULL)
-       {
-          if (! windowExceeded)
-          {
-             enet_uint32 windowSize = (peer -> packetThrottle * peer -> windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
-             
-             if (peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > ENET_MAX (windowSize, peer -> mtu))
-               windowExceeded = 1;
-          }
-          if (windowExceeded)
-          {
-             currentCommand = enet_list_next (currentCommand);
-
-             continue;
-          }
-       }
-
-       canPing = 0;
-
-       commandSize = commandSizes [outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-       if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
-           buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
-           peer -> mtu - host -> packetSize < commandSize ||
-           (outgoingCommand -> packet != NULL && 
-             (enet_uint16) (peer -> mtu - host -> packetSize) < (enet_uint16) (commandSize + outgoingCommand -> fragmentLength)))
-       {
-          host -> continueSending = 1;
-          
-          break;
-       }
-
-       currentCommand = enet_list_next (currentCommand);
-
-       if (channel != NULL && outgoingCommand -> sendAttempts < 1)
-       {
-          channel -> usedReliableWindows |= 1 << reliableWindow;
-          ++ channel -> reliableWindows [reliableWindow];
-       }
-
-       ++ outgoingCommand -> sendAttempts;
- 
-       if (outgoingCommand -> roundTripTimeout == 0)
-       {
-          outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
-          outgoingCommand -> roundTripTimeoutLimit = peer -> timeoutLimit * outgoingCommand -> roundTripTimeout;
-       }
-
-       if (enet_list_empty (& peer -> sentReliableCommands))
-         peer -> nextTimeout = host -> serviceTime + outgoingCommand -> roundTripTimeout;
-
-       enet_list_insert (enet_list_end (& peer -> sentReliableCommands),
-                         enet_list_remove (& outgoingCommand -> outgoingCommandList));
-
-       outgoingCommand -> sentTime = host -> serviceTime;
-
-       buffer -> data = command;
-       buffer -> dataLength = commandSize;
-
-       host -> packetSize += buffer -> dataLength;
-       host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
-
-       * command = outgoingCommand -> command;
-
-       if (outgoingCommand -> packet != NULL)
-       {
-          ++ buffer;
-          
-          buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset;
-          buffer -> dataLength = outgoingCommand -> fragmentLength;
-
-          host -> packetSize += outgoingCommand -> fragmentLength;
-
-          peer -> reliableDataInTransit += outgoingCommand -> fragmentLength;
-       }
-
-       ++ peer -> packetsSent;
-        
-       ++ command;
-       ++ buffer;
-    }
-
-    host -> commandCount = command - host -> commands;
-    host -> bufferCount = buffer - host -> buffers;
-
-    return canPing;
-}
-
-static int
-enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int checkForTimeouts)
-{
-    enet_uint8 headerData [sizeof (ENetProtocolHeader) + sizeof (enet_uint32)];
-    ENetProtocolHeader * header = (ENetProtocolHeader *) headerData;
-    ENetPeer * currentPeer;
-    int sentLength;
-    size_t shouldCompress = 0;
- 
-    host -> continueSending = 1;
-
-    while (host -> continueSending)
-    for (host -> continueSending = 0,
-           currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-        if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED ||
-            currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
-          continue;
-
-        host -> headerFlags = 0;
-        host -> commandCount = 0;
-        host -> bufferCount = 1;
-        host -> packetSize = sizeof (ENetProtocolHeader);
-
-        if (! enet_list_empty (& currentPeer -> acknowledgements))
-          enet_protocol_send_acknowledgements (host, currentPeer);
-
-        if (checkForTimeouts != 0 &&
-            ! enet_list_empty (& currentPeer -> sentReliableCommands) &&
-            ENET_TIME_GREATER_EQUAL (host -> serviceTime, currentPeer -> nextTimeout) &&
-            enet_protocol_check_timeouts (host, currentPeer, event) == 1)
-        {
-            if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
-              return 1;
-            else
-              continue;
-        }
-
-        if ((enet_list_empty (& currentPeer -> outgoingReliableCommands) ||
-              enet_protocol_send_reliable_outgoing_commands (host, currentPeer)) &&
-            enet_list_empty (& currentPeer -> sentReliableCommands) &&
-            ENET_TIME_DIFFERENCE (host -> serviceTime, currentPeer -> lastReceiveTime) >= currentPeer -> pingInterval &&
-            currentPeer -> mtu - host -> packetSize >= sizeof (ENetProtocolPing))
-        { 
-            enet_peer_ping (currentPeer);
-            enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
-        }
-                      
-        if (! enet_list_empty (& currentPeer -> outgoingUnreliableCommands))
-          enet_protocol_send_unreliable_outgoing_commands (host, currentPeer);
-
-        if (host -> commandCount == 0)
-          continue;
-
-        if (currentPeer -> packetLossEpoch == 0)
-          currentPeer -> packetLossEpoch = host -> serviceTime;
-        else
-        if (ENET_TIME_DIFFERENCE (host -> serviceTime, currentPeer -> packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL &&
-            currentPeer -> packetsSent > 0)
-        {
-           enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;
-
-#ifdef ENET_DEBUG
-           printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
-#endif
-          
-           currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;
-
-           if (packetLoss >= currentPeer -> packetLoss)
-           {
-              currentPeer -> packetLoss += (packetLoss - currentPeer -> packetLoss) / 8;
-              currentPeer -> packetLossVariance += (packetLoss - currentPeer -> packetLoss) / 4;
-           }
-           else
-           {
-              currentPeer -> packetLoss -= (currentPeer -> packetLoss - packetLoss) / 8;
-              currentPeer -> packetLossVariance += (currentPeer -> packetLoss - packetLoss) / 4;
-           }
-
-           currentPeer -> packetLossEpoch = host -> serviceTime;
-           currentPeer -> packetsSent = 0;
-           currentPeer -> packetsLost = 0;
-        }
-
-        host -> buffers -> data = headerData;
-        if (host -> headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)
-        {
-            header -> sentTime = ENET_HOST_TO_NET_16 (host -> serviceTime & 0xFFFF);
-
-            host -> buffers -> dataLength = sizeof (ENetProtocolHeader);
-        }
-        else
-          host -> buffers -> dataLength = (size_t) & ((ENetProtocolHeader *) 0) -> sentTime;
-
-        shouldCompress = 0;
-        if (host -> compressor.context != NULL && host -> compressor.compress != NULL)
-        {
-            size_t originalSize = host -> packetSize - sizeof(ENetProtocolHeader),
-                   compressedSize = host -> compressor.compress (host -> compressor.context,
-                                        & host -> buffers [1], host -> bufferCount - 1,
-                                        originalSize,
-                                        host -> packetData [1],
-                                        originalSize);
-            if (compressedSize > 0 && compressedSize < originalSize)
-            {
-                host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED;
-                shouldCompress = compressedSize;
-#ifdef ENET_DEBUG_COMPRESS
-                printf ("peer %u: compressed %u -> %u (%u%%)\n", currentPeer -> incomingPeerID, originalSize, compressedSize, (compressedSize * 100) / originalSize);
-#endif
-            }
-        }
-
-        if (currentPeer -> outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID)
-          host -> headerFlags |= currentPeer -> outgoingSessionID << ENET_PROTOCOL_HEADER_SESSION_SHIFT;
-        header -> peerID = ENET_HOST_TO_NET_16 (currentPeer -> outgoingPeerID | host -> headerFlags);
-        if (host -> checksum != NULL)
-        {
-            enet_uint32 * checksum = (enet_uint32 *) & headerData [host -> buffers -> dataLength];
-            * checksum = currentPeer -> outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer -> connectID : 0;
-            host -> buffers -> dataLength += sizeof (enet_uint32);
-            * checksum = host -> checksum (host -> buffers, host -> bufferCount);
-        }
-
-        if (shouldCompress > 0)
-        {
-            host -> buffers [1].data = host -> packetData [1];
-            host -> buffers [1].dataLength = shouldCompress;
-            host -> bufferCount = 2;
-        }
-
-        currentPeer -> lastSendTime = host -> serviceTime;
-
-        sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount);
-
-        enet_protocol_remove_sent_unreliable_commands (currentPeer);
-
-        if (sentLength < 0)
-          return -1;
-
-        host -> totalSentData += sentLength;
-        host -> totalSentPackets ++;
-    }
-   
-    return 0;
-}
-
-/** Sends any queued packets on the host specified to its designated peers.
-
-    @param host   host to flush
-    @remarks this function need only be used in circumstances where one wishes to send queued packets earlier than in a call to enet_host_service().
-    @ingroup host
-*/
-void
-enet_host_flush (ENetHost * host)
-{
-    host -> serviceTime = enet_time_get ();
-
-    enet_protocol_send_outgoing_commands (host, NULL, 0);
-}
-
-/** Checks for any queued events on the host and dispatches one if available.
-
-    @param host    host to check for events
-    @param event   an event structure where event details will be placed if available
-    @retval > 0 if an event was dispatched
-    @retval 0 if no events are available
-    @retval < 0 on failure
-    @ingroup host
-*/
-int
-enet_host_check_events (ENetHost * host, ENetEvent * event)
-{
-    if (event == NULL) return -1;
-
-    event -> type = ENET_EVENT_TYPE_NONE;
-    event -> peer = NULL;
-    event -> packet = NULL;
-
-    return enet_protocol_dispatch_incoming_commands (host, event);
-}
-
-/** Waits for events on the host specified and shuttles packets between
-    the host and its peers.
-
-    @param host    host to service
-    @param event   an event structure where event details will be placed if one occurs
-                   if event == NULL then no events will be delivered
-    @param timeout number of milliseconds that ENet should wait for events
-    @retval > 0 if an event occurred within the specified time limit
-    @retval 0 if no event occurred
-    @retval < 0 on failure
-    @remarks enet_host_service should be called fairly regularly for adequate performance
-    @ingroup host
-*/
-int
-enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
-{
-    enet_uint32 waitCondition;
-
-    if (event != NULL)
-    {
-        event -> type = ENET_EVENT_TYPE_NONE;
-        event -> peer = NULL;
-        event -> packet = NULL;
-
-        switch (enet_protocol_dispatch_incoming_commands (host, event))
-        {
-        case 1:
-            return 1;
-
-        case -1:
-#ifdef ENET_DEBUG
-            perror ("Error dispatching incoming packets");
-#endif
-
-            return -1;
-
-        default:
-            break;
-        }
-    }
-
-    host -> serviceTime = enet_time_get ();
-    
-    timeout += host -> serviceTime;
-
-    do
-    {
-       if (ENET_TIME_DIFFERENCE (host -> serviceTime, host -> bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
-         enet_host_bandwidth_throttle (host);
-
-       switch (enet_protocol_send_outgoing_commands (host, event, 1))
-       {
-       case 1:
-          return 1;
-
-       case -1:
-#ifdef ENET_DEBUG
-          perror ("Error sending outgoing packets");
-#endif
-
-          return -1;
-
-       default:
-          break;
-       }
-
-       switch (enet_protocol_receive_incoming_commands (host, event))
-       {
-       case 1:
-          return 1;
-
-       case -1:
-#ifdef ENET_DEBUG
-          perror ("Error receiving incoming packets");
-#endif
-
-          return -1;
-
-       default:
-          break;
-       }
-
-       switch (enet_protocol_send_outgoing_commands (host, event, 1))
-       {
-       case 1:
-          return 1;
-
-       case -1:
-#ifdef ENET_DEBUG
-          perror ("Error sending outgoing packets");
-#endif
-
-          return -1;
-
-       default:
-          break;
-       }
-
-       if (event != NULL)
-       {
-          switch (enet_protocol_dispatch_incoming_commands (host, 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 (host -> serviceTime, timeout))
-         return 0;
-
-       do
-       {
-          host -> serviceTime = enet_time_get ();
-
-          if (ENET_TIME_GREATER_EQUAL (host -> serviceTime, timeout))
-            return 0;
-
-          waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
-
-          if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, host -> serviceTime)) != 0)
-            return -1;
-       }
-       while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
-
-       host -> serviceTime = enet_time_get ();
-    } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
-
-    return 0; 
-}
-

src/protocol.c.us.c

@@ -1,1981 +0,0 @@
-/**
- * @file  protocol.c
- * @brief ENet protocol functions
- */
-#include <stdio.h>
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "enet/utility.h"
-#include "enet/time.h"
-#include "enet/enet.h"
-
-static size_t commandSizes [ENET_PROTOCOL_COMMAND_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)
-};
-
-size_t enet_protocol_command_size(enet_uint8 commandNumber) {
-    return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK];
-}
-
-static void enet_protocol_change_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-    if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER) {
-        enet_peer_on_connect(peer);
-    } else {
-        enet_peer_on_disconnect(peer);
-    }
-
-    peer->state = state;
-}
-
-static void enet_protocol_dispatch_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-    enet_protocol_change_state(host, peer, state);
-
-    if (!peer->needsDispatch) {
-        enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-
-        peer->needsDispatch = 1;
-    }
-}
-
-static int enet_protocol_dispatch_incoming_commands(ENetHost *host, ENetEvent *event) {
-    while (!enet_list_empty(&host->dispatchQueue)) {
-        ENetPeer *peer = (ENetPeer *) enet_list_remove(enet_list_begin(&host->dispatchQueue));
-
-        peer->needsDispatch = 0;
-
-        switch (peer->state) {
-            case ENET_PEER_STATE_CONNECTION_PENDING:
-            case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
-                enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-                event->type = ENET_EVENT_TYPE_CONNECT;
-                event->peer = peer;
-                event->data = peer->eventData;
-
-                return 1;
-
-            case ENET_PEER_STATE_ZOMBIE:
-                host->recalculateBandwidthLimits = 1;
-
-                event->type = ENET_EVENT_TYPE_DISCONNECT;
-                event->peer = peer;
-                event->data = peer->eventData;
-
-                enet_peer_reset(peer);
-
-                return 1;
-
-            case ENET_PEER_STATE_CONNECTED:
-                if (enet_list_empty(&peer->dispatchedCommands)) {
-                    continue;
-                }
-
-                event->packet = enet_peer_receive(peer, &event->channelID);
-                if (event->packet == NULL) {
-                    continue;
-                }
-
-                event->type = ENET_EVENT_TYPE_RECEIVE;
-                event->peer = peer;
-
-                if (!enet_list_empty(&peer->dispatchedCommands)) {
-                    peer->needsDispatch = 1;
-
-                    enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-                }
-
-                return 1;
-
-            default:
-                break;
-        }
-    }
-
-    return 0;
-} /* enet_protocol_dispatch_incoming_commands */
-
-static void enet_protocol_notify_connect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    host->recalculateBandwidthLimits = 1;
-
-    if (event != NULL) {
-        enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-        event->type = ENET_EVENT_TYPE_CONNECT;
-        event->peer = peer;
-        event->data = peer->eventData;
-    } else {
-        enet_protocol_dispatch_state(host, peer,
-          peer->state ==
-          ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING);
-    }
-}
-
-static void enet_protocol_notify_disconnect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
-        host->recalculateBandwidthLimits = 1;
-    }
-
-    if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
-        enet_peer_reset(peer);
-    } else if (event != NULL) {
-        event->type = ENET_EVENT_TYPE_DISCONNECT;
-        event->peer = peer;
-        event->data = 0;
-
-        enet_peer_reset(peer);
-    } else {
-        peer->eventData = 0;
-
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    }
-}
-
-static void enet_protocol_remove_sent_unreliable_commands(ENetPeer *peer) {
-    ENetOutgoingCommand *outgoingCommand;
-
-    while (!enet_list_empty(&peer->sentUnreliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) enet_list_front(&peer->sentUnreliableCommands);
-
-        enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-        if (outgoingCommand->packet != NULL) {
-            --outgoingCommand->packet->referenceCount;
-
-            if (outgoingCommand->packet->referenceCount == 0) {
-                outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-
-                enet_packet_destroy(outgoingCommand->packet);
-            }
-        }
-
-        enet_free(outgoingCommand);
-    }
-}
-
-static ENetProtocolCommand enet_protocol_remove_sent_reliable_command(ENetPeer *peer,
-  enet_uint16                                                                   reliableSequenceNumber,
-  enet_uint8                                                                    channelID) {
-    ENetOutgoingCommand *outgoingCommand = NULL;
-    ENetListIterator currentCommand;
-    ENetProtocolCommand commandNumber;
-    int wasSent = 1;
-
-    for (currentCommand = enet_list_begin(&peer->sentReliableCommands);
-      currentCommand != enet_list_end(&peer->sentReliableCommands);
-      currentCommand = enet_list_next(currentCommand))
-    {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber &&
-          outgoingCommand->command.header.channelID == channelID)
-        {
-            break;
-        }
-    }
-
-    if (currentCommand == enet_list_end(&peer->sentReliableCommands)) {
-        for (currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-          currentCommand != enet_list_end(&peer->outgoingReliableCommands);
-          currentCommand = enet_list_next(currentCommand))
-        {
-            outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-            if (outgoingCommand->sendAttempts < 1) { return ENET_PROTOCOL_COMMAND_NONE; }
-
-            if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber &&
-              outgoingCommand->command.header.channelID == channelID)
-            {
-                break;
-            }
-        }
-
-        if (currentCommand == enet_list_end(&peer->outgoingReliableCommands)) {
-            return ENET_PROTOCOL_COMMAND_NONE;
-        }
-
-        wasSent = 0;
-    }
-
-    if (outgoingCommand == NULL) {
-        return ENET_PROTOCOL_COMMAND_NONE;
-    }
-
-    if (channelID < peer->channelCount) {
-        ENetChannel *channel       = &peer->channels [channelID];
-        enet_uint16 reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        if (channel->reliableWindows [reliableWindow] > 0) {
-            --channel->reliableWindows [reliableWindow];
-            if (!channel->reliableWindows [reliableWindow]) {
-                channel->usedReliableWindows &= ~(1 << reliableWindow);
-            }
-        }
-    }
-
-    commandNumber = (ENetProtocolCommand) (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK);
-
-    enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-    if (outgoingCommand->packet != NULL) {
-        if (wasSent) {
-            peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-        }
-
-        --outgoingCommand->packet->referenceCount;
-
-        if (outgoingCommand->packet->referenceCount == 0) {
-            outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-
-            enet_packet_destroy(outgoingCommand->packet);
-        }
-    }
-
-    enet_free(outgoingCommand);
-
-    if (enet_list_empty(&peer->sentReliableCommands)) {
-        return commandNumber;
-    }
-
-    outgoingCommand = (ENetOutgoingCommand *) enet_list_front(&peer->sentReliableCommands);
-
-    peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-
-    return commandNumber;
-} /* enet_protocol_remove_sent_reliable_command */
-
-static ENetPeer * enet_protocol_handle_connect(ENetHost *host, ENetProtocolHeader *header, ENetProtocol *command) {
-    enet_uint8 incomingSessionID, outgoingSessionID;
-    enet_uint32 mtu, windowSize;
-    ENetChannel *channel;
-    size_t channelCount, duplicatePeers = 0;
-    ENetPeer *currentPeer, *peer = NULL;
-    ENetProtocol verifyCommand;
-
-    channelCount = ENET_NET_TO_HOST_32(command->connect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||
-      channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
-    {
-        return NULL;
-    }
-
-    for (currentPeer = host->peers;
-      currentPeer < &host->peers [host->peerCount];
-      ++currentPeer)
-    {
-        if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
-            if (peer == NULL) {
-                peer = currentPeer;
-            }
-        } else if (currentPeer->state != ENET_PEER_STATE_CONNECTING &&
-          currentPeer->address.host == host->receivedAddress.host)
-        {
-            if (currentPeer->address.port == host->receivedAddress.port &&
-              currentPeer->connectID == command->connect.connectID)
-            {
-                return NULL;
-            }
-
-            ++duplicatePeers;
-        }
-    }
-
-    if (peer == NULL || duplicatePeers >= host->duplicatePeers) {
-        return NULL;
-    }
-
-    if (channelCount > host->channelLimit) {
-        channelCount = host->channelLimit;
-    }
-    peer->channels = (ENetChannel *) enet_malloc(channelCount * sizeof(ENetChannel));
-    if (peer->channels == NULL) {
-        return NULL;
-    }
-    peer->channelCount               = channelCount;
-    peer->state                      = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
-    peer->connectID                  = command->connect.connectID;
-    peer->address                    = host->receivedAddress;
-    peer->outgoingPeerID             = ENET_NET_TO_HOST_16(command->connect.outgoingPeerID);
-    peer->incomingBandwidth          = ENET_NET_TO_HOST_32(command->connect.incomingBandwidth);
-    peer->outgoingBandwidth          = ENET_NET_TO_HOST_32(command->connect.outgoingBandwidth);
-    peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->connect.packetThrottleInterval);
-    peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleAcceleration);
-    peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleDeceleration);
-    peer->eventData                  = ENET_NET_TO_HOST_32(command->connect.data);
-
-    incomingSessionID = command->connect.incomingSessionID ==
-      0xFF ? peer->outgoingSessionID : command->connect.incomingSessionID;
-    incomingSessionID = (incomingSessionID + 1)
-      & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (incomingSessionID == peer->outgoingSessionID) {
-        incomingSessionID = (incomingSessionID + 1)
-          & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    }
-    peer->outgoingSessionID = incomingSessionID;
-
-    outgoingSessionID = command->connect.outgoingSessionID ==
-      0xFF ? peer->incomingSessionID : command->connect.outgoingSessionID;
-    outgoingSessionID = (outgoingSessionID + 1)
-      & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    if (outgoingSessionID == peer->incomingSessionID) {
-        outgoingSessionID = (outgoingSessionID + 1)
-          & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-    }
-    peer->incomingSessionID = outgoingSessionID;
-
-    for (channel = peer->channels;
-      channel < &peer->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));
-    }
-
-    mtu = ENET_NET_TO_HOST_32(command->connect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-    }
-
-    peer->mtu = mtu;
-
-    if (host->outgoingBandwidth == 0 &&
-      peer->incomingBandwidth == 0)
-    {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else if (host->outgoingBandwidth == 0 ||
-      peer->incomingBandwidth == 0)
-    {
-        peer->windowSize = (ENET_MAX(host->outgoingBandwidth, peer->incomingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else {
-        peer->windowSize = (ENET_MIN(host->outgoingBandwidth, peer->incomingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    if (host->incomingBandwidth == 0) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else {
-        windowSize = (host->incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE)
-          * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize > ENET_NET_TO_HOST_32(command->connect.windowSize)) {
-        windowSize = ENET_NET_TO_HOST_32(command->connect.windowSize);
-    }
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    verifyCommand.header.command   = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-    verifyCommand.header.channelID = 0xFF;
-    verifyCommand.verifyConnect.outgoingPeerID    = ENET_HOST_TO_NET_16(peer->incomingPeerID);
-    verifyCommand.verifyConnect.incomingSessionID = incomingSessionID;
-    verifyCommand.verifyConnect.outgoingSessionID = outgoingSessionID;
-    verifyCommand.verifyConnect.mtu                        = ENET_HOST_TO_NET_32(peer->mtu);
-    verifyCommand.verifyConnect.windowSize                 = ENET_HOST_TO_NET_32(windowSize);
-    verifyCommand.verifyConnect.channelCount               = ENET_HOST_TO_NET_32(channelCount);
-    verifyCommand.verifyConnect.incomingBandwidth          = ENET_HOST_TO_NET_32(host->incomingBandwidth);
-    verifyCommand.verifyConnect.outgoingBandwidth          = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
-    verifyCommand.verifyConnect.packetThrottleInterval     = ENET_HOST_TO_NET_32(peer->packetThrottleInterval);
-    verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32(peer->packetThrottleAcceleration);
-    verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32(peer->packetThrottleDeceleration);
-    verifyCommand.verifyConnect.connectID                  = peer->connectID;
-
-    enet_peer_queue_outgoing_command(peer, &verifyCommand, NULL, 0, 0);
-
-    return peer;
-} /* enet_protocol_handle_connect */
-
-static int enet_protocol_handle_send_reliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendReliable.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *) command + sizeof(ENetProtocolSendReliable),
-      dataLength, ENET_PACKET_FLAG_RELIABLE, 0) == NULL)
-    {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_send_unsequenced(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 unsequencedGroup, index;
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendUnsequenced.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    unsequencedGroup = ENET_NET_TO_HOST_16(command->sendUnsequenced.unsequencedGroup);
-    index = unsequencedGroup % ENET_PEER_UNSEQUENCED_WINDOW_SIZE;
-
-    if (unsequencedGroup < peer->incomingUnsequencedGroup) {
-        unsequencedGroup += 0x10000;
-    }
-
-    if (unsequencedGroup >=
-      (enet_uint32) peer->incomingUnsequencedGroup + ENET_PEER_FREE_UNSEQUENCED_WINDOWS
-      * ENET_PEER_UNSEQUENCED_WINDOW_SIZE)
-    {
-        return 0;
-    }
-
-    unsequencedGroup &= 0xFFFF;
-
-    if (unsequencedGroup - index != peer->incomingUnsequencedGroup) {
-        peer->incomingUnsequencedGroup = unsequencedGroup - index;
-
-        memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-    } else if (peer->unsequencedWindow [index / 32] & (1 << (index % 32))) {
-        return 0;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command,
-      (const enet_uint8 *) command + sizeof(ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED,
-      0) == NULL)
-    {
-        return -1;
-    }
-
-    peer->unsequencedWindow [index / 32] |= 1 << (index % 32);
-
-    return 0;
-} /* enet_protocol_handle_send_unsequenced */
-
-static int enet_protocol_handle_send_unreliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    size_t dataLength;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    dataLength    = ENET_NET_TO_HOST_16(command->sendUnreliable.dataLength);
-    *currentData += dataLength;
-    if (dataLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    if (enet_peer_queue_incoming_command(peer, command,
-      (const enet_uint8 *) command + sizeof(ENetProtocolSendUnreliable), dataLength, 0, 0) == NULL)
-    {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_send_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 fragmentNumber,
-      fragmentCount,
-      fragmentOffset,
-      fragmentLength,
-      startSequenceNumber,
-      totalLength;
-    ENetChannel *channel;
-    enet_uint16 startWindow, currentWindow;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand *startCommand = NULL;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-    *currentData  += fragmentLength;
-    if (fragmentLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    channel = &peer->channels [command->header.channelID];
-    startSequenceNumber = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-    startWindow         = startSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow       = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (startSequenceNumber < channel->incomingReliableSequenceNumber) {
-        startWindow += ENET_PEER_RELIABLE_WINDOWS;
-    }
-
-    if (startWindow < currentWindow || startWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-        return 0;
-    }
-
-    fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-    fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-    totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-      fragmentNumber >= fragmentCount ||
-      totalLength > host->maximumPacketSize ||
-      fragmentOffset >= totalLength ||
-      fragmentLength > totalLength - fragmentOffset)
-    {
-        return -1;
-    }
-
-    for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-      currentCommand != enet_list_end(&channel->incomingReliableCommands);
-      currentCommand = enet_list_previous(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        if (startSequenceNumber >= channel->incomingReliableSequenceNumber) {
-            if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                continue;
-            }
-        } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-            break;
-        }
-
-        if (incomingCommand->reliableSequenceNumber <= startSequenceNumber) {
-            if (incomingCommand->reliableSequenceNumber < startSequenceNumber) {
-                break;
-            }
-
-            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-              ENET_PROTOCOL_COMMAND_SEND_FRAGMENT ||
-              totalLength != incomingCommand->packet->dataLength ||
-              fragmentCount != incomingCommand->fragmentCount)
-            {
-                return -1;
-            }
-
-            startCommand = incomingCommand;
-            break;
-        }
-    }
-
-    if (startCommand == NULL) {
-        ENetProtocol hostCommand = *command;
-
-        hostCommand.header.reliableSequenceNumber = startSequenceNumber;
-
-        startCommand = enet_peer_queue_incoming_command(peer, &hostCommand, NULL, totalLength,
-            ENET_PACKET_FLAG_RELIABLE, fragmentCount);
-        if (startCommand == NULL) {
-            return -1;
-        }
-    }
-
-    if ((startCommand->fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-        --startCommand->fragmentsRemaining;
-
-        startCommand->fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-        if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-            fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-        }
-
-        memcpy(startCommand->packet->data + fragmentOffset,
-          (enet_uint8 *) command + sizeof(ENetProtocolSendFragment),
-          fragmentLength);
-
-        if (startCommand->fragmentsRemaining <= 0) {
-            enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-        }
-    }
-
-    return 0;
-} /* enet_protocol_handle_send_fragment */
-
-static int enet_protocol_handle_send_unreliable_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command,
-  enet_uint8 **currentData) {
-    enet_uint32 fragmentNumber,
-      fragmentCount,
-      fragmentOffset,
-      fragmentLength,
-      reliableSequenceNumber,
-      startSequenceNumber,
-      totalLength;
-    enet_uint16 reliableWindow, currentWindow;
-    ENetChannel *channel;
-    ENetListIterator currentCommand;
-    ENetIncomingCommand *startCommand = NULL;
-
-    if (command->header.channelID >= peer->channelCount ||
-      (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER))
-    {
-        return -1;
-    }
-
-    fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-    *currentData  += fragmentLength;
-    if (fragmentLength > host->maximumPacketSize ||
-      *currentData < host->receivedData ||
-      *currentData > &host->receivedData [host->receivedDataLength])
-    {
-        return -1;
-    }
-
-    channel = &peer->channels [command->header.channelID];
-    reliableSequenceNumber = command->header.reliableSequenceNumber;
-    startSequenceNumber    = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-
-    reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-    currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-    if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-        reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-    }
-
-    if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-        return 0;
-    }
-
-    if (reliableSequenceNumber == channel->incomingReliableSequenceNumber &&
-      startSequenceNumber <= channel->incomingUnreliableSequenceNumber)
-    {
-        return 0;
-    }
-
-    fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-    fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-    fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-    totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-    if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-      fragmentNumber >= fragmentCount ||
-      totalLength > host->maximumPacketSize ||
-      fragmentOffset >= totalLength ||
-      fragmentLength > totalLength - fragmentOffset)
-    {
-        return -1;
-    }
-
-    for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-      currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-      currentCommand = enet_list_previous(currentCommand))
-    {
-        ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *) currentCommand;
-
-        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 <= startSequenceNumber) {
-            if (incomingCommand->unreliableSequenceNumber < startSequenceNumber) {
-                break;
-            }
-
-            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-              ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT ||
-              totalLength != incomingCommand->packet->dataLength ||
-              fragmentCount != incomingCommand->fragmentCount)
-            {
-                return -1;
-            }
-
-            startCommand = incomingCommand;
-            break;
-        }
-    }
-
-    if (startCommand == NULL) {
-        startCommand = enet_peer_queue_incoming_command(peer, command, NULL, totalLength,
-            ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT, fragmentCount);
-        if (startCommand == NULL) {
-            return -1;
-        }
-    }
-
-    if ((startCommand->fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-        --startCommand->fragmentsRemaining;
-
-        startCommand->fragments [fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-        if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-            fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-        }
-
-        memcpy(startCommand->packet->data + fragmentOffset,
-          (enet_uint8 *) command + sizeof(ENetProtocolSendFragment),
-          fragmentLength);
-
-        if (startCommand->fragmentsRemaining <= 0) {
-            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-        }
-    }
-
-    return 0;
-} /* enet_protocol_handle_send_unreliable_fragment */
-
-static int enet_protocol_handle_ping(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_bandwidth_limit(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    if (peer->incomingBandwidth != 0) {
-        --host->bandwidthLimitedPeers;
-    }
-
-    peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.incomingBandwidth);
-    peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
-
-    if (peer->incomingBandwidth != 0) {
-        ++host->bandwidthLimitedPeers;
-    }
-
-    if (peer->incomingBandwidth == 0 && host->outgoingBandwidth == 0) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    } else if (peer->incomingBandwidth == 0 || host->outgoingBandwidth == 0) {
-        peer->windowSize = (ENET_MAX(peer->incomingBandwidth, host->outgoingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else {
-        peer->windowSize = (ENET_MIN(peer->incomingBandwidth, host->outgoingBandwidth)
-          / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    return 0;
-} /* enet_protocol_handle_bandwidth_limit */
-
-static int enet_protocol_handle_throttle_configure(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        return -1;
-    }
-
-    peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleInterval);
-    peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleAcceleration);
-    peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleDeceleration);
-
-    return 0;
-}
-
-static int enet_protocol_handle_disconnect(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE ||
-      peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT)
-    {
-        return 0;
-    }
-
-    enet_peer_reset_queues(peer);
-
-    if (peer->state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer->state == ENET_PEER_STATE_DISCONNECTING ||
-      peer->state == ENET_PEER_STATE_CONNECTING)
-    {
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    } else if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-        if (peer->state == ENET_PEER_STATE_CONNECTION_PENDING) { host->recalculateBandwidthLimits = 1; }
-
-        enet_peer_reset(peer);
-    } else if (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-        enet_protocol_change_state(host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
-    } else {
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-    }
-
-    if (peer->state != ENET_PEER_STATE_DISCONNECTED) {
-        peer->eventData = ENET_NET_TO_HOST_32(command->disconnect.data);
-    }
-
-    return 0;
-}
-
-static int enet_protocol_handle_acknowledge(ENetHost *host, ENetEvent *event, ENetPeer *peer,
-  const ENetProtocol *command) {
-    enet_uint32 roundTripTime,
-      receivedSentTime,
-      receivedReliableSequenceNumber;
-    ENetProtocolCommand commandNumber;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE) {
-        return 0;
-    }
-
-    receivedSentTime  = ENET_NET_TO_HOST_16(command->acknowledge.receivedSentTime);
-    receivedSentTime |= host->serviceTime & 0xFFFF0000;
-    if ((receivedSentTime & 0x8000) > (host->serviceTime & 0x8000)) {
-        receivedSentTime -= 0x10000;
-    }
-
-    if (ENET_TIME_LESS(host->serviceTime, receivedSentTime)) {
-        return 0;
-    }
-
-    peer->lastReceiveTime = host->serviceTime;
-    peer->earliestTimeout = 0;
-
-    roundTripTime = ENET_TIME_DIFFERENCE(host->serviceTime, receivedSentTime);
-
-    enet_peer_throttle(peer, roundTripTime);
-
-    peer->roundTripTimeVariance -= peer->roundTripTimeVariance / 4;
-
-    if (roundTripTime >= peer->roundTripTime) {
-        peer->roundTripTime         += (roundTripTime - peer->roundTripTime) / 8;
-        peer->roundTripTimeVariance += (roundTripTime - peer->roundTripTime) / 4;
-    } else {
-        peer->roundTripTime         -= (peer->roundTripTime - roundTripTime) / 8;
-        peer->roundTripTimeVariance += (peer->roundTripTime - roundTripTime) / 4;
-    }
-
-    if (peer->roundTripTime < peer->lowestRoundTripTime) {
-        peer->lowestRoundTripTime = peer->roundTripTime;
-    }
-
-    if (peer->roundTripTimeVariance > peer->highestRoundTripTimeVariance) {
-        peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-    }
-
-    if (peer->packetThrottleEpoch == 0 ||
-      ENET_TIME_DIFFERENCE(host->serviceTime, peer->packetThrottleEpoch) >= peer->packetThrottleInterval)
-    {
-        peer->lastRoundTripTime            = peer->lowestRoundTripTime;
-        peer->lastRoundTripTimeVariance    = peer->highestRoundTripTimeVariance;
-        peer->lowestRoundTripTime          = peer->roundTripTime;
-        peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-        peer->packetThrottleEpoch          = host->serviceTime;
-    }
-
-    receivedReliableSequenceNumber = ENET_NET_TO_HOST_16(command->acknowledge.receivedReliableSequenceNumber);
-
-    commandNumber = enet_protocol_remove_sent_reliable_command(peer, receivedReliableSequenceNumber,
-        command->header.channelID);
-
-    switch (peer->state) {
-        case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-            if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT) {
-                return -1;
-            }
-
-            enet_protocol_notify_connect(host, peer, event);
-            break;
-
-        case ENET_PEER_STATE_DISCONNECTING:
-            if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                return -1;
-            }
-
-            enet_protocol_notify_disconnect(host, peer, event);
-            break;
-
-        case ENET_PEER_STATE_DISCONNECT_LATER:
-            if (enet_list_empty(&peer->outgoingReliableCommands) &&
-              enet_list_empty(&peer->outgoingUnreliableCommands) &&
-              enet_list_empty(&peer->sentReliableCommands))
-            {
-                enet_peer_disconnect(peer, peer->eventData);
-            }
-            break;
-
-        default:
-            break;
-    }
-
-    return 0;
-} /* enet_protocol_handle_acknowledge */
-
-static int enet_protocol_handle_verify_connect(ENetHost *host, ENetEvent *event, ENetPeer *peer,
-  const ENetProtocol *command) {
-    enet_uint32 mtu, windowSize;
-    size_t channelCount;
-
-    if (peer->state != ENET_PEER_STATE_CONNECTING) {
-        return 0;
-    }
-
-    channelCount = ENET_NET_TO_HOST_32(command->verifyConnect.channelCount);
-
-    if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleInterval) != peer->packetThrottleInterval ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleAcceleration) != peer->packetThrottleAcceleration ||
-      ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleDeceleration) != peer->packetThrottleDeceleration ||
-      command->verifyConnect.connectID != peer->connectID)
-    {
-        peer->eventData = 0;
-
-        enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-
-        return -1;
-    }
-
-    enet_protocol_remove_sent_reliable_command(peer, 1, 0xFF);
-
-    if (channelCount < peer->channelCount) {
-        peer->channelCount = channelCount;
-    }
-
-    peer->outgoingPeerID    = ENET_NET_TO_HOST_16(command->verifyConnect.outgoingPeerID);
-    peer->incomingSessionID = command->verifyConnect.incomingSessionID;
-    peer->outgoingSessionID = command->verifyConnect.outgoingSessionID;
-
-    mtu = ENET_NET_TO_HOST_32(command->verifyConnect.mtu);
-
-    if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MINIMUM_MTU;
-    } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-        mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-    }
-
-    if (mtu < peer->mtu) {
-        peer->mtu = mtu;
-    }
-
-    windowSize = ENET_NET_TO_HOST_32(command->verifyConnect.windowSize);
-
-    if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-        windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-    }
-
-    if (windowSize < peer->windowSize) {
-        peer->windowSize = windowSize;
-    }
-
-    peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.incomingBandwidth);
-    peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.outgoingBandwidth);
-
-    enet_protocol_notify_connect(host, peer, event);
-    return 0;
-} /* enet_protocol_handle_verify_connect */
-
-static int enet_protocol_handle_incoming_commands(ENetHost *host, ENetEvent *event) {
-    ENetProtocolHeader *header;
-    ENetProtocol *command;
-    ENetPeer *peer;
-    enet_uint8 *currentData;
-    size_t headerSize;
-    enet_uint16 peerID, flags;
-    enet_uint8 sessionID;
-
-    if (host->receivedDataLength < (size_t) &((ENetProtocolHeader *) 0)->sentTime) {
-        return 0;
-    }
-
-    header = (ENetProtocolHeader *) host->receivedData;
-
-    peerID    = ENET_NET_TO_HOST_16(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;
-        }
-    }
-
-    if (flags & ENET_PROTOCOL_HEADER_FLAG_COMPRESSED) {
-        size_t originalSize;
-        if (host->compressor.context == NULL || host->compressor.decompress == NULL) {
-            return 0;
-        }
-
-        originalSize = host->compressor.decompress(host->compressor.context,
-            host->receivedData + headerSize,
-            host->receivedDataLength - headerSize,
-            host->packetData [1] + headerSize,
-            sizeof(host->packetData [1]) - headerSize);
-        if (originalSize <= 0 || originalSize > sizeof(host->packetData [1]) - headerSize) {
-            return 0;
-        }
-
-        memcpy(host->packetData [1], header, headerSize);
-        host->receivedData       = host->packetData [1];
-        host->receivedDataLength = headerSize + originalSize;
-    }
-
-    if (host->checksum != NULL) {
-        enet_uint32 *checksum = (enet_uint32 *) &host->receivedData [headerSize - sizeof(enet_uint32)],
-          desiredChecksum     = *checksum;
-        ENetBuffer buffer;
-
-        *checksum = peer != NULL ? peer->connectID : 0;
-
-        buffer.data       = host->receivedData;
-        buffer.dataLength = host->receivedDataLength;
-
-        if (host->checksum(&buffer, 1) != desiredChecksum) {
-            return 0;
-        }
-    }
-
-    if (peer != NULL) {
-        peer->address.host       = host->receivedAddress.host;
-        peer->address.port       = host->receivedAddress.port;
-        peer->incomingDataTotal += host->receivedDataLength;
-    }
-
-    currentData = host->receivedData + headerSize;
-
-    while (currentData < &host->receivedData [host->receivedDataLength]) {
-        enet_uint8 commandNumber;
-        size_t commandSize;
-
-        command = (ENetProtocol *) currentData;
-
-        if (currentData + sizeof(ENetProtocolCommandHeader) > &host->receivedData [host->receivedDataLength]) {
-            break;
-        }
-
-        commandNumber = command->header.command & ENET_PROTOCOL_COMMAND_MASK;
-        if (commandNumber >= ENET_PROTOCOL_COMMAND_COUNT) {
-            break;
-        }
-
-        commandSize = commandSizes [commandNumber];
-        if (commandSize == 0 || currentData + commandSize > &host->receivedData [host->receivedDataLength]) {
-            break;
-        }
-
-        currentData += commandSize;
-
-        if (peer == NULL && commandNumber != ENET_PROTOCOL_COMMAND_CONNECT) {
-            break;
-        }
-
-        command->header.reliableSequenceNumber = ENET_NET_TO_HOST_16(command->header.reliableSequenceNumber);
-
-        switch (commandNumber) {
-            case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
-                if (enet_protocol_handle_acknowledge(host, event, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_CONNECT:
-                if (peer != NULL) {
-                    goto commandError;
-                }
-                peer = enet_protocol_handle_connect(host, header, command);
-                if (peer == NULL) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
-                if (enet_protocol_handle_verify_connect(host, event, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_DISCONNECT:
-                if (enet_protocol_handle_disconnect(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_PING:
-                if (enet_protocol_handle_ping(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-                if (enet_protocol_handle_send_reliable(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-                if (enet_protocol_handle_send_unreliable(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-                if (enet_protocol_handle_send_unsequenced(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-                if (enet_protocol_handle_send_fragment(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
-                if (enet_protocol_handle_bandwidth_limit(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
-                if (enet_protocol_handle_throttle_configure(host, peer, command)) {
-                    goto commandError;
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-                if (enet_protocol_handle_send_unreliable_fragment(host, peer, command, &currentData)) {
-                    goto commandError;
-                }
-                break;
-
-            default:
-                goto commandError;
-        }
-
-        if (peer != NULL &&
-          (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0)
-        {
-            enet_uint16 sentTime;
-
-            if (!(flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)) {
-                break;
-            }
-
-            sentTime = ENET_NET_TO_HOST_16(header->sentTime);
-
-            switch (peer->state) {
-                case ENET_PEER_STATE_DISCONNECTING:
-                case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-                case ENET_PEER_STATE_DISCONNECTED:
-                case ENET_PEER_STATE_ZOMBIE:
-                    break;
-
-                case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
-                    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                        enet_peer_queue_acknowledgement(peer, command, sentTime);
-                    }
-                    break;
-
-                default:
-                    enet_peer_queue_acknowledgement(peer, command, sentTime);
-                    break;
-            }
-        }
-    }
-
-commandError:
-    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-        return 1;
-    }
-
-    return 0;
-} /* enet_protocol_handle_incoming_commands */
-
-static int enet_protocol_receive_incoming_commands(ENetHost *host, ENetEvent *event) {
-    int packets;
-
-    for (packets = 0; packets < 256; ++packets) {
-        int receivedLength;
-        ENetBuffer buffer;
-
-        buffer.data       = host->packetData [0];
-        buffer.dataLength = sizeof(host->packetData [0]);
-
-        receivedLength = enet_socket_receive(host->socket,
-            &host->receivedAddress,
-            &buffer,
-            1);
-
-        if (receivedLength < 0) {
-            return -1;
-        }
-
-        if (receivedLength == 0) {
-            return 0;
-        }
-
-        host->receivedData       = host->packetData [0];
-        host->receivedDataLength = receivedLength;
-
-        host->totalReceivedData += receivedLength;
-        host->totalReceivedPackets++;
-
-        if (host->intercept != NULL) {
-            switch (host->intercept(host, event)) {
-                case 1:
-                    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                        return 1;
-                    }
-
-                    continue;
-
-                case -1:
-                    return -1;
-
-                default:
-                    break;
-            }
-        }
-
-        switch (enet_protocol_handle_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                return -1;
-
-            default:
-                break;
-        }
-    }
-
-    return -1;
-} /* enet_protocol_receive_incoming_commands */
-
-static void enet_protocol_send_acknowledgements(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetAcknowledgement *acknowledgement;
-    ENetListIterator currentAcknowledgement;
-    enet_uint16 reliableSequenceNumber;
-
-    currentAcknowledgement = enet_list_begin(&peer->acknowledgements);
-
-    while (currentAcknowledgement != enet_list_end(&peer->acknowledgements)) {
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < sizeof(ENetProtocolAcknowledge))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        acknowledgement = (ENetAcknowledgement *) currentAcknowledgement;
-
-        currentAcknowledgement = enet_list_next(currentAcknowledgement);
-
-        buffer->data       = command;
-        buffer->dataLength = sizeof(ENetProtocolAcknowledge);
-
-        host->packetSize += buffer->dataLength;
-
-        reliableSequenceNumber = ENET_HOST_TO_NET_16(acknowledgement->command.header.reliableSequenceNumber);
-
-        command->header.command   = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
-        command->header.channelID = acknowledgement->command.header.channelID;
-        command->header.reliableSequenceNumber = reliableSequenceNumber;
-        command->acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
-        command->acknowledge.receivedSentTime = ENET_HOST_TO_NET_16(acknowledgement->sentTime);
-
-        if ((acknowledgement->command.header.command & ENET_PROTOCOL_COMMAND_MASK) ==
-          ENET_PROTOCOL_COMMAND_DISCONNECT)
-        {
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        }
-
-        enet_list_remove(&acknowledgement->acknowledgementList);
-        enet_free(acknowledgement);
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-} /* enet_protocol_send_acknowledgements */
-
-static void enet_protocol_send_unreliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand;
-
-    currentCommand = enet_list_begin(&peer->outgoingUnreliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->outgoingUnreliableCommands)) {
-        size_t commandSize;
-
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-        commandSize     = commandSizes [outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer + 1 >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < commandSize ||
-          (outgoingCommand->packet != NULL &&
-          peer->mtu - host->packetSize < commandSize + outgoingCommand->fragmentLength))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (outgoingCommand->packet != NULL && outgoingCommand->fragmentOffset == 0) {
-            peer->packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
-            peer->packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-
-            if (peer->packetThrottleCounter > peer->packetThrottle) {
-                enet_uint16 reliableSequenceNumber = outgoingCommand->reliableSequenceNumber,
-                  unreliableSequenceNumber         = outgoingCommand->unreliableSequenceNumber;
-                for (;;) {
-                    --outgoingCommand->packet->referenceCount;
-
-                    if (outgoingCommand->packet->referenceCount == 0) {
-                        enet_packet_destroy(outgoingCommand->packet);
-                    }
-
-                    enet_list_remove(&outgoingCommand->outgoingCommandList);
-                    enet_free(outgoingCommand);
-
-                    if (currentCommand == enet_list_end(&peer->outgoingUnreliableCommands)) {
-                        break;
-                    }
-
-                    outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-                    if (outgoingCommand->reliableSequenceNumber != reliableSequenceNumber ||
-                      outgoingCommand->unreliableSequenceNumber != unreliableSequenceNumber)
-                    {
-                        break;
-                    }
-
-                    currentCommand = enet_list_next(currentCommand);
-                }
-
-                continue;
-            }
-        }
-
-        buffer->data       = command;
-        buffer->dataLength = commandSize;
-
-        host->packetSize += buffer->dataLength;
-
-        *command = outgoingCommand->command;
-
-        enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-        if (outgoingCommand->packet != NULL) {
-            ++buffer;
-
-            buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-            buffer->dataLength = outgoingCommand->fragmentLength;
-
-            host->packetSize += buffer->dataLength;
-
-            enet_list_insert(enet_list_end(&peer->sentUnreliableCommands), outgoingCommand);
-        } else {
-            enet_free(outgoingCommand);
-        }
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-
-    if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER &&
-      enet_list_empty(&peer->outgoingReliableCommands) &&
-      enet_list_empty(&peer->outgoingUnreliableCommands) &&
-      enet_list_empty(&peer->sentReliableCommands))
-    {
-        enet_peer_disconnect(peer, peer->eventData);
-    }
-} /* enet_protocol_send_unreliable_outgoing_commands */
-
-static int enet_protocol_check_timeouts(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand, insertPosition;
-
-    currentCommand = enet_list_begin(&peer->sentReliableCommands);
-    insertPosition = enet_list_begin(&peer->outgoingReliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->sentReliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (ENET_TIME_DIFFERENCE(host->serviceTime, outgoingCommand->sentTime) < outgoingCommand->roundTripTimeout) {
-            continue;
-        }
-
-        if (peer->earliestTimeout == 0 ||
-          ENET_TIME_LESS(outgoingCommand->sentTime, peer->earliestTimeout))
-        {
-            peer->earliestTimeout = outgoingCommand->sentTime;
-        }
-
-        if (peer->earliestTimeout != 0 &&
-          (ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMaximum ||
-          (outgoingCommand->roundTripTimeout >= outgoingCommand->roundTripTimeoutLimit &&
-          ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMinimum)))
-        {
-            enet_protocol_notify_disconnect(host, peer, event);
-
-            return 1;
-        }
-
-        if (outgoingCommand->packet != NULL) {
-            peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-        }
-
-        ++peer->packetsLost;
-
-        outgoingCommand->roundTripTimeout *= 2;
-
-        enet_list_insert(insertPosition, enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-        if (currentCommand == enet_list_begin(&peer->sentReliableCommands) &&
-          !enet_list_empty(&peer->sentReliableCommands))
-        {
-            outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-            peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-        }
-    }
-
-    return 0;
-} /* enet_protocol_check_timeouts */
-
-static int enet_protocol_send_reliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-    ENetProtocol *command = &host->commands [host->commandCount];
-    ENetBuffer *buffer    = &host->buffers [host->bufferCount];
-    ENetOutgoingCommand *outgoingCommand;
-    ENetListIterator currentCommand;
-    ENetChannel *channel;
-    enet_uint16 reliableWindow;
-    size_t commandSize;
-    int windowExceeded = 0, windowWrap = 0, canPing = 1;
-
-    currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-
-    while (currentCommand != enet_list_end(&peer->outgoingReliableCommands)) {
-        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
-        channel = outgoingCommand->command.header.channelID <
-          peer->channelCount ? &peer->channels [outgoingCommand->command.header.channelID] : NULL;
-        reliableWindow = outgoingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        if (channel != NULL) {
-            if (!windowWrap &&
-              outgoingCommand->sendAttempts < 1 &&
-              !(outgoingCommand->reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
-              (channel->reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1)
-              % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
-              channel->usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow)
-              | (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
-            {
-                windowWrap = 1;
-            }
-            if (windowWrap) {
-                currentCommand = enet_list_next(currentCommand);
-
-                continue;
-            }
-        }
-
-        if (outgoingCommand->packet != NULL) {
-            if (!windowExceeded) {
-                enet_uint32 windowSize = (peer->packetThrottle * peer->windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
-
-                if (peer->reliableDataInTransit + outgoingCommand->fragmentLength > ENET_MAX(windowSize, peer->mtu)) {
-                    windowExceeded = 1;
-                }
-            }
-            if (windowExceeded) {
-                currentCommand = enet_list_next(currentCommand);
-
-                continue;
-            }
-        }
-
-        canPing = 0;
-
-        commandSize = commandSizes [outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-        if (command >= &host->commands [sizeof(host->commands) / sizeof(ENetProtocol)] ||
-          buffer + 1 >= &host->buffers [sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-          peer->mtu - host->packetSize < commandSize ||
-          (outgoingCommand->packet != NULL &&
-          (enet_uint16) (peer->mtu - host->packetSize) < (enet_uint16) (commandSize + outgoingCommand->fragmentLength)))
-        {
-            host->continueSending = 1;
-
-            break;
-        }
-
-        currentCommand = enet_list_next(currentCommand);
-
-        if (channel != NULL && outgoingCommand->sendAttempts < 1) {
-            channel->usedReliableWindows |= 1 << reliableWindow;
-            ++channel->reliableWindows [reliableWindow];
-        }
-
-        ++outgoingCommand->sendAttempts;
-
-        if (outgoingCommand->roundTripTimeout == 0) {
-            outgoingCommand->roundTripTimeout      = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
-            outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
-        }
-
-        if (enet_list_empty(&peer->sentReliableCommands)) {
-            peer->nextTimeout = host->serviceTime + outgoingCommand->roundTripTimeout;
-        }
-
-        enet_list_insert(enet_list_end(&peer->sentReliableCommands),
-          enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-        outgoingCommand->sentTime = host->serviceTime;
-
-        buffer->data       = command;
-        buffer->dataLength = commandSize;
-
-        host->packetSize  += buffer->dataLength;
-        host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
-
-        *command = outgoingCommand->command;
-
-        if (outgoingCommand->packet != NULL) {
-            ++buffer;
-
-            buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-            buffer->dataLength = outgoingCommand->fragmentLength;
-
-            host->packetSize += outgoingCommand->fragmentLength;
-
-            peer->reliableDataInTransit += outgoingCommand->fragmentLength;
-        }
-
-        ++peer->packetsSent;
-
-        ++command;
-        ++buffer;
-    }
-
-    host->commandCount = command - host->commands;
-    host->bufferCount  = buffer - host->buffers;
-
-    return canPing;
-} /* enet_protocol_send_reliable_outgoing_commands */
-
-static int enet_protocol_send_outgoing_commands(ENetHost *host, ENetEvent *event, int checkForTimeouts) {
-    enet_uint8 headerData [sizeof(ENetProtocolHeader) + sizeof(enet_uint32)];
-    ENetProtocolHeader *header = (ENetProtocolHeader *) headerData;
-    ENetPeer *currentPeer;
-    int sentLength;
-    size_t shouldCompress = 0;
-
-    host->continueSending = 1;
-
-    while (host->continueSending)
-        for (host->continueSending = 0,
-          currentPeer = host->peers;
-          currentPeer < &host->peers [host->peerCount];
-          ++currentPeer)
-        {
-            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED ||
-              currentPeer->state == ENET_PEER_STATE_ZOMBIE)
-            {
-                continue;
-            }
-
-            host->headerFlags  = 0;
-            host->commandCount = 0;
-            host->bufferCount  = 1;
-            host->packetSize   = sizeof(ENetProtocolHeader);
-
-            if (!enet_list_empty(&currentPeer->acknowledgements)) {
-                enet_protocol_send_acknowledgements(host, currentPeer);
-            }
-
-            if (checkForTimeouts != 0 &&
-              !enet_list_empty(&currentPeer->sentReliableCommands) &&
-              ENET_TIME_GREATER_EQUAL(host->serviceTime, currentPeer->nextTimeout) &&
-              enet_protocol_check_timeouts(host, currentPeer, event) == 1)
-            {
-                if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                    return 1;
-                } else {
-                    continue;
-                }
-            }
-
-            if ((enet_list_empty(&currentPeer->outgoingReliableCommands) ||
-              enet_protocol_send_reliable_outgoing_commands(host, currentPeer)) &&
-              enet_list_empty(&currentPeer->sentReliableCommands) &&
-              ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->lastReceiveTime) >= currentPeer->pingInterval &&
-              currentPeer->mtu - host->packetSize >= sizeof(ENetProtocolPing))
-            {
-                enet_peer_ping(currentPeer);
-                enet_protocol_send_reliable_outgoing_commands(host, currentPeer);
-            }
-
-            if (!enet_list_empty(&currentPeer->outgoingUnreliableCommands)) {
-                enet_protocol_send_unreliable_outgoing_commands(host, currentPeer);
-            }
-
-            if (host->commandCount == 0) {
-                continue;
-            }
-
-            if (currentPeer->packetLossEpoch == 0) {
-                currentPeer->packetLossEpoch = host->serviceTime;
-            } else if (ENET_TIME_DIFFERENCE(host->serviceTime,
-              currentPeer->packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL &&
-              currentPeer->packetsSent > 0)
-            {
-                enet_uint32 packetLoss = currentPeer->packetsLost * ENET_PEER_PACKET_LOSS_SCALE
-                  / currentPeer->packetsSent;
-
-                #ifdef ENET_DEBUG
-                printf(
-                    "peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer->incomingPeerID,
-                    currentPeer->packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE,
-                    currentPeer->packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer->roundTripTime, currentPeer->roundTripTimeVariance,
-                    currentPeer->packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE,
-                    enet_list_size(&currentPeer->outgoingReliableCommands),
-                    enet_list_size(
-                        &currentPeer->outgoingUnreliableCommands),
-                    currentPeer->channels != NULL ? enet_list_size(
-                        &currentPeer->channels->incomingReliableCommands) : 0,
-                    currentPeer->channels !=
-                    NULL ? enet_list_size(&currentPeer->channels->incomingUnreliableCommands) : 0);
-                #endif
-
-                currentPeer->packetLossVariance -= currentPeer->packetLossVariance / 4;
-
-                if (packetLoss >= currentPeer->packetLoss) {
-                    currentPeer->packetLoss         += (packetLoss - currentPeer->packetLoss) / 8;
-                    currentPeer->packetLossVariance += (packetLoss - currentPeer->packetLoss) / 4;
-                } else {
-                    currentPeer->packetLoss         -= (currentPeer->packetLoss - packetLoss) / 8;
-                    currentPeer->packetLossVariance += (currentPeer->packetLoss - packetLoss) / 4;
-                }
-
-                currentPeer->packetLossEpoch = host->serviceTime;
-                currentPeer->packetsSent     = 0;
-                currentPeer->packetsLost     = 0;
-            }
-
-            host->buffers->data = headerData;
-            if (host->headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) {
-                header->sentTime = ENET_HOST_TO_NET_16(host->serviceTime & 0xFFFF);
-
-                host->buffers->dataLength = sizeof(ENetProtocolHeader);
-            } else {
-                host->buffers->dataLength = (size_t) &((ENetProtocolHeader *) 0)->sentTime;
-            }
-
-            shouldCompress = 0;
-            if (host->compressor.context != NULL && host->compressor.compress != NULL) {
-                size_t originalSize = host->packetSize - sizeof(ENetProtocolHeader),
-                  compressedSize    = host->compressor.compress(host->compressor.context,
-                    &host->buffers [1], host->bufferCount - 1,
-                    originalSize,
-                    host->packetData [1],
-                    originalSize);
-                if (compressedSize > 0 && compressedSize < originalSize) {
-                    host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED;
-                    shouldCompress     = compressedSize;
-                    #ifdef ENET_DEBUG_COMPRESS
-                    printf("peer %u: compressed %u -> %u (%u%%)\n", currentPeer->incomingPeerID, originalSize,
-                      compressedSize, (compressedSize * 100) / originalSize);
-                    #endif
-                }
-            }
-
-            if (currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID) {
-                host->headerFlags |= currentPeer->outgoingSessionID << ENET_PROTOCOL_HEADER_SESSION_SHIFT;
-            }
-            header->peerID = ENET_HOST_TO_NET_16(currentPeer->outgoingPeerID | host->headerFlags);
-            if (host->checksum != NULL) {
-                enet_uint32 *checksum = (enet_uint32 *) &headerData [host->buffers->dataLength];
-                *checksum = currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer->connectID : 0;
-                host->buffers->dataLength += sizeof(enet_uint32);
-                *checksum = host->checksum(host->buffers, host->bufferCount);
-            }
-
-            if (shouldCompress > 0) {
-                host->buffers [1].data       = host->packetData [1];
-                host->buffers [1].dataLength = shouldCompress;
-                host->bufferCount = 2;
-            }
-
-            currentPeer->lastSendTime = host->serviceTime;
-
-            sentLength = enet_socket_send(host->socket, &currentPeer->address, host->buffers, host->bufferCount);
-
-            enet_protocol_remove_sent_unreliable_commands(currentPeer);
-
-            if (sentLength < 0) {
-                return -1;
-            }
-
-            host->totalSentData += sentLength;
-            host->totalSentPackets++;
-        }
-
-    return 0;
-} /* enet_protocol_send_outgoing_commands */
-
-/** Sends any queued packets on the host specified to its designated peers.
- *
- *  @param host   host to flush
- *  @remarks this function need only be used in circumstances where one wishes to send queued packets earlier than in a call to enet_host_service().
- *  @ingroup host
- */
-void enet_host_flush(ENetHost *host) {
-    host->serviceTime = enet_time_get();
-
-    enet_protocol_send_outgoing_commands(host, NULL, 0);
-}
-
-/** Checks for any queued events on the host and dispatches one if available.
- *
- *  @param host    host to check for events
- *  @param event   an event structure where event details will be placed if available
- *  @retval > 0 if an event was dispatched
- *  @retval 0 if no events are available
- *  @retval < 0 on failure
- *  @ingroup host
- */
-int enet_host_check_events(ENetHost *host, ENetEvent *event) {
-    if (event == NULL) { return -1; }
-
-    event->type   = ENET_EVENT_TYPE_NONE;
-    event->peer   = NULL;
-    event->packet = NULL;
-
-    return enet_protocol_dispatch_incoming_commands(host, event);
-}
-
-/** Waits for events on the host specified and shuttles packets between
- *  the host and its peers.
- *
- *  @param host    host to service
- *  @param event   an event structure where event details will be placed if one occurs
- *                 if event == NULL then no events will be delivered
- *  @param timeout number of milliseconds that ENet should wait for events
- *  @retval > 0 if an event occurred within the specified time limit
- *  @retval 0 if no event occurred
- *  @retval < 0 on failure
- *  @remarks enet_host_service should be called fairly regularly for adequate performance
- *  @ingroup host
- */
-int enet_host_service(ENetHost *host, ENetEvent *event, enet_uint32 timeout) {
-    enet_uint32 waitCondition;
-
-    if (event != NULL) {
-        event->type   = ENET_EVENT_TYPE_NONE;
-        event->peer   = NULL;
-        event->packet = NULL;
-
-        switch (enet_protocol_dispatch_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #ifdef ENET_DEBUG
-                perror("Error dispatching incoming packets");
-                #endif
-
-                return -1;
-
-            default:
-                break;
-        }
-    }
-
-    host->serviceTime = enet_time_get();
-
-    timeout += host->serviceTime;
-
-    do {
-        if (ENET_TIME_DIFFERENCE(host->serviceTime,
-          host->bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
-        {
-            enet_host_bandwidth_throttle(host);
-        }
-
-        switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #ifdef ENET_DEBUG
-                perror("Error sending outgoing packets");
-                #endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        switch (enet_protocol_receive_incoming_commands(host, event)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #ifdef ENET_DEBUG
-                perror("Error receiving incoming packets");
-                #endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-            case 1:
-                return 1;
-
-            case -1:
-                #ifdef ENET_DEBUG
-                perror("Error sending outgoing packets");
-                #endif
-
-                return -1;
-
-            default:
-                break;
-        }
-
-        if (event != NULL) {
-            switch (enet_protocol_dispatch_incoming_commands(host, 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(host->serviceTime, timeout)) {
-            return 0;
-        }
-
-        do {
-            host->serviceTime = enet_time_get();
-
-            if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
-                return 0;
-            }
-
-            waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
-
-            if (enet_socket_wait(host->socket, &waitCondition, ENET_TIME_DIFFERENCE(timeout, host->serviceTime)) != 0) {
-                return -1;
-            }
-        } while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
-
-        host->serviceTime = enet_time_get();
-    } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
-
-    return 0;
-} /* enet_host_service */

src/unix.c

@@ -1,616 +0,0 @@
-/** 
- @file  unix.c
- @brief ENet Unix system specific functions
-*/
-#ifndef _WIN32
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <arpa/inet.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <time.h>
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-#ifdef __APPLE__
-#ifdef HAS_POLL
-#undef HAS_POLL
-#endif
-#ifndef HAS_FCNTL
-#define HAS_FCNTL 1
-#endif
-#ifndef HAS_INET_PTON
-#define HAS_INET_PTON 1
-#endif
-#ifndef HAS_INET_NTOP
-#define HAS_INET_NTOP 1
-#endif
-#ifndef HAS_MSGHDR_FLAGS
-#define HAS_MSGHDR_FLAGS 1
-#endif
-#ifndef HAS_SOCKLEN_T
-#define HAS_SOCKLEN_T 1
-#endif
-#ifndef HAS_GETADDRINFO
-#define HAS_GETADDRINFO 1
-#endif
-#ifndef HAS_GETNAMEINFO
-#define HAS_GETNAMEINFO 1
-#endif
-#endif
-
-#ifdef HAS_FCNTL
-#include <fcntl.h>
-#endif
-
-#ifdef HAS_POLL
-#include <sys/poll.h>
-#endif
-
-#ifndef HAS_SOCKLEN_T
-typedef int socklen_t;
-#endif
-
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
-
-static enet_uint64 timeBase = 0;
-
-int
-enet_initialize (void)
-{
-    return 0;
-}
-
-void
-enet_deinitialize (void)
-{
-}
-
-enet_uint64
-enet_host_random_seed (void)
-{
-    return (enet_uint64) time (NULL);
-}
-
-enet_uint64
-enet_time_get (void)
-{
-    struct timeval timeVal;
-
-    gettimeofday (& timeVal, NULL);
-
-    return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
-}
-
-void
-enet_time_set (enet_uint64 newTimeBase)
-{
-    struct timeval timeVal;
-
-    gettimeofday (& timeVal, NULL);
-    
-    timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
-}
-
-int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
-{
-#ifdef HAS_INET_PTON
-    if (! inet_pton (AF_INET, name, & address -> host))
-#else
-    if (! inet_aton (name, (struct in_addr *) & address -> host))
-#endif
-        return -1;
-
-    return 0;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{
-#ifdef HAS_GETADDRINFO
-    struct addrinfo hints, * resultList = NULL, * result = NULL;
-
-    memset (& hints, 0, sizeof (hints));
-    hints.ai_family = AF_INET;
-
-    if (getaddrinfo (name, NULL, NULL, & resultList) != 0)
-      return -1;
-
-    for (result = resultList; result != NULL; result = result -> ai_next)
-    {
-        if (result -> ai_family == AF_INET && result -> ai_addr != NULL && result -> ai_addrlen >= sizeof (struct sockaddr_in))
-        {
-            struct sockaddr_in * sin = (struct sockaddr_in *) result -> ai_addr;
-
-            address -> host = sin -> sin_addr.s_addr;
-
-            freeaddrinfo (resultList);
-
-            return 0;
-        }
-    }
-
-    if (resultList != NULL)
-      freeaddrinfo (resultList);
-#else
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYNAME_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    hostEntry = gethostbyname (name);
-#endif
-
-    if (hostEntry != NULL && hostEntry -> h_addrtype == AF_INET)
-    {
-        address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
-        return 0;
-    }
-#endif
-
-    return enet_address_set_host_ip (address, name);
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_INET_NTOP
-    if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
-#else
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr != NULL)
-    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    } 
-    else
-#endif
-        return -1;
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_GETNAMEINFO
-    struct sockaddr_in sin;
-    int err;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    err = getnameinfo ((struct sockaddr *) & sin, sizeof (sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-    if (! err)
-    {
-        if (name != NULL && nameLength > 0 && ! memchr (name, '\0', nameLength))
-          return -1;
-        return 0;
-    }
-    if (err != EAI_NONAME)
-      return -1;
-#else
-    struct in_addr in;
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYADDR_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    in.s_addr = address -> host;
-
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    in.s_addr = address -> host;
-
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-#endif
-
-    if (hostEntry != NULL)
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
-       return 0;
-    }
-#endif
-
-    return enet_address_get_host_ip (address, name, nameLength);
-}
-
-int
-enet_socket_bind (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)); 
-}
-
-int
-enet_socket_get_address (ENetSocket socket, ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
-
-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
-      return -1;
-
-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
-    return 0;
-}
-
-int 
-enet_socket_listen (ENetSocket socket, int backlog)
-{
-    return listen (socket, backlog < 0 ? SOMAXCONN : backlog);
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type)
-{
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int
-enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
-{
-    int result = -1;
-    switch (option)
-    {
-        case ENET_SOCKOPT_NONBLOCK:
-#ifdef HAS_FCNTL
-            result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK));
-#else
-            result = ioctl (socket, FIONBIO, & value);
-#endif
-            break;
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-        {
-            struct timeval timeVal;
-            timeVal.tv_sec = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & timeVal, sizeof (struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_SNDTIMEO:
-        {
-            struct timeval timeVal;
-            timeVal.tv_sec = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & timeVal, sizeof (struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int
-enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
-{
-    int result = -1;
-    socklen_t len;
-    switch (option)
-    {
-        case ENET_SOCKOPT_ERROR:
-            len = sizeof (int);
-            result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len);
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int result;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-    if (result == -1 && errno == EINPROGRESS)
-      return 0;
-
-    return result;
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{
-    int result;
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
-
-    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
-    
-    if (result == -1)
-      return ENET_SOCKET_NULL;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return result;
-} 
-    
-int
-enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
-{
-    return shutdown (socket, (int) how);
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{
-    if (socket != -1)
-      close (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
-                  const ENetAddress * address,
-                  const ENetBuffer * buffers,
-                  size_t bufferCount)
-{
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int sentLength;
-
-    memset (& msgHdr, 0, sizeof (struct msghdr));
-
-    if (address != NULL)
-    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
-
-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
-
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
-    
-    if (sentLength == -1)
-    {
-       if (errno == EWOULDBLOCK)
-         return 0;
-
-       return -1;
-    }
-
-    return sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
-                     ENetAddress * address,
-                     ENetBuffer * buffers,
-                     size_t bufferCount)
-{
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int recvLength;
-
-    memset (& msgHdr, 0, sizeof (struct msghdr));
-
-    if (address != NULL)
-    {
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
-
-    if (recvLength == -1)
-    {
-       if (errno == EWOULDBLOCK)
-         return 0;
-
-       return -1;
-    }
-
-#ifdef HAS_MSGHDR_FLAGS
-    if (msgHdr.msg_flags & MSG_TRUNC)
-      return -1;
-#endif
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return recvLength;
-}
-
-int
-enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
-{
-    struct timeval timeVal;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint64 timeout)
-{
-#ifdef HAS_POLL
-    struct pollfd pollSocket;
-    int pollCount;
-    
-    pollSocket.fd = socket;
-    pollSocket.events = 0;
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      pollSocket.events |= POLLOUT;
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      pollSocket.events |= POLLIN;
-
-    pollCount = poll (& pollSocket, 1, timeout);
-
-    if (pollCount < 0)
-    {
-        if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
-        {
-            * condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (pollCount == 0)
-      return 0;
-
-    if (pollSocket.revents & POLLOUT)
-      * condition |= ENET_SOCKET_WAIT_SEND;
-    
-    if (pollSocket.revents & POLLIN)
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-#else
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO (& readSet);
-    FD_ZERO (& writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      FD_SET (socket, & writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      FD_SET (socket, & readSet);
-
-    selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
-    if (selectCount < 0)
-    {
-        if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
-        {
-            * condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-      
-        return -1;
-    }
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0)
-      return 0;
-
-    if (FD_ISSET (socket, & writeSet))
-      * condition |= ENET_SOCKET_WAIT_SEND;
-
-    if (FD_ISSET (socket, & readSet))
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-#endif
-}
-
-#endif
-

src/unix.c.us.c

@@ -1,578 +0,0 @@
-/**
- * @file  unix.c
- * @brief ENet Unix system specific functions
- */
-#ifndef _WIN32
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <arpa/inet.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <time.h>
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-
-#ifdef __APPLE__
-# ifdef HAS_POLL
-#  undef HAS_POLL
-# endif
-# ifndef HAS_FCNTL
-#  define HAS_FCNTL 1
-# endif
-# ifndef HAS_INET_PTON
-#  define HAS_INET_PTON 1
-# endif
-# ifndef HAS_INET_NTOP
-#  define HAS_INET_NTOP 1
-# endif
-# ifndef HAS_MSGHDR_FLAGS
-#  define HAS_MSGHDR_FLAGS 1
-# endif
-# ifndef HAS_SOCKLEN_T
-#  define HAS_SOCKLEN_T 1
-# endif
-# ifndef HAS_GETADDRINFO
-#  define HAS_GETADDRINFO 1
-# endif
-# ifndef HAS_GETNAMEINFO
-#  define HAS_GETNAMEINFO 1
-# endif
-#endif /* ifdef __APPLE__ */
-
-#ifdef HAS_FCNTL
-# include <fcntl.h>
-#endif
-
-#ifdef HAS_POLL
-# include <sys/poll.h>
-#endif
-
-#ifndef HAS_SOCKLEN_T
-typedef int socklen_t;
-#endif
-
-#ifndef MSG_NOSIGNAL
-# define MSG_NOSIGNAL 0
-#endif
-
-static enet_uint64 timeBase = 0;
-
-int enet_initialize(void) {
-    return 0;
-}
-
-void enet_deinitialize(void)
-{ }
-
-enet_uint64 enet_host_random_seed(void) {
-    return (enet_uint64) time(NULL);
-}
-
-enet_uint64 enet_time_get(void) {
-    struct timeval timeVal;
-
-    gettimeofday(&timeVal, NULL);
-
-    return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
-}
-
-void enet_time_set(enet_uint64 newTimeBase) {
-    struct timeval timeVal;
-
-    gettimeofday(&timeVal, NULL);
-
-    timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
-}
-
-int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-    #ifdef HAS_INET_PTON
-    if (!inet_pton(AF_INET, name, &address->host))
-    #else
-    if (!inet_aton(name, (struct in_addr *) &address->host))
-    #endif
-    { return -1; }
-
-    return 0;
-}
-
-int enet_address_set_host(ENetAddress *address, const char *name) {
-    #ifdef HAS_GETADDRINFO
-    struct addrinfo hints, *resultList = NULL, *result = NULL;
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET;
-
-    if (getaddrinfo(name, NULL, NULL, &resultList) != 0) {
-        return -1;
-    }
-
-    for (result = resultList; result != NULL; result = result->ai_next) {
-        if (result->ai_family == AF_INET && result->ai_addr != NULL &&
-          result->ai_addrlen >= sizeof(struct sockaddr_in))
-        {
-            struct sockaddr_in *sin = (struct sockaddr_in *) result->ai_addr;
-
-            address->host = sin->sin_addr.s_addr;
-
-            freeaddrinfo(resultList);
-
-            return 0;
-        }
-    }
-
-    if (resultList != NULL) {
-        freeaddrinfo(resultList);
-    }
-    #else  /* ifdef HAS_GETADDRINFO */
-    struct hostent *hostEntry = NULL;
-    # ifdef HAS_GETHOSTBYNAME_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    #  if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
-    #  else
-    hostEntry = gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &errnum);
-    #  endif
-    # else
-    hostEntry = gethostbyname(name);
-    # endif /* ifdef HAS_GETHOSTBYNAME_R */
-
-    if (hostEntry != NULL && hostEntry->h_addrtype == AF_INET) {
-        address->host = *(enet_uint32 *) hostEntry->h_addr_list [0];
-
-        return 0;
-    }
-    #endif /* ifdef HAS_GETADDRINFO */
-
-    return enet_address_set_host_ip(address, name);
-} /* enet_address_set_host */
-
-int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-    #ifdef HAS_INET_NTOP
-    if (inet_ntop(AF_INET, &address->host, name, nameLength) == NULL)
-    #else
-    char *addr = inet_ntoa(*(struct in_addr *) &address->host);
-    if (addr != NULL) {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, addr, addrLen + 1);
-    } else
-    #endif
-    { return -1; }
-    return 0;
-}
-
-int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-    #ifdef HAS_GETNAMEINFO
-    struct sockaddr_in sin;
-    int err;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    err = getnameinfo((struct sockaddr *) &sin, sizeof(sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-    if (!err) {
-        if (name != NULL && nameLength > 0 && !memchr(name, '\0', nameLength)) {
-            return -1;
-        }
-        return 0;
-    }
-    if (err != EAI_NONAME) {
-        return -1;
-    }
-    #else  /* ifdef HAS_GETNAMEINFO */
-    struct in_addr in;
-    struct hostent *hostEntry = NULL;
-    # ifdef HAS_GETHOSTBYADDR_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    in.s_addr = address->host;
-
-    #  if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__EMSCRIPTEN__)
-    gethostbyaddr_r((char *) &in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &hostEntry,
-      &errnum);
-    #  else
-    hostEntry = gethostbyaddr_r((char *) &in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer),
-        &errnum);
-    #  endif
-    # else  /* ifdef HAS_GETHOSTBYADDR_R */
-    in.s_addr = address->host;
-
-    hostEntry = gethostbyaddr((char *) &in, sizeof(struct in_addr), AF_INET);
-    # endif /* ifdef HAS_GETHOSTBYADDR_R */
-
-    if (hostEntry != NULL) {
-        size_t hostLen = strlen(hostEntry->h_name);
-        if (hostLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, hostEntry->h_name, hostLen + 1);
-        return 0;
-    }
-    #endif /* ifdef HAS_GETNAMEINFO */
-
-    return enet_address_get_host_ip(address, name, nameLength);
-} /* enet_address_get_host */
-
-int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL) {
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    } else {
-        sin.sin_port        = 0;
-        sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind(socket,
-             (struct sockaddr *) &sin,
-             sizeof(struct sockaddr_in));
-}
-
-int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof(struct sockaddr_in);
-
-    if (getsockname(socket, (struct sockaddr *) &sin, &sinLength) == -1) {
-        return -1;
-    }
-
-    address->host = (enet_uint32) sin.sin_addr.s_addr;
-    address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-
-    return 0;
-}
-
-int enet_socket_listen(ENetSocket socket, int backlog) {
-    return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
-}
-
-ENetSocket enet_socket_create(ENetSocketType type) {
-    return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-    int result = -1;
-
-    switch (option) {
-        case ENET_SOCKOPT_NONBLOCK:
-            #ifdef HAS_FCNTL
-            result = fcntl(socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl(socket, F_GETFL) & ~O_NONBLOCK));
-            #else
-            result = ioctl(socket, FIONBIO, &value);
-            #endif
-            break;
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO: {
-            struct timeval timeVal;
-            timeVal.tv_sec  = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeVal, sizeof(struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_SNDTIMEO: {
-            struct timeval timeVal;
-            timeVal.tv_sec  = value / 1000;
-            timeVal.tv_usec = (value % 1000) * 1000;
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeVal, sizeof(struct timeval));
-            break;
-        }
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *) &value, sizeof(int));
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-} /* enet_socket_set_option */
-
-int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-    int result = -1;
-    socklen_t len;
-
-    switch (option) {
-        case ENET_SOCKOPT_ERROR:
-            len    = sizeof(int);
-            result = getsockopt(socket, SOL_SOCKET, SO_ERROR, value, &len);
-            break;
-
-        default:
-            break;
-    }
-    return result == -1 ? -1 : 0;
-}
-
-int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-    int result;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    result = connect(socket, (struct sockaddr *) &sin, sizeof(struct sockaddr_in));
-    if (result == -1 && errno == EINPROGRESS) {
-        return 0;
-    }
-
-    return result;
-}
-
-ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-    int result;
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof(struct sockaddr_in);
-
-    result = accept(socket,
-        address != NULL ? (struct sockaddr *) &sin : NULL,
-        address != NULL ? &sinLength : NULL);
-
-    if (result == -1) {
-        return ENET_SOCKET_NULL;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return result;
-}
-
-int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-    return shutdown(socket, (int) how);
-}
-
-void enet_socket_destroy(ENetSocket socket) {
-    if (socket != -1) {
-        close(socket);
-    }
-}
-
-int enet_socket_send(ENetSocket socket,
-  const ENetAddress *           address,
-  const ENetBuffer *            buffers,
-  size_t                        bufferCount) {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int sentLength;
-
-    memset(&msgHdr, 0, sizeof(struct msghdr));
-
-    if (address != NULL) {
-        memset(&sin, 0, sizeof(struct sockaddr_in));
-
-        sin.sin_family      = AF_INET;
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-
-        msgHdr.msg_name    = &sin;
-        msgHdr.msg_namelen = sizeof(struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov    = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-    if (sentLength == -1) {
-        if (errno == EWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    return sentLength;
-} /* enet_socket_send */
-
-int enet_socket_receive(ENetSocket socket,
-  ENetAddress *                    address,
-  ENetBuffer *                     buffers,
-  size_t                           bufferCount) {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
-    int recvLength;
-
-    memset(&msgHdr, 0, sizeof(struct msghdr));
-
-    if (address != NULL) {
-        msgHdr.msg_name    = &sin;
-        msgHdr.msg_namelen = sizeof(struct sockaddr_in);
-    }
-
-    msgHdr.msg_iov    = (struct iovec *) buffers;
-    msgHdr.msg_iovlen = bufferCount;
-
-    recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-    if (recvLength == -1) {
-        if (errno == EWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    #ifdef HAS_MSGHDR_FLAGS
-    if (msgHdr.msg_flags & MSG_TRUNC) {
-        return -1;
-    }
-    #endif
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return recvLength;
-} /* enet_socket_receive */
-
-int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-    struct timeval timeVal;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-}
-
-int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-    #ifdef HAS_POLL
-    struct pollfd pollSocket;
-    int pollCount;
-
-    pollSocket.fd     = socket;
-    pollSocket.events = 0;
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        pollSocket.events |= POLLOUT;
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        pollSocket.events |= POLLIN;
-    }
-
-    pollCount = poll(&pollSocket, 1, timeout);
-
-    if (pollCount < 0) {
-        if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
-            *condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (pollCount == 0) {
-        return 0;
-    }
-
-    if (pollSocket.revents & POLLOUT) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (pollSocket.revents & POLLIN) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-
-    #else  /* ifdef HAS_POLL */
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO(&readSet);
-    FD_ZERO(&writeSet);
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        FD_SET(socket, &writeSet);
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        FD_SET(socket, &readSet);
-    }
-
-    selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
-
-    if (selectCount < 0) {
-        if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
-            *condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-            return 0;
-        }
-
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0) {
-        return 0;
-    }
-
-    if (FD_ISSET(socket, &writeSet)) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (FD_ISSET(socket, &readSet)) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-
-    #endif /* ifdef HAS_POLL */
-} /* enet_socket_wait */
-
-#endif /* ifndef _WIN32 */

src/win32.c

@@ -1,442 +0,0 @@
-/** 
- @file  win32.c
- @brief ENet Win32 system specific functions
-*/
-#ifdef _WIN32
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-#include <windows.h>
-#include <mmsystem.h>
-
-static enet_uint64 timeBase = 0;
-
-int
-enet_initialize (void)
-{
-    WORD versionRequested = MAKEWORD (1, 1);
-    WSADATA wsaData;
-   
-    if (WSAStartup (versionRequested, & wsaData))
-       return -1;
-
-    if (LOBYTE (wsaData.wVersion) != 1||
-        HIBYTE (wsaData.wVersion) != 1)
-    {
-       WSACleanup ();
-       
-       return -1;
-    }
-
-    timeBeginPeriod (1);
-
-    return 0;
-}
-
-void
-enet_deinitialize (void)
-{
-    timeEndPeriod (1);
-
-    WSACleanup ();
-}
-
-enet_uint64
-enet_host_random_seed (void)
-{
-    return (enet_uint64) timeGetTime ();
-}
-
-enet_uint64
-enet_time_get (void)
-{
-    return (enet_uint64) timeGetTime () - timeBase;
-}
-
-void
-enet_time_set (enet_uint64 newTimeBase)
-{
-    timeBase = (enet_uint64) timeGetTime () - newTimeBase;
-}
-
-int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
-{
-    enet_uint8 vals [4] = { 0, 0, 0, 0 };
-    int i;
-
-    for (i = 0; i < 4; ++ i)
-    {
-        const char * next = name + 1;
-        if (* name != '0')
-        {
-            long val = strtol (name, (char **) & next, 10);
-            if (val < 0 || val > 255 || next == name || next - name > 3)
-              return -1;
-            vals [i] = (enet_uint8) val;
-        }
-
-        if (* next != (i < 3 ? '.' : '\0'))
-          return -1;
-        name = next + 1;
-    }
-
-    memcpy (& address -> host, vals, sizeof (enet_uint32));
-    return 0;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{
-    struct hostent * hostEntry;
-
-    hostEntry = gethostbyname (name);
-    if (hostEntry == NULL ||
-        hostEntry -> h_addrtype != AF_INET)
-      return enet_address_set_host_ip (address, name);
-
-    address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
-    return 0;
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr == NULL)
-        return -1;
-    else
-    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    }
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-    struct in_addr in;
-    struct hostent * hostEntry;
- 
-    in.s_addr = address -> host;
-    
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-    if (hostEntry == NULL)
-      return enet_address_get_host_ip (address, name, nameLength);
-    else
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
-    }
-
-    return 0;
-}
-
-int
-enet_socket_bind (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_get_address (ENetSocket socket, ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
-
-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
-      return -1;
-
-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
-    return 0;
-}
-
-int
-enet_socket_listen (ENetSocket socket, int backlog)
-{
-    return listen (socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type)
-{
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int
-enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
-{
-    int result = SOCKET_ERROR;
-    switch (option)
-    {
-        case ENET_SOCKOPT_NONBLOCK:
-        {
-            u_long nonBlocking = (u_long) value;
-            result = ioctlsocket (socket, FIONBIO, & nonBlocking);
-            break;
-        }
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-            result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_SNDTIMEO:
-            result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int));
-            break;
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
-{
-    int result = SOCKET_ERROR, len;
-    switch (option)
-    {
-        case ENET_SOCKOPT_ERROR:
-            len = sizeof(int);
-            result = getsockopt (socket, SOL_SOCKET, SO_ERROR, (char *) value, & len);
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{
-    struct sockaddr_in sin;
-    int result;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-    if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)
-      return -1;
-
-    return 0;
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{
-    SOCKET result;
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
-
-    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
-
-    if (result == INVALID_SOCKET)
-      return ENET_SOCKET_NULL;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return result;
-}
-
-int
-enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
-{
-    return shutdown (socket, (int) how) == SOCKET_ERROR ? -1 : 0;
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{
-    if (socket != INVALID_SOCKET)
-      closesocket (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
-                  const ENetAddress * address,
-                  const ENetBuffer * buffers,
-                  size_t bufferCount)
-{
-    struct sockaddr_in sin;
-    DWORD sentLength;
-
-    if (address != NULL)
-    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
-
-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
-    }
-
-    if (WSASendTo (socket, 
-                   (LPWSABUF) buffers,
-                   (DWORD) bufferCount,
-                   & sentLength,
-                   0,
-                   address != NULL ? (struct sockaddr *) & sin : NULL,
-                   address != NULL ? sizeof (struct sockaddr_in) : 0,
-                   NULL,
-                   NULL) == SOCKET_ERROR)
-    {
-       if (WSAGetLastError () == WSAEWOULDBLOCK)
-         return 0;
-
-       return -1;
-    }
-
-    return (int) sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
-                     ENetAddress * address,
-                     ENetBuffer * buffers,
-                     size_t bufferCount)
-{
-    INT sinLength = sizeof (struct sockaddr_in);
-    DWORD flags = 0,
-          recvLength;
-    struct sockaddr_in sin;
-
-    if (WSARecvFrom (socket,
-                     (LPWSABUF) buffers,
-                     (DWORD) bufferCount,
-                     & recvLength,
-                     & flags,
-                     address != NULL ? (struct sockaddr *) & sin : NULL,
-                     address != NULL ? & sinLength : NULL,
-                     NULL,
-                     NULL) == SOCKET_ERROR)
-    {
-       switch (WSAGetLastError ())
-       {
-       case WSAEWOULDBLOCK:
-       case WSAECONNRESET:
-          return 0;
-       }
-
-       return -1;
-    }
-
-    if (flags & MSG_PARTIAL)
-      return -1;
-
-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
-    return (int) recvLength;
-}
-
-int
-enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
-{
-    struct timeval timeVal;
-
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint64 timeout)
-{
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-    
-    timeVal.tv_sec = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-    
-    FD_ZERO (& readSet);
-    FD_ZERO (& writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_SEND)
-      FD_SET (socket, & writeSet);
-
-    if (* condition & ENET_SOCKET_WAIT_RECEIVE)
-      FD_SET (socket, & readSet);
-
-    selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
-    if (selectCount < 0)
-      return -1;
-
-    * condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0)
-      return 0;
-
-    if (FD_ISSET (socket, & writeSet))
-      * condition |= ENET_SOCKET_WAIT_SEND;
-    
-    if (FD_ISSET (socket, & readSet))
-      * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
-    return 0;
-} 
-
-#endif
-

src/win32.c.us.c

@@ -1,403 +0,0 @@
-/**
- * @file  win32.c
- * @brief ENet Win32 system specific functions
- */
-#ifdef _WIN32
-
-#define ENET_BUILDING_LIB 1
-#include "enet/enet.h"
-#include <windows.h>
-#include <mmsystem.h>
-
-static enet_uint64 timeBase = 0;
-
-int enet_initialize(void) {
-    WORD versionRequested = MAKEWORD(1, 1);
-    WSADATA wsaData;
-
-    if (WSAStartup(versionRequested, &wsaData)) {
-        return -1;
-    }
-
-    if (LOBYTE(wsaData.wVersion) != 1 ||
-      HIBYTE(wsaData.wVersion) != 1)
-    {
-        WSACleanup();
-
-        return -1;
-    }
-
-    timeBeginPeriod(1);
-
-    return 0;
-}
-
-void enet_deinitialize(void) {
-    timeEndPeriod(1);
-
-    WSACleanup();
-}
-
-enet_uint64 enet_host_random_seed(void) {
-    return (enet_uint64) timeGetTime();
-}
-
-enet_uint64 enet_time_get(void) {
-    return (enet_uint64) timeGetTime() - timeBase;
-}
-
-void enet_time_set(enet_uint64 newTimeBase) {
-    timeBase = (enet_uint64) timeGetTime() - newTimeBase;
-}
-
-int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-    enet_uint8 vals [4] = { 0, 0, 0, 0 };
-    int i;
-
-    for (i = 0; i < 4; ++i) {
-        const char *next = name + 1;
-        if (*name != '0') {
-            long val = strtol(name, (char **) &next, 10);
-            if (val < 0 || val > 255 || next == name || next - name > 3) {
-                return -1;
-            }
-            vals [i] = (enet_uint8) val;
-        }
-
-        if (*next != (i < 3 ? '.' : '\0')) {
-            return -1;
-        }
-        name = next + 1;
-    }
-
-    memcpy(&address->host, vals, sizeof(enet_uint32));
-    return 0;
-}
-
-int enet_address_set_host(ENetAddress *address, const char *name) {
-    struct hostent *hostEntry;
-
-    hostEntry = gethostbyname(name);
-    if (hostEntry == NULL ||
-      hostEntry->h_addrtype != AF_INET)
-    {
-        return enet_address_set_host_ip(address, name);
-    }
-
-    address->host = *(enet_uint32 *) hostEntry->h_addr_list [0];
-
-    return 0;
-}
-
-int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-    char *addr = inet_ntoa(*(struct in_addr *) &address->host);
-
-    if (addr == NULL) {
-        return -1;
-    } else {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, addr, addrLen + 1);
-    }
-    return 0;
-}
-
-int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-    struct in_addr in;
-    struct hostent *hostEntry;
-
-    in.s_addr = address->host;
-
-    hostEntry = gethostbyaddr((char *) &in, sizeof(struct in_addr), AF_INET);
-    if (hostEntry == NULL) {
-        return enet_address_get_host_ip(address, name, nameLength);
-    } else {
-        size_t hostLen = strlen(hostEntry->h_name);
-        if (hostLen >= nameLength) {
-            return -1;
-        }
-        memcpy(name, hostEntry->h_name, hostLen + 1);
-    }
-
-    return 0;
-}
-
-int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL) {
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    } else   {
-        sin.sin_port        = 0;
-        sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
-    return bind(socket,
-             (struct sockaddr *) &sin,
-             sizeof(struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
-}
-
-int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-    struct sockaddr_in sin;
-    int sinLength = sizeof(struct sockaddr_in);
-
-    if (getsockname(socket, (struct sockaddr *) &sin, &sinLength) == -1) {
-        return -1;
-    }
-
-    address->host = (enet_uint32) sin.sin_addr.s_addr;
-    address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-
-    return 0;
-}
-
-int enet_socket_listen(ENetSocket socket, int backlog) {
-    return listen(socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
-}
-
-ENetSocket enet_socket_create(ENetSocketType type) {
-    return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-}
-
-int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-    int result = SOCKET_ERROR;
-
-    switch (option) {
-        case ENET_SOCKOPT_NONBLOCK: {
-            u_long nonBlocking = (u_long) value;
-            result = ioctlsocket(socket, FIONBIO, &nonBlocking);
-            break;
-        }
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_REUSEADDR:
-            result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDBUF:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_RCVTIMEO:
-            result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_SNDTIMEO:
-            result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *) &value, sizeof(int));
-            break;
-
-        case ENET_SOCKOPT_NODELAY:
-            result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *) &value, sizeof(int));
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-} /* enet_socket_set_option */
-
-int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-    int result = SOCKET_ERROR, len;
-
-    switch (option) {
-        case ENET_SOCKOPT_ERROR:
-            len    = sizeof(int);
-            result = getsockopt(socket, SOL_SOCKET, SO_ERROR, (char *) value, &len);
-            break;
-
-        default:
-            break;
-    }
-    return result == SOCKET_ERROR ? -1 : 0;
-}
-
-int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-    struct sockaddr_in sin;
-    int result;
-
-    memset(&sin, 0, sizeof(struct sockaddr_in));
-
-    sin.sin_family      = AF_INET;
-    sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-    sin.sin_addr.s_addr = address->host;
-
-    result = connect(socket, (struct sockaddr *) &sin, sizeof(struct sockaddr_in));
-    if (result == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) {
-        return -1;
-    }
-
-    return 0;
-}
-
-ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-    SOCKET result;
-    struct sockaddr_in sin;
-    int sinLength = sizeof(struct sockaddr_in);
-
-    result = accept(socket,
-        address != NULL ? (struct sockaddr *) &sin : NULL,
-        address != NULL ? &sinLength : NULL);
-
-    if (result == INVALID_SOCKET) {
-        return ENET_SOCKET_NULL;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return result;
-}
-
-int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-    return shutdown(socket, (int) how) == SOCKET_ERROR ? -1 : 0;
-}
-
-void enet_socket_destroy(ENetSocket socket) {
-    if (socket != INVALID_SOCKET) {
-        closesocket(socket);
-    }
-}
-
-int enet_socket_send(ENetSocket socket,
-  const ENetAddress *           address,
-  const ENetBuffer *            buffers,
-  size_t                        bufferCount) {
-    struct sockaddr_in sin;
-    DWORD sentLength;
-
-    if (address != NULL) {
-        memset(&sin, 0, sizeof(struct sockaddr_in));
-
-        sin.sin_family      = AF_INET;
-        sin.sin_port        = ENET_HOST_TO_NET_16(address->port);
-        sin.sin_addr.s_addr = address->host;
-    }
-
-    if (WSASendTo(socket,
-      (LPWSABUF) buffers,
-      (DWORD) bufferCount,
-      &sentLength,
-      0,
-      address != NULL ? (struct sockaddr *) &sin : NULL,
-      address != NULL ? sizeof(struct sockaddr_in) : 0,
-      NULL,
-      NULL) == SOCKET_ERROR)
-    {
-        if (WSAGetLastError() == WSAEWOULDBLOCK) {
-            return 0;
-        }
-
-        return -1;
-    }
-
-    return (int) sentLength;
-}
-
-int enet_socket_receive(ENetSocket socket,
-  ENetAddress *                    address,
-  ENetBuffer *                     buffers,
-  size_t                           bufferCount) {
-    INT sinLength = sizeof(struct sockaddr_in);
-    DWORD flags   = 0,
-      recvLength;
-    struct sockaddr_in sin;
-
-    if (WSARecvFrom(socket,
-      (LPWSABUF) buffers,
-      (DWORD) bufferCount,
-      &recvLength,
-      &flags,
-      address != NULL ? (struct sockaddr *) &sin : NULL,
-      address != NULL ? &sinLength : NULL,
-      NULL,
-      NULL) == SOCKET_ERROR)
-    {
-        switch (WSAGetLastError()) {
-            case WSAEWOULDBLOCK:
-            case WSAECONNRESET:
-                return 0;
-        }
-
-        return -1;
-    }
-
-    if (flags & MSG_PARTIAL) {
-        return -1;
-    }
-
-    if (address != NULL) {
-        address->host = (enet_uint32) sin.sin_addr.s_addr;
-        address->port = ENET_NET_TO_HOST_16(sin.sin_port);
-    }
-
-    return (int) recvLength;
-} /* enet_socket_receive */
-
-int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-    struct timeval timeVal;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-}
-
-int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-    fd_set readSet, writeSet;
-    struct timeval timeVal;
-    int selectCount;
-
-    timeVal.tv_sec  = timeout / 1000;
-    timeVal.tv_usec = (timeout % 1000) * 1000;
-
-    FD_ZERO(&readSet);
-    FD_ZERO(&writeSet);
-
-    if (*condition & ENET_SOCKET_WAIT_SEND) {
-        FD_SET(socket, &writeSet);
-    }
-
-    if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-        FD_SET(socket, &readSet);
-    }
-
-    selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
-
-    if (selectCount < 0) {
-        return -1;
-    }
-
-    *condition = ENET_SOCKET_WAIT_NONE;
-
-    if (selectCount == 0) {
-        return 0;
-    }
-
-    if (FD_ISSET(socket, &writeSet)) {
-        *condition |= ENET_SOCKET_WAIT_SEND;
-    }
-
-    if (FD_ISSET(socket, &readSet)) {
-        *condition |= ENET_SOCKET_WAIT_RECEIVE;
-    }
-
-    return 0;
-} /* enet_socket_wait */
-
-#endif /* ifdef _WIN32 */