diff --git a/polymer/eduke32/source/enet/Makefile b/polymer/eduke32/source/enet/Makefile index e7558d5b7..9ccd486b9 100644 --- a/polymer/eduke32/source/enet/Makefile +++ b/polymer/eduke32/source/enet/Makefile @@ -25,7 +25,7 @@ CFLAGS=$(debug) -W -Wall -Wimplicit -Werror-implicit-function-declaration \ -funsigned-char -fno-strict-aliasing -DNO_GCC_BUILTINS -D_FORTIFY_SOURCE=2 \ -fjump-tables -fno-stack-protector -CPPFLAGS=-Iinclude -Isrc -DHAVE_VORBIS +CPPFLAGS=-Iinclude -Isrc OBJECTS=$(OBJ)/callbacks.o \ $(OBJ)/host.o \ diff --git a/polymer/eduke32/source/enet/Makefile.msvc b/polymer/eduke32/source/enet/Makefile.msvc index 9de19bd0a..21f71c905 100644 --- a/polymer/eduke32/source/enet/Makefile.msvc +++ b/polymer/eduke32/source/enet/Makefile.msvc @@ -23,7 +23,7 @@ CFLAGS=$(CFLAGS) /nologo /MT /J $(flags_cl) $(TARGETOPTS) /I$(INC) /I$(SRC) CFLAGS=$(CFLAGS) /DDEBUGGINGAIDS !endif -CFLAGS=$(CFLAGS) /DRENDERTYPE$(RENDERTYPE)=1 /D "_CRT_SECURE_NO_DEPRECATE" /W2 /DHAVE_VORBIS /Iinclude/msvc /DWIN32 +CFLAGS=$(CFLAGS) /DRENDERTYPE$(RENDERTYPE)=1 /D "_CRT_SECURE_NO_DEPRECATE" /W2 /Iinclude/msvc /DWIN32 OBJECTS=$(OBJ)\callbacks.o \ $(OBJ)\host.o \ diff --git a/polymer/eduke32/source/enet/include/enet/callbacks.h b/polymer/eduke32/source/enet/include/enet/callbacks.h index 0b9e6939e..b488ac724 100644 --- a/polymer/eduke32/source/enet/include/enet/callbacks.h +++ b/polymer/eduke32/source/enet/include/enet/callbacks.h @@ -12,6 +12,7 @@ typedef struct _ENetCallbacks void * (ENET_CALLBACK * malloc) (size_t size); void (ENET_CALLBACK * free) (void * memory); int (ENET_CALLBACK * rand) (void); + void (ENET_CALLBACK * no_memory) (void); } ENetCallbacks; /** @defgroup callbacks ENet internal callbacks diff --git a/polymer/eduke32/source/enet/include/enet/enet.h b/polymer/eduke32/source/enet/include/enet/enet.h index dca564c3d..7d4ac3345 100644 --- a/polymer/eduke32/source/enet/include/enet/enet.h +++ b/polymer/eduke32/source/enet/include/enet/enet.h @@ -23,10 +23,13 @@ extern "C" #include "enet/list.h" #include "enet/callbacks.h" -typedef enum _ENetVersion -{ - ENET_VERSION = 1 -} ENetVersion; +#define ENET_VERSION_MAJOR 1 +#define ENET_VERSION_MINOR 2 +#define ENET_VERSION_PATCH 2 +#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch)) +#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH) + +typedef enet_uint32 ENetVersion; typedef enum _ENetSocketType { @@ -226,6 +229,7 @@ typedef struct _ENetChannel */ typedef struct _ENetPeer { + ENetListNode dispatchList; struct _ENetHost * host; enet_uint16 outgoingPeerID; enet_uint16 incomingPeerID; @@ -272,6 +276,8 @@ typedef struct _ENetPeer 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]; @@ -288,6 +294,7 @@ typedef struct _ENetPeer @sa enet_host_service() @sa enet_host_flush() @sa enet_host_broadcast() + @sa enet_host_channel_limit() @sa enet_host_bandwidth_limit() @sa enet_host_bandwidth_throttle() */ @@ -302,8 +309,9 @@ typedef struct _ENetHost 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; - ENetPeer * lastServicedPeer; + ENetList dispatchQueue; int continueSending; size_t packetSize; enet_uint16 headerFlags; @@ -314,6 +322,10 @@ typedef struct _ENetHost ENetAddress receivedAddress; enet_uint8 receivedData [ENET_PROTOCOL_MAXIMUM_MTU]; 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 */ } ENetHost; /** @@ -373,7 +385,7 @@ typedef struct _ENetEvent 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. + 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-overriden callbacks where any NULL callbacks will use ENet's defaults @@ -465,11 +477,12 @@ 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_channel_limit (ENetHost *, size_t); ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32); extern void enet_host_bandwidth_throttle (ENetHost *); ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *); -ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8); +ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID); ENET_API void enet_peer_ping (ENetPeer *); ENET_API void enet_peer_reset (ENetPeer *); ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32); @@ -478,6 +491,7 @@ 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 *, ENetPacket *, enet_uint32); extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16); diff --git a/polymer/eduke32/source/enet/include/enet/list.h b/polymer/eduke32/source/enet/include/enet/list.h index 99bc4aeee..d7b260084 100644 --- a/polymer/eduke32/source/enet/include/enet/list.h +++ b/polymer/eduke32/source/enet/include/enet/list.h @@ -24,6 +24,7 @@ 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 *); diff --git a/polymer/eduke32/source/enet/include/enet/protocol.h b/polymer/eduke32/source/enet/include/enet/protocol.h index 363857bcc..4e61cad38 100644 --- a/polymer/eduke32/source/enet/include/enet/protocol.h +++ b/polymer/eduke32/source/enet/include/enet/protocol.h @@ -19,7 +19,7 @@ enum ENET_PROTOCOL_MAXIMUM_PEER_ID = 0x7FFF }; -typedef enum +typedef enum _ENetProtocolCommand { ENET_PROTOCOL_COMMAND_NONE = 0, ENET_PROTOCOL_COMMAND_ACKNOWLEDGE = 1, @@ -38,7 +38,7 @@ typedef enum ENET_PROTOCOL_COMMAND_MASK = 0x0F } ENetProtocolCommand; -typedef enum +typedef enum _ENetProtocolFlag { ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7), ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6), @@ -47,28 +47,37 @@ typedef enum ENET_PROTOCOL_HEADER_FLAG_MASK = 0x8000 } ENetProtocolFlag; -typedef struct +#ifdef _MSC_VER_ +#pragma pack(push, 1) +#define ENET_PACKED +#elif defined(__GNUC__) +#define ENET_PACKED __attribute__ ((packed)) +#else +#define ENET_PACKED +#endif + +typedef struct _ENetProtocolHeader { enet_uint32 checksum; enet_uint16 peerID; enet_uint16 sentTime; -} ENetProtocolHeader; +} ENET_PACKED ENetProtocolHeader; -typedef struct +typedef struct _ENetProtocolCommandHeader { enet_uint8 command; enet_uint8 channelID; enet_uint16 reliableSequenceNumber; -} ENetProtocolCommandHeader; +} ENET_PACKED ENetProtocolCommandHeader; -typedef struct +typedef struct _ENetProtocolAcknowledge { ENetProtocolCommandHeader header; enet_uint16 receivedReliableSequenceNumber; enet_uint16 receivedSentTime; -} ENetProtocolAcknowledge; +} ENET_PACKED ENetProtocolAcknowledge; -typedef struct +typedef struct _ENetProtocolConnect { ENetProtocolCommandHeader header; enet_uint16 outgoingPeerID; @@ -81,9 +90,9 @@ typedef struct enet_uint32 packetThrottleAcceleration; enet_uint32 packetThrottleDeceleration; enet_uint32 sessionID; -} ENetProtocolConnect; +} ENET_PACKED ENetProtocolConnect; -typedef struct +typedef struct _ENetProtocolVerifyConnect { ENetProtocolCommandHeader header; enet_uint16 outgoingPeerID; @@ -95,55 +104,55 @@ typedef struct enet_uint32 packetThrottleInterval; enet_uint32 packetThrottleAcceleration; enet_uint32 packetThrottleDeceleration; -} ENetProtocolVerifyConnect; +} ENET_PACKED ENetProtocolVerifyConnect; -typedef struct +typedef struct _ENetProtocolBandwidthLimit { ENetProtocolCommandHeader header; enet_uint32 incomingBandwidth; enet_uint32 outgoingBandwidth; -} ENetProtocolBandwidthLimit; +} ENET_PACKED ENetProtocolBandwidthLimit; -typedef struct +typedef struct _ENetProtocolThrottleConfigure { ENetProtocolCommandHeader header; enet_uint32 packetThrottleInterval; enet_uint32 packetThrottleAcceleration; enet_uint32 packetThrottleDeceleration; -} ENetProtocolThrottleConfigure; +} ENET_PACKED ENetProtocolThrottleConfigure; -typedef struct +typedef struct _ENetProtocolDisconnect { ENetProtocolCommandHeader header; enet_uint32 data; -} ENetProtocolDisconnect; +} ENET_PACKED ENetProtocolDisconnect; -typedef struct +typedef struct _ENetProtocolPing { ENetProtocolCommandHeader header; -} ENetProtocolPing; +} ENET_PACKED ENetProtocolPing; -typedef struct +typedef struct _ENetProtocolSendReliable { ENetProtocolCommandHeader header; enet_uint16 dataLength; -} ENetProtocolSendReliable; +} ENET_PACKED ENetProtocolSendReliable; -typedef struct +typedef struct _ENetProtocolSendUnreliable { ENetProtocolCommandHeader header; enet_uint16 unreliableSequenceNumber; enet_uint16 dataLength; -} ENetProtocolSendUnreliable; +} ENET_PACKED ENetProtocolSendUnreliable; -typedef struct +typedef struct _ENetProtocolSendUnsequenced { ENetProtocolCommandHeader header; enet_uint16 unsequencedGroup; enet_uint16 dataLength; -} ENetProtocolSendUnsequenced; +} ENET_PACKED ENetProtocolSendUnsequenced; -typedef struct +typedef struct _ENetProtocolSendFragment { ENetProtocolCommandHeader header; enet_uint16 startSequenceNumber; @@ -152,9 +161,9 @@ typedef struct enet_uint32 fragmentNumber; enet_uint32 totalLength; enet_uint32 fragmentOffset; -} ENetProtocolSendFragment; +} ENET_PACKED ENetProtocolSendFragment; -typedef union +typedef union _ENetProtocol { ENetProtocolCommandHeader header; ENetProtocolAcknowledge acknowledge; @@ -168,7 +177,11 @@ typedef union ENetProtocolSendFragment sendFragment; ENetProtocolBandwidthLimit bandwidthLimit; ENetProtocolThrottleConfigure throttleConfigure; -} ENetProtocol; +} ENET_PACKED ENetProtocol; + +#ifdef _MSC_VER_ +#pragma pack(pop) +#endif #endif /* __ENET_PROTOCOL_H__ */ diff --git a/polymer/eduke32/source/enet/include/enet/win32.h b/polymer/eduke32/source/enet/include/enet/win32.h index 7d34953ae..0e1cf0c5a 100644 --- a/polymer/eduke32/source/enet/include/enet/win32.h +++ b/polymer/eduke32/source/enet/include/enet/win32.h @@ -5,14 +5,12 @@ #ifndef __ENET_WIN32_H__ #define __ENET_WIN32_H__ -#ifdef _MSC_VER #ifdef ENET_BUILDING_LIB #pragma warning (disable: 4996) // 'strncpy' was declared deprecated #pragma warning (disable: 4267) // size_t to int conversion #pragma warning (disable: 4244) // 64bit to 32bit int #pragma warning (disable: 4018) // signed/unsigned mismatch #endif -#endif #include #include diff --git a/polymer/eduke32/source/enet/src/callbacks.c b/polymer/eduke32/source/enet/src/callbacks.c index 7f960af3f..250b9670d 100644 --- a/polymer/eduke32/source/enet/src/callbacks.c +++ b/polymer/eduke32/source/enet/src/callbacks.c @@ -5,14 +5,11 @@ #define ENET_BUILDING_LIB 1 #include "enet/enet.h" -static ENetCallbacks callbacks = { malloc, free, rand }; +static ENetCallbacks callbacks = { malloc, free, rand, abort }; int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits) { - if (version != ENET_VERSION) - return -1; - if (inits -> malloc != NULL || inits -> free != NULL) { if (inits -> malloc == NULL || inits -> free == NULL) @@ -25,6 +22,12 @@ enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits if (inits -> rand != NULL) callbacks.rand = inits -> rand; + if (version >= ENET_VERSION_CREATE(1, 2, 2)) + { + if (inits -> no_memory != NULL) + callbacks.no_memory = inits -> no_memory; + } + return enet_initialize (); } @@ -34,7 +37,7 @@ enet_malloc (size_t size) void * memory = callbacks.malloc (size); if (memory == NULL) - abort (); + callbacks.no_memory (); return memory; } diff --git a/polymer/eduke32/source/enet/src/host.c b/polymer/eduke32/source/enet/src/host.c index 30eaded90..67accd93f 100644 --- a/polymer/eduke32/source/enet/src/host.c +++ b/polymer/eduke32/source/enet/src/host.c @@ -27,13 +27,23 @@ ENetHost * enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) { - ENetHost * host = (ENetHost *) enet_malloc (sizeof (ENetHost)); + ENetHost * host; ENetPeer * currentPeer; if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID) return NULL; + host = (ENetHost *) enet_malloc (sizeof (ENetHost)); + if (host == NULL) + return NULL; + 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); @@ -56,19 +66,26 @@ enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 inc if (address != NULL) host -> address = * address; + host -> channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT; host -> incomingBandwidth = incomingBandwidth; host -> outgoingBandwidth = outgoingBandwidth; host -> bandwidthThrottleEpoch = 0; host -> recalculateBandwidthLimits = 0; host -> mtu = ENET_HOST_DEFAULT_MTU; host -> peerCount = peerCount; - host -> lastServicedPeer = host -> peers; host -> commandCount = 0; host -> bufferCount = 0; host -> receivedAddress.host = ENET_HOST_ANY; host -> receivedAddress.port = 0; host -> receivedDataLength = 0; + host -> totalSentData = 0; + host -> totalSentPackets = 0; + host -> totalReceivedData = 0; + host -> totalReceivedPackets = 0; + + enet_list_clear (& host -> dispatchQueue); + for (currentPeer = host -> peers; currentPeer < & host -> peers [host -> peerCount]; ++ currentPeer) @@ -82,6 +99,7 @@ enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 inc enet_list_clear (& currentPeer -> sentUnreliableCommands); enet_list_clear (& currentPeer -> outgoingReliableCommands); enet_list_clear (& currentPeer -> outgoingUnreliableCommands); + enet_list_clear (& currentPeer -> dispatchedCommands); enet_peer_reset (currentPeer); } @@ -142,10 +160,12 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC 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 -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); - currentPeer -> channelCount = channelCount; currentPeer -> sessionID = (enet_uint32) enet_rand (); if (host -> outgoingBandwidth == 0) @@ -194,6 +214,22 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC return currentPeer; } +/** 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; +} + /** 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 diff --git a/polymer/eduke32/source/enet/src/list.c b/polymer/eduke32/source/enet/src/list.c index 1a4aa3ae7..8487200ff 100644 --- a/polymer/eduke32/source/enet/src/list.c +++ b/polymer/eduke32/source/enet/src/list.c @@ -40,6 +40,24 @@ enet_list_remove (ENetListIterator position) 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) { diff --git a/polymer/eduke32/source/enet/src/packet.c b/polymer/eduke32/source/enet/src/packet.c index 7f18e49eb..2fc9a10e8 100644 --- a/polymer/eduke32/source/enet/src/packet.c +++ b/polymer/eduke32/source/enet/src/packet.c @@ -20,6 +20,8 @@ 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; diff --git a/polymer/eduke32/source/enet/src/peer.c b/polymer/eduke32/source/enet/src/peer.c index 52e34a51f..395a90274 100644 --- a/polymer/eduke32/source/enet/src/peer.c +++ b/polymer/eduke32/source/enet/src/peer.c @@ -115,9 +115,10 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) enet_uint32 fragmentCount = ENET_HOST_TO_NET_32 ((packet -> dataLength + fragmentLength - 1) / fragmentLength), fragmentNumber, fragmentOffset; + ENetList fragments; + ENetOutgoingCommand * fragment; - packet -> flags |= ENET_PACKET_FLAG_RELIABLE; - packet -> flags &= ~ENET_PACKET_FLAG_UNSEQUENCED; + enet_list_clear (& fragments); for (fragmentNumber = 0, fragmentOffset = 0; @@ -128,16 +129,41 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) if (packet -> dataLength - fragmentOffset < fragmentLength) fragmentLength = packet -> dataLength - fragmentOffset; - command.header.command = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; - command.header.channelID = channelID; - command.sendFragment.startSequenceNumber = startSequenceNumber; - command.sendFragment.dataLength = ENET_HOST_TO_NET_16 (fragmentLength); - command.sendFragment.fragmentCount = fragmentCount; - command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32 (fragmentNumber); - command.sendFragment.totalLength = ENET_HOST_TO_NET_32 (packet -> dataLength); - command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32 (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 = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; + fragment -> command.header.channelID = channelID; + fragment -> command.sendFragment.startSequenceNumber = startSequenceNumber; + fragment -> command.sendFragment.dataLength = ENET_HOST_TO_NET_16 (fragmentLength); + fragment -> command.sendFragment.fragmentCount = 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); + } - enet_peer_queue_outgoing_command (peer, & command, packet, fragmentOffset, fragmentLength); + 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; @@ -145,9 +171,6 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) command.header.channelID = channelID; - if (! (packet -> flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) && channel -> outgoingUnreliableSequenceNumber >= 0xFFFF) - packet -> flags |= ENET_PACKET_FLAG_RELIABLE; - if (packet -> flags & ENET_PACKET_FLAG_RELIABLE) { command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; @@ -160,6 +183,12 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16 (peer -> outgoingUnsequencedGroup + 1); command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength); } + else + if (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; @@ -167,53 +196,30 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength); } - enet_peer_queue_outgoing_command (peer, & command, packet, 0, 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 channel on which to receive + @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) +enet_peer_receive (ENetPeer * peer, enet_uint8 * channelID) { - ENetChannel * channel = & peer -> channels [channelID]; - ENetIncomingCommand * incomingCommand = NULL; + ENetIncomingCommand * incomingCommand; ENetPacket * packet; - - if (! enet_list_empty (& channel -> incomingUnreliableCommands)) - { - incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingUnreliableCommands); - - if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE) - { - if (incomingCommand -> reliableSequenceNumber != channel -> incomingReliableSequenceNumber) - incomingCommand = NULL; - } - } - - if (incomingCommand == NULL && - ! enet_list_empty (& channel -> incomingReliableCommands)) - { - incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingReliableCommands); - - if (incomingCommand -> fragmentsRemaining > 0 || - incomingCommand -> reliableSequenceNumber != (enet_uint16) (channel -> incomingReliableSequenceNumber + 1)) - return NULL; - - channel -> incomingReliableSequenceNumber = incomingCommand -> reliableSequenceNumber; - - if (incomingCommand -> fragmentCount > 0) - channel -> incomingReliableSequenceNumber += incomingCommand -> fragmentCount - 1; - } - - if (incomingCommand == NULL) + + if (enet_list_empty (& peer -> dispatchedCommands)) return NULL; - enet_list_remove (& incomingCommand -> incomingCommandList); + incomingCommand = (ENetIncomingCommand *) enet_list_remove (enet_list_begin (& peer -> dispatchedCommands)); + + if (channelID != NULL) + * channelID = incomingCommand -> command.header.channelID; packet = incomingCommand -> packet; @@ -277,6 +283,13 @@ 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))); @@ -284,6 +297,7 @@ enet_peer_reset_queues (ENetPeer * peer) 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) { @@ -487,9 +501,11 @@ enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, return NULL; } - peer -> outgoingDataTotal += sizeof (ENetProtocolAcknowledge); - acknowledgement = (ENetAcknowledgement *) enet_malloc (sizeof (ENetAcknowledgement)); + if (acknowledgement == NULL) + return NULL; + + peer -> outgoingDataTotal += sizeof (ENetProtocolAcknowledge); acknowledgement -> sentTime = sentTime; acknowledgement -> command = * command; @@ -499,17 +515,14 @@ enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, return acknowledgement; } -ENetOutgoingCommand * -enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 offset, enet_uint16 length) +void +enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoingCommand) { - ENetChannel * channel = & peer -> channels [command -> header.channelID]; - ENetOutgoingCommand * outgoingCommand; + ENetChannel * channel = & peer -> channels [outgoingCommand -> command.header.channelID]; - peer -> outgoingDataTotal += enet_protocol_command_size (command -> header.command) + length; + peer -> outgoingDataTotal += enet_protocol_command_size (outgoingCommand -> command.header.command) + outgoingCommand -> fragmentLength; - outgoingCommand = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand)); - - if (command -> header.channelID == 0xFF) + if (outgoingCommand -> command.header.channelID == 0xFF) { ++ peer -> outgoingReliableSequenceNumber; @@ -517,7 +530,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> unreliableSequenceNumber = 0; } else - if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) + if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) { ++ channel -> outgoingReliableSequenceNumber; channel -> outgoingUnreliableSequenceNumber = 0; @@ -526,7 +539,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> unreliableSequenceNumber = 0; } else - if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) + if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) { ++ peer -> outgoingUnsequencedGroup; @@ -545,26 +558,103 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> sentTime = 0; outgoingCommand -> roundTripTimeout = 0; outgoingCommand -> roundTripTimeoutLimit = 0; - outgoingCommand -> fragmentOffset = offset; - outgoingCommand -> fragmentLength = length; - outgoingCommand -> packet = packet; - outgoingCommand -> command = * command; outgoingCommand -> command.header.reliableSequenceNumber = ENET_HOST_TO_NET_16 (outgoingCommand -> reliableSequenceNumber); - if (packet != NULL) - ++ packet -> referenceCount; - - if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) + 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; } +static void +enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel * channel) +{ + ENetListIterator currentCommand; + + for (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_UNRELIABLE && + incomingCommand -> reliableSequenceNumber != channel -> incomingReliableSequenceNumber) + break; + } + + if (currentCommand == enet_list_begin (& channel -> incomingUnreliableCommands)) + return; + + enet_list_move (enet_list_end (& peer -> dispatchedCommands), enet_list_begin (& channel -> incomingUnreliableCommands), enet_list_previous (currentCommand)); + + if (! peer -> needsDispatch) + { + enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList); + + peer -> needsDispatch = 1; + } +} + +static 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; + + 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; + } + + enet_peer_dispatch_incoming_unreliable_commands (peer, channel); +} + ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 fragmentCount) { + static ENetIncomingCommand dummyCommand; + ENetChannel * channel = & peer -> channels [command -> header.channelID]; enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber; enet_uint16 reliableWindow, currentWindow; @@ -665,6 +755,8 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, } incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand)); + if (incomingCommand == NULL) + goto notifyError; incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber; incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF; @@ -677,6 +769,12 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, if (fragmentCount > 0) { 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)); } @@ -685,14 +783,32 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, 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; freePacket: - if (packet != NULL) - { - if (packet -> referenceCount == 0) - enet_packet_destroy (packet); - } + 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; } diff --git a/polymer/eduke32/source/enet/src/protocol.c b/polymer/eduke32/source/enet/src/protocol.c index 47bf8447a..21460b1b8 100644 --- a/polymer/eduke32/source/enet/src/protocol.c +++ b/polymer/eduke32/source/enet/src/protocol.c @@ -34,24 +34,20 @@ enet_protocol_command_size (enet_uint8 commandNumber) static int enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event) { - ENetPeer * currentPeer = host -> lastServicedPeer; - ENetChannel * channel; - - do + while (! enet_list_empty (& host -> dispatchQueue)) { - ++ currentPeer; - - if (currentPeer >= & host -> peers [host -> peerCount]) - currentPeer = host -> peers; + ENetPeer * peer = (ENetPeer *) enet_list_remove (enet_list_begin (& host -> dispatchQueue)); - switch (currentPeer -> state) + peer -> needsDispatch = 0; + + switch (peer -> state) { case ENET_PEER_STATE_CONNECTION_PENDING: case ENET_PEER_STATE_CONNECTION_SUCCEEDED: - currentPeer -> state = ENET_PEER_STATE_CONNECTED; + peer -> state = ENET_PEER_STATE_CONNECTED; event -> type = ENET_EVENT_TYPE_CONNECT; - event -> peer = currentPeer; + event -> peer = peer; return 1; @@ -59,72 +55,77 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event) host -> recalculateBandwidthLimits = 1; event -> type = ENET_EVENT_TYPE_DISCONNECT; - event -> peer = currentPeer; - event -> data = currentPeer -> disconnectData; + event -> peer = peer; + event -> data = peer -> disconnectData; - enet_peer_reset (currentPeer); - - host -> lastServicedPeer = currentPeer; + enet_peer_reset (peer); return 1; - } - if (currentPeer -> state != ENET_PEER_STATE_CONNECTED) - continue; - - for (channel = currentPeer -> channels; - channel < & currentPeer -> channels [currentPeer -> channelCount]; - ++ channel) - { - if (enet_list_empty (& channel -> incomingReliableCommands) && - enet_list_empty (& channel -> incomingUnreliableCommands)) + case ENET_PEER_STATE_CONNECTED: + if (enet_list_empty (& peer -> dispatchedCommands)) continue; - event -> packet = enet_peer_receive (currentPeer, channel - currentPeer -> channels); + event -> packet = enet_peer_receive (peer, & event -> channelID); if (event -> packet == NULL) continue; event -> type = ENET_EVENT_TYPE_RECEIVE; - event -> peer = currentPeer; - event -> channelID = (enet_uint8) (channel - currentPeer -> channels); + event -> peer = peer; - host -> lastServicedPeer = currentPeer; + if (! enet_list_empty (& peer -> dispatchedCommands)) + { + peer -> needsDispatch = 1; + + enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList); + } return 1; } - } while (currentPeer != host -> lastServicedPeer); + } return 0; } +static void +enet_protocol_dispatch_state (ENetHost * host, ENetPeer * peer, ENetPeerState state) +{ + peer -> state = state; + + if (! peer -> needsDispatch) + { + enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList); + + peer -> needsDispatch = 1; + } +} + static void enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event) { host -> recalculateBandwidthLimits = 1; - if (event == NULL) - peer -> state = (peer -> state == ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING); - else + if (event != NULL) { - peer -> state = ENET_PEER_STATE_CONNECTED; + peer -> state = ENET_PEER_STATE_CONNECTED; - event -> type = ENET_EVENT_TYPE_CONNECT; - event -> peer = peer; + event -> type = ENET_EVENT_TYPE_CONNECT; + event -> peer = peer; } + 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; + 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) - peer -> state = ENET_PEER_STATE_ZOMBIE; - else + if (event != NULL) { event -> type = ENET_EVENT_TYPE_DISCONNECT; event -> peer = peer; @@ -132,6 +133,8 @@ enet_protocol_notify_disconnect (ENetHost * host, ENetPeer * peer, ENetEvent * e enet_peer_reset (peer); } + else + enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE); } static void @@ -289,6 +292,12 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet if (currentPeer >= & host -> peers [host -> peerCount]) return NULL; + if (channelCount > host -> channelLimit) + channelCount = host -> channelLimit; + currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); + if (currentPeer -> channels == NULL) + return NULL; + currentPeer -> channelCount = channelCount; currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT; currentPeer -> sessionID = command -> connect.sessionID; currentPeer -> address = host -> receivedAddress; @@ -298,8 +307,6 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet currentPeer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval); currentPeer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration); currentPeer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration); - currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); - currentPeer -> channelCount = channelCount; for (channel = currentPeer -> channels; channel < & currentPeer -> channels [channelCount]; @@ -396,10 +403,10 @@ enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENet packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable), dataLength, ENET_PACKET_FLAG_RELIABLE); - if (packet == NULL) + if (packet == NULL || + enet_peer_queue_incoming_command (peer, command, packet, 0) == NULL) return -1; - enet_peer_queue_incoming_command (peer, command, packet, 0); return 0; } @@ -440,16 +447,15 @@ enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const E if (peer -> unsequencedWindow [index / 32] & (1 << (index % 32))) return 0; - peer -> unsequencedWindow [index / 32] |= 1 << (index % 32); - - packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED); - if (packet == NULL) + if (packet == NULL || + enet_peer_queue_incoming_command (peer, command, packet, 0) == NULL) return -1; - - enet_peer_queue_incoming_command (peer, command, packet, 0); + + peer -> unsequencedWindow [index / 32] |= 1 << (index % 32); + return 0; } @@ -471,10 +477,10 @@ enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const EN packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable), dataLength, 0); - if (packet == NULL) + if (packet == NULL || + enet_peer_queue_incoming_command (peer, command, packet, 0) == NULL) return -1; - enet_peer_queue_incoming_command (peer, command, packet, 0); return 0; } @@ -635,7 +641,7 @@ enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetPro enet_peer_reset_queues (peer); if (peer -> state == ENET_PEER_STATE_CONNECTION_SUCCEEDED) - peer -> state = ENET_PEER_STATE_ZOMBIE; + 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) { @@ -647,7 +653,7 @@ enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetPro if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT; else - peer -> state = ENET_PEER_STATE_ZOMBIE; + enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE); peer -> disconnectData = ENET_NET_TO_HOST_32 (command -> disconnect.data); return 0; @@ -741,22 +747,28 @@ enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPee { enet_uint16 mtu; enet_uint32 windowSize; + size_t channelCount; if (peer -> state != ENET_PEER_STATE_CONNECTING) return 0; - if (ENET_NET_TO_HOST_32 (command -> verifyConnect.channelCount) != peer -> channelCount || + 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) { - peer -> state = ENET_PEER_STATE_ZOMBIE; + 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); mtu = ENET_NET_TO_HOST_16 (command -> verifyConnect.mtu); @@ -993,7 +1005,10 @@ enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event) return 0; host -> receivedDataLength = receivedLength; - + + host -> totalReceivedData += receivedLength; + host -> totalReceivedPackets ++; + switch (enet_protocol_handle_incoming_commands (host, event)) { case 1: @@ -1046,7 +1061,7 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer) command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_16 (acknowledgement -> sentTime); if ((acknowledgement -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) - peer -> state = ENET_PEER_STATE_ZOMBIE; + enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE); enet_list_remove (& acknowledgement -> acknowledgementList); enet_free (acknowledgement); @@ -1412,6 +1427,9 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch if (sentLength < 0) return -1; + + host -> totalSentData += sentLength; + host -> totalSentPackets ++; } return 0; diff --git a/polymer/eduke32/source/enet/src/unix.c b/polymer/eduke32/source/enet/src/unix.c index 5bf9ac334..69715413b 100644 --- a/polymer/eduke32/source/enet/src/unix.c +++ b/polymer/eduke32/source/enet/src/unix.c @@ -31,7 +31,7 @@ #endif #ifndef HAS_SOCKLEN_T -// typedef int socklen_t; +typedef int socklen_t; #endif #ifndef MSG_NOSIGNAL