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