Browse Source

integration of enet on the server side, streams and data vectors removed
- read moved to packet, write outstanding, string improvements, command
editor is a global console reader with less string copies, replaced
headers in types with own types and static asserts

Kajetan Johannes Hammerle 2 years ago
parent
commit
c069080130

+ 5920 - 0
common/enet/enet.h

@@ -0,0 +1,5920 @@
+/**
+ * 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>
+ *
+ * License:
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2002-2016 Lee Salzman
+ * Copyright (c) 2017-2018 Vladyslav Hrytsenko, Dominik Madarász
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+#ifndef ENET_INCLUDE_H
+#define ENET_INCLUDE_H
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
+
+#define ENET_VERSION_MAJOR 2
+#define ENET_VERSION_MINOR 2
+#define ENET_VERSION_PATCH 0
+#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)
+
+#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))
+
+// =======================================================================//
+// !
+// ! System differences
+// !
+// =======================================================================//
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && defined(ENET_IMPLEMENTATION)
+        #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
+
+    #ifndef ENET_NO_PRAGMA_LINK
+    #pragma comment(lib, "ws2_32.lib")
+    #pragma comment(lib, "winmm.lib")
+    #endif
+
+    #if _MSC_VER >= 1910
+    /* It looks like there were changes as of Visual Studio 2017 and there are no 32/64 bit
+       versions of _InterlockedExchange[operation], only InterlockedExchange[operation]
+       (without leading underscore), so we have to distinguish between compiler versions */
+    #define NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+    #endif
+
+    #ifdef __GNUC__
+    #if (_WIN32_WINNT < 0x0501)
+    #undef _WIN32_WINNT
+    #define _WIN32_WINNT 0x0501
+    #endif
+    #endif
+
+    #include <winsock2.h>
+    #include <ws2tcpip.h>
+    #include <mmsystem.h>
+
+    #include <intrin.h>
+
+    #if defined(_WIN32) && defined(_MSC_VER)
+    #if _MSC_VER < 1900
+    typedef struct timespec {
+        long tv_sec;
+        long tv_nsec;
+    };
+    #endif
+    #define CLOCK_MONOTONIC 0
+    #endif
+
+    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_IMPLEMENTATION
+    #define ENET_API __declspec( dllexport )
+    #else
+    #define ENET_API __declspec( dllimport )
+    #endif // ENET_IMPLEMENTATION
+    #else
+    #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))
+#else
+    #include <sys/types.h>
+    #include <sys/ioctl.h>
+    #include <sys/time.h>
+    #include <sys/socket.h>
+    #include <poll.h>
+    #include <arpa/inet.h>
+    #include <netinet/in.h>
+    #include <netinet/tcp.h>
+    #include <netdb.h>
+    #include <unistd.h>
+    #include <string.h>
+    #include <errno.h>
+    #include <fcntl.h>
+
+    #ifdef __APPLE__
+    #include <mach/clock.h>
+    #include <mach/mach.h>
+    #include <Availability.h>
+    #endif
+
+    #ifndef MSG_NOSIGNAL
+    #define MSG_NOSIGNAL 0
+    #endif
+
+    #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
+
+#ifndef ENET_BUFFER_MAXIMUM
+#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
+#endif
+
+#define ENET_UNUSED(x) (void)x;
+
+#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
+#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+#define ENET_IPV6           1
+#define ENET_HOST_ANY       in6addr_any
+#define ENET_HOST_BROADCAST 0xFFFFFFFFU
+#define ENET_PORT_ANY       0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =======================================================================//
+// !
+// ! Basic stuff
+// !
+// =======================================================================//
+
+    typedef uint8_t   enet_uint8;   /**< unsigned 8-bit type  */
+    typedef uint16_t enet_uint16;   /**< unsigned 16-bit type */
+    typedef uint32_t enet_uint32;   /**< unsigned 32-bit type */
+    typedef uint64_t enet_uint64;   /**< unsigned 64-bit type */
+
+    typedef enet_uint32 ENetVersion;
+
+    typedef struct _ENetCallbacks {
+        void *(ENET_CALLBACK *malloc) (size_t size);
+        void (ENET_CALLBACK *free) (void *memory);
+        void (ENET_CALLBACK *no_memory) (void);
+    } ENetCallbacks;
+
+    extern void *enet_malloc(size_t);
+    extern void enet_free(void *);
+
+// =======================================================================//
+// !
+// ! List
+// !
+// =======================================================================//
+
+    typedef struct _ENetListNode {
+        struct _ENetListNode *next;
+        struct _ENetListNode *previous;
+    } ENetListNode;
+
+    typedef ENetListNode *ENetListIterator;
+
+    typedef struct _ENetList {
+        ENetListNode sentinel;
+    } ENetList;
+
+    extern ENetListIterator enet_list_insert(ENetListIterator, void *);
+    extern ENetListIterator enet_list_move(ENetListIterator, void *, void *);
+
+    extern void *enet_list_remove(ENetListIterator);
+    extern void enet_list_clear(ENetList *);
+    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)
+
+
+// =======================================================================//
+// !
+// ! Protocol
+// !
+// =======================================================================//
+
+    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
+
+// =======================================================================//
+// !
+// ! General ENet structs/enums
+// !
+// =======================================================================//
+
+    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,
+        ENET_SOCKOPT_IPV6_V6ONLY = 10,
+    } ENetSocketOption;
+
+    typedef enum _ENetSocketShutdown {
+        ENET_SOCKET_SHUTDOWN_READ       = 0,
+        ENET_SOCKET_SHUTDOWN_WRITE      = 1,
+        ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
+    } ENetSocketShutdown;
+
+    /**
+     * 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 {
+        struct in6_addr host;
+        enet_uint16 port;
+        enet_uint16 sin6_scope_id;
+    } ENetAddress;
+
+    #define in6_equal(in6_addr_a, in6_addr_b) (memcmp(&in6_addr_a, &in6_addr_b, sizeof(struct in6_addr)) == 0)
+
+    /**
+     * 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 {
+        ENET_PACKET_FLAG_RELIABLE            = (1 << 0), /** packet must be received by the target peer and resend attempts should be made until the packet is delivered */
+        ENET_PACKET_FLAG_UNSEQUENCED         = (1 << 1), /** packet will not be sequenced with other packets not supported for reliable packets */
+        ENET_PACKET_FLAG_NO_ALLOCATE         = (1 << 2), /** packet will not allocate data, and user must supply it instead */
+        ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3), /** packet will be fragmented using unreliable (instead of reliable) sends if it exceeds the MTU */
+        ENET_PACKET_FLAG_SENT                = (1 << 8), /** whether the packet has been sent from all queues it has been entered into */
+    } ENetPacketFlag;
+
+    typedef void (ENET_CALLBACK *ENetPacketFreeCallback)(void *);
+
+    /**
+     * 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;
+
+    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_uint64       totalDataReceived;
+        enet_uint32       outgoingDataTotal;
+        enet_uint64       totalDataSent;
+        enet_uint32       lastSendTime;
+        enet_uint32       lastReceiveTime;
+        enet_uint32       nextTimeout;
+        enet_uint32       earliestTimeout;
+        enet_uint32       packetLossEpoch;
+        enet_uint32       packetsSent;
+        enet_uint64       totalPacketsSent; /**< total number of packets sent during a session */
+        enet_uint32       packetsLost;
+        enet_uint32       totalPacketsLost;     /**< total number of packets lost during a session */
+        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, void *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_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.  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,
+
+        /** a peer is disconnected because the host didn't receive the acknowledgment
+         * packet within certain maximum time out. The reason could be because of bad
+         * network connection or  host crashed.
+         */
+        ENET_EVENT_TYPE_DISCONNECT_TIMEOUT = 4,
+    } 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;
+
+// =======================================================================//
+// !
+// ! Public API
+// !
+// =======================================================================//
+
+    /**
+     * 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);
+
+    /** Returns the monotonic time in milliseconds. Its initial value is unspecified unless otherwise set. */
+    ENET_API enet_uint32 enet_time_get(void);
+
+    /** 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);
+
+    /** 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 enet_uint32 enet_host_get_peers_count(ENetHost *);
+    ENET_API enet_uint32 enet_host_get_packets_sent(ENetHost *);
+    ENET_API enet_uint32 enet_host_get_packets_received(ENetHost *);
+    ENET_API enet_uint32 enet_host_get_bytes_sent(ENetHost *);
+    ENET_API enet_uint32 enet_host_get_bytes_received(ENetHost *);
+    ENET_API enet_uint32 enet_host_get_received_data(ENetHost *, enet_uint8** data);
+    ENET_API enet_uint32 enet_host_get_mtu(ENetHost *);
+
+    ENET_API enet_uint32 enet_peer_get_id(ENetPeer *);
+    ENET_API enet_uint32 enet_peer_get_ip(ENetPeer *, char * ip, size_t ipLength);
+    ENET_API enet_uint16 enet_peer_get_port(ENetPeer *);
+    ENET_API enet_uint32 enet_peer_get_rtt(ENetPeer *);
+    ENET_API enet_uint64 enet_peer_get_packets_sent(ENetPeer *);
+    ENET_API enet_uint32 enet_peer_get_packets_lost(ENetPeer *);
+    ENET_API enet_uint64 enet_peer_get_bytes_sent(ENetPeer *);
+    ENET_API enet_uint64 enet_peer_get_bytes_received(ENetPeer *);
+
+    ENET_API ENetPeerState enet_peer_get_state(ENetPeer *);
+
+    ENET_API void * enet_peer_get_data(ENetPeer *);
+    ENET_API void   enet_peer_set_data(ENetPeer *, const void *);
+
+    ENET_API void *      enet_packet_get_data(ENetPacket *);
+    ENET_API enet_uint32 enet_packet_get_length(ENetPacket *);
+    ENET_API void        enet_packet_set_free_callback(ENetPacket *, ENetPacketFreeCallback);
+
+    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 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 int        enet_host_send_raw(ENetHost *, const ENetAddress *, enet_uint8 *, size_t);
+    ENET_API int        enet_host_send_raw_ex(ENetHost *host, const ENetAddress* address, enet_uint8* data, size_t skipBytes, size_t bytesToSend);
+    ENET_API void       enet_host_set_intercept(ENetHost *, const ENetInterceptCallback);
+    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 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 *);
+
+    extern size_t enet_protocol_command_size (enet_uint8);
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(ENET_IMPLEMENTATION) && !defined(ENET_IMPLEMENTATION_DONE)
+#define ENET_IMPLEMENTATION_DONE 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =======================================================================//
+// !
+// ! Atomics
+// !
+// =======================================================================//
+
+#if defined(_MSC_VER)
+
+    #define ENET_AT_CASSERT_PRED(predicate) sizeof(char[2 * !!(predicate)-1])
+    #define ENET_IS_SUPPORTED_ATOMIC(size) ENET_AT_CASSERT_PRED(size == 1 || size == 2 || size == 4 || size == 8)
+    #define ENET_ATOMIC_SIZEOF(variable) (ENET_IS_SUPPORTED_ATOMIC(sizeof(*(variable))), sizeof(*(variable)))
+
+    __inline int64_t enet_at_atomic_read(char *ptr, size_t size)
+    {
+        switch (size) {
+            case 1:
+                return _InterlockedExchangeAdd8((volatile char *)ptr, 0);
+            case 2:
+                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, 0);
+            case 4:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchangeAdd((volatile LONG *)ptr, 0);
+    #else
+                return _InterlockedExchangeAdd((volatile LONG *)ptr, 0);
+    #endif
+            case 8:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
+    #else
+                return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
+    #endif
+            default:
+                return 0xbad13bad; /* never reached */
+        }
+    }
+
+    __inline int64_t enet_at_atomic_write(char *ptr, int64_t value, size_t size)
+    {
+        switch (size) {
+            case 1:
+                return _InterlockedExchange8((volatile char *)ptr, (char)value);
+            case 2:
+                return _InterlockedExchange16((volatile SHORT *)ptr, (SHORT)value);
+            case 4:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchange((volatile LONG *)ptr, (LONG)value);
+    #else
+                return _InterlockedExchange((volatile LONG *)ptr, (LONG)value);
+    #endif
+            case 8:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
+    #else
+                return _InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
+    #endif
+            default:
+                return 0xbad13bad; /* never reached */
+        }
+    }
+
+    __inline int64_t enet_at_atomic_cas(char *ptr, int64_t new_val, int64_t old_val, size_t size)
+    {
+        switch (size) {
+            case 1:
+                return _InterlockedCompareExchange8((volatile char *)ptr, (char)new_val, (char)old_val);
+            case 2:
+                return _InterlockedCompareExchange16((volatile SHORT *)ptr, (SHORT)new_val,
+                                                     (SHORT)old_val);
+            case 4:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
+    #else
+                return _InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
+    #endif
+            case 8:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val,
+                                                    (LONGLONG)old_val);
+    #else
+                return _InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val,
+                                                     (LONGLONG)old_val);
+    #endif
+            default:
+                return 0xbad13bad; /* never reached */
+        }
+    }
+
+    __inline int64_t enet_at_atomic_inc(char *ptr, int64_t delta, size_t data_size)
+    {
+        switch (data_size) {
+            case 1:
+                return _InterlockedExchangeAdd8((volatile char *)ptr, (char)delta);
+            case 2:
+                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, (SHORT)delta);
+            case 4:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
+    #else
+                return _InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
+    #endif
+            case 8:
+    #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
+    #else
+                return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
+    #endif
+            default:
+                return 0xbad13bad; /* never reached */
+        }
+    }
+
+    #define ENET_ATOMIC_READ(variable) enet_at_atomic_read((char *)(variable), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_WRITE(variable, new_val)                                                            \
+        enet_at_atomic_write((char *)(variable), (int64_t)(new_val), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                   \
+        enet_at_atomic_cas((char *)(variable), (int64_t)(new_val), (int64_t)(old_value),                    \
+                      ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_INC(variable) enet_at_atomic_inc((char *)(variable), 1, ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_DEC(variable) enet_at_atomic_inc((char *)(variable), -1, ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_INC_BY(variable, delta)                                                             \
+        enet_at_atomic_inc((char *)(variable), (delta), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_DEC_BY(variable, delta)                                                             \
+        enet_at_atomic_inc((char *)(variable), -(delta), ENET_ATOMIC_SIZEOF(variable))
+
+#elif defined(__GNUC__) || defined(__clang__)
+
+    #if defined(__clang__) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
+    #define AT_HAVE_ATOMICS
+    #endif
+
+    /* We want to use __atomic built-ins if possible because the __sync primitives are
+       deprecated, because the __atomic build-ins allow us to use ENET_ATOMIC_WRITE on
+       uninitialized memory without running into undefined behavior, and because the
+       __atomic versions generate more efficient code since we don't need to rely on
+       CAS when we don't actually want it.
+       Note that we use acquire-release memory order (like mutexes do). We could use
+       sequentially consistent memory order but that has lower performance and is
+       almost always unneeded. */
+    #ifdef AT_HAVE_ATOMICS
+        #define ENET_ATOMIC_READ(ptr) __atomic_load_n((ptr), __ATOMIC_ACQUIRE)
+        #define ENET_ATOMIC_WRITE(ptr, value) __atomic_store_n((ptr), (value), __ATOMIC_RELEASE)
+
+        #ifndef typeof
+        #define typeof __typeof__
+        #endif
+
+        /* clang_analyzer doesn't know that CAS writes to memory so it complains about
+           potentially lost data. Replace the code with the equivalent non-sync code. */
+        #ifdef __clang_analyzer__
+
+        #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
+            ({                                                                                             \
+                typeof(*(ptr)) ENET_ATOMIC_CAS_old_actual_ = (*(ptr));                                          \
+                if (ATOMIC_CAS_old_actual_ == (old_value)) {                                               \
+                    *(ptr) = new_value;                                                                    \
+                }                                                                                          \
+                ENET_ATOMIC_CAS_old_actual_;                                                                    \
+            })
+
+        #else
+
+        /* Could use __auto_type instead of typeof but that shouldn't work in C++.
+           The ({ }) syntax is a GCC extension called statement expression. It lets
+           us return a value out of the macro.
+           TODO We should return bool here instead of the old value to avoid the ABA
+           problem. */
+        #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
+            ({                                                                                             \
+                typeof(*(ptr)) ENET_ATOMIC_CAS_expected_ = (old_value);                                         \
+                __atomic_compare_exchange_n((ptr), &ENET_ATOMIC_CAS_expected_, (new_value), false,              \
+                                            __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE);                           \
+                ENET_ATOMIC_CAS_expected_;                                                                      \
+            })
+
+        #endif /* __clang_analyzer__ */
+
+        #define ENET_ATOMIC_INC(ptr) __atomic_fetch_add((ptr), 1, __ATOMIC_ACQ_REL)
+        #define ENET_ATOMIC_DEC(ptr) __atomic_fetch_sub((ptr), 1, __ATOMIC_ACQ_REL)
+        #define ENET_ATOMIC_INC_BY(ptr, delta) __atomic_fetch_add((ptr), (delta), __ATOMIC_ACQ_REL)
+        #define ENET_ATOMIC_DEC_BY(ptr, delta) __atomic_fetch_sub((ptr), (delta), __ATOMIC_ACQ_REL)
+
+        #else
+
+        #define ENET_ATOMIC_READ(variable) __sync_fetch_and_add(variable, 0)
+        #define ENET_ATOMIC_WRITE(variable, new_val)                                                            \
+            (void) __sync_val_compare_and_swap((variable), *(variable), (new_val))
+        #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                   \
+            __sync_val_compare_and_swap((variable), (old_value), (new_val))
+        #define ENET_ATOMIC_INC(variable) __sync_fetch_and_add((variable), 1)
+        #define ENET_ATOMIC_DEC(variable) __sync_fetch_and_sub((variable), 1)
+        #define ENET_ATOMIC_INC_BY(variable, delta) __sync_fetch_and_add((variable), (delta), 1)
+        #define ENET_ATOMIC_DEC_BY(variable, delta) __sync_fetch_and_sub((variable), (delta), 1)
+
+    #endif /* AT_HAVE_ATOMICS */
+
+    #undef AT_HAVE_ATOMICS
+
+#endif /* defined(_MSC_VER) */
+
+
+// =======================================================================//
+// !
+// ! Callbacks
+// !
+// =======================================================================//
+
+    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);
+    }
+
+// =======================================================================//
+// !
+// ! List
+// !
+// =======================================================================//
+
+    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;
+        ENetListIterator 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;
+    }
+
+// =======================================================================//
+// !
+// ! Packet
+// !
+// =======================================================================//
+
+    /**
+     * 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;
+        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
+            packet = (ENetPacket *)enet_malloc(sizeof (ENetPacket));
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)data;
+        }
+        else {
+            packet = (ENetPacket *)enet_malloc(sizeof (ENetPacket) + dataLength);
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
+
+            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;
+        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
+            packet = (ENetPacket *)enet_malloc(sizeof (ENetPacket));
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)data;
+        }
+        else {
+            packet = (ENetPacket *)enet_malloc(sizeof (ENetPacket) + dataLength + dataOffset);
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
+
+            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)((void *)packet);
+        }
+
+        enet_free(packet);
+    }
+
+    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;
+            const enet_uint8 *dataEnd = &data[buffers->dataLength];
+
+            while (data < dataEnd) {
+                crc = (crc >> 8) ^ crcTable[(crc & 0xFF) ^ *data++];
+            }
+
+            ++buffers;
+        }
+
+        return ENET_HOST_TO_NET_32(~crc);
+    }
+
+// =======================================================================//
+// !
+// ! Protocol
+// !
+// =======================================================================//
+
+    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) {
+        ENET_UNUSED(host)
+
+        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);
+
+            peer->totalDataSent     = 0;
+            peer->totalDataReceived = 0;
+            peer->totalPacketsSent  = 0;
+            peer->totalPacketsLost  = 0;
+
+            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_notify_disconnect_timeout (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_TIMEOUT;
+            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_UNUSED(header)
+
+        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 && in6_equal(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) {
+        ENET_UNUSED(host)
+        ENET_UNUSED(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) {
+        ENET_UNUSED(host)
+
+        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 ||
+                ((!in6_equal(host->receivedAddress.host , peer->address.host) ||
+                host->receivedAddress.port != peer->address.port) &&
+                1 /* no broadcast in ipv6  !in6_equal(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)];
+            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;
+            peer->totalDataReceived += 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 || currentData < &host->receivedData[host->receivedDataLength])) {
+                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]);
+            buffer.dataLength = host->mtu;
+
+            receivedLength    = enet_socket_receive(host->socket, &host->receivedAddress, &buffer, 1);
+
+            if (receivedLength == -2)
+                continue;
+
+            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, (void *)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;
+                    enet_uint16 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;
+            }