From 1d6253cc3d63801cc4077ff4621e31cf53cc75f9 Mon Sep 17 00:00:00 2001 From: eihrul Date: Thu, 6 Jul 2006 21:22:41 +0000 Subject: [PATCH] *** empty log message *** --- configure.in | 16 +- host.c | 26 +-- include/enet/enet.h | 74 +++--- include/enet/protocol.h | 45 ++-- packet.c | 65 +++++- peer.c | 185 ++++++++------- protocol.c | 505 +++++++++++++++++++++++++--------------- unix.c | 6 +- win32.c | 2 + 9 files changed, 579 insertions(+), 345 deletions(-) diff --git a/configure.in b/configure.in index bd626c8..eb6a374 100644 --- a/configure.in +++ b/configure.in @@ -1,5 +1,5 @@ -AC_INIT(libenet, 1.0) -AM_INIT_AUTOMAKE(libenet.a, 1.0) +AC_INIT(libenet, 7-6-2006) +AM_INIT_AUTOMAKE(libenet.a, 7-6-2006) AC_PROG_CC AC_PROG_RANLIB @@ -21,4 +21,16 @@ AC_CHECK_TYPE(socklen_t, [AC_DEFINE(HAS_SOCKLEN_T)], , AC_EGREP_HEADER(MSG_MAXIOVLEN, /usr/include/sys/socket.h, AC_DEFINE(ENET_BUFFER_MAXIMUM, [MSG_MAXIOVLEN])) AC_EGREP_HEADER(MSG_MAXIOVLEN, socket.h, AC_DEFINE(ENET_BUFFER_MAXIMUM, [MSG_MAXIOVLEN])) +AC_MSG_CHECKING(whether to use CRC32) +AC_ARG_ENABLE(crc32, + [ --enable-crc32 enable CRC32 packet verification ], + [if test "$enableval" = yes; then + AC_MSG_RESULT(yes) + AC_DEFINE(USE_CRC32) + else + AC_MSG_RESULT(no) + fi], + [AC_MSG_RESULT(no)]) + AC_OUTPUT([Makefile include/Makefile include/enet/Makefile]) + diff --git a/host.c b/host.c index e5db56e..5633fb9 100644 --- a/host.c +++ b/host.c @@ -30,6 +30,9 @@ enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 inc ENetHost * host = (ENetHost *) enet_malloc (sizeof (ENetHost)); ENetPeer * currentPeer; + if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID) + return NULL; + host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer)); memset (host -> peers, 0, peerCount * sizeof (ENetPeer)); @@ -135,7 +138,7 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC currentPeer -> address = * address; currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); currentPeer -> channelCount = channelCount; - currentPeer -> challenge = (enet_uint32) enet_rand (); + currentPeer -> sessionID = (enet_uint32) enet_rand (); if (host -> outgoingBandwidth == 0) currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; @@ -163,10 +166,8 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC enet_list_clear (& channel -> incomingUnreliableCommands); } - command.header.command = ENET_PROTOCOL_COMMAND_CONNECT; + command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolConnect); command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID); command.connect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu); command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize); @@ -176,6 +177,7 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC 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.sessionID = currentPeer -> sessionID; enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0); @@ -243,7 +245,7 @@ enet_host_bandwidth_throttle (ENetHost * host) peer < & host -> peers [host -> peerCount]; ++ peer) { - if (peer -> state != ENET_PEER_STATE_CONNECTED) + if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) continue; ++ peersTotal; @@ -276,7 +278,7 @@ enet_host_bandwidth_throttle (ENetHost * host) { enet_uint32 peerBandwidth; - if (peer -> state != ENET_PEER_STATE_CONNECTED || + if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || peer -> incomingBandwidth == 0 || peer -> outgoingBandwidthThrottleEpoch == timeCurrent) continue; @@ -309,7 +311,7 @@ enet_host_bandwidth_throttle (ENetHost * host) peer < & host -> peers [host -> peerCount]; ++ peer) { - if (peer -> state != ENET_PEER_STATE_CONNECTED || + if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || peer -> outgoingBandwidthThrottleEpoch == timeCurrent) continue; @@ -339,12 +341,12 @@ enet_host_bandwidth_throttle (ENetHost * host) peer < & host -> peers [host -> peerCount]; ++ peer) { - if (peer -> state != ENET_PEER_STATE_CONNECTED || + if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || peer -> incomingBandwidthThrottleEpoch == timeCurrent) continue; if (peer -> outgoingBandwidth > 0 && - bandwidthLimit > peer -> outgoingBandwidth) + peer -> outgoingBandwidth >= bandwidthLimit) continue; peer -> incomingBandwidthThrottleEpoch = timeCurrent; @@ -359,13 +361,11 @@ enet_host_bandwidth_throttle (ENetHost * host) peer < & host -> peers [host -> peerCount]; ++ peer) { - if (peer -> state != ENET_PEER_STATE_CONNECTED) + if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) continue; - command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT; + command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolBandwidthLimit); command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth); if (peer -> incomingBandwidthThrottleEpoch == timeCurrent) diff --git a/include/enet/enet.h b/include/enet/enet.h index 4c48a92..24f6ef9 100644 --- a/include/enet/enet.h +++ b/include/enet/enet.h @@ -80,7 +80,9 @@ typedef enum /** packet will not be sequenced with other packets * not supported for reliable packets */ - ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1) + ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1), + /** packet will not allocate data, and user must supply it instead */ + ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2) } ENetPacketFlag; /** @@ -115,8 +117,8 @@ typedef struct _ENetAcknowledgement typedef struct _ENetOutgoingCommand { ENetListNode outgoingCommandList; - enet_uint32 reliableSequenceNumber; - enet_uint32 unreliableSequenceNumber; + enet_uint16 reliableSequenceNumber; + enet_uint16 unreliableSequenceNumber; enet_uint32 sentTime; enet_uint32 roundTripTimeout; enet_uint32 roundTripTimeoutLimit; @@ -129,8 +131,8 @@ typedef struct _ENetOutgoingCommand typedef struct _ENetIncomingCommand { ENetListNode incomingCommandList; - enet_uint32 reliableSequenceNumber; - enet_uint32 unreliableSequenceNumber; + enet_uint16 reliableSequenceNumber; + enet_uint16 unreliableSequenceNumber; ENetProtocol command; enet_uint32 fragmentCount; enet_uint32 fragmentsRemaining; @@ -144,10 +146,12 @@ typedef enum ENET_PEER_STATE_CONNECTING = 1, ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2, ENET_PEER_STATE_CONNECTION_PENDING = 3, - ENET_PEER_STATE_CONNECTED = 4, - ENET_PEER_STATE_DISCONNECTING = 5, - ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 6, - ENET_PEER_STATE_ZOMBIE = 7 + 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 @@ -157,6 +161,7 @@ typedef enum 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, @@ -197,7 +202,7 @@ typedef struct _ENetPeer struct _ENetHost * host; enet_uint16 outgoingPeerID; enet_uint16 incomingPeerID; - enet_uint32 challenge; + enet_uint32 sessionID; ENetAddress address; /**< Internet address of the peer */ void * data; /**< Application private data, may be freely modified */ ENetPeerState state; @@ -234,14 +239,14 @@ typedef struct _ENetPeer enet_uint16 mtu; enet_uint32 windowSize; enet_uint32 reliableDataInTransit; - enet_uint32 outgoingReliableSequenceNumber; + enet_uint16 outgoingReliableSequenceNumber; ENetList acknowledgements; ENetList sentReliableCommands; ENetList sentUnreliableCommands; ENetList outgoingReliableCommands; ENetList outgoingUnreliableCommands; - enet_uint32 incomingUnsequencedGroup; - enet_uint32 outgoingUnsequencedGroup; + enet_uint16 incomingUnsequencedGroup; + enet_uint16 outgoingUnsequencedGroup; enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; enet_uint32 disconnectData; } ENetPeer; @@ -271,7 +276,9 @@ typedef struct _ENetHost ENetPeer * peers; /**< array of peers allocated for this host */ size_t peerCount; /**< number of peers allocated for this host */ ENetPeer * lastServicedPeer; + int continueSending; size_t packetSize; + enet_uint16 headerFlags; ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS]; size_t commandCount; ENetBuffer buffers [ENET_BUFFER_MAXIMUM]; @@ -337,7 +344,7 @@ typedef struct _ENetEvent */ ENET_API int enet_initialize (void); -ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits); +ENET_API int enet_initialize_with_callbacks (ENetVersion, const ENetCallbacks *); /** Shuts down ENet globally. Should be called when a program that has @@ -361,15 +368,14 @@ ENET_API void enet_time_set (enet_uint32); /** @defgroup socket ENet socket functions @{ - @ingroup private */ -extern ENetSocket enet_socket_create (ENetSocketType, const ENetAddress *); -extern ENetSocket enet_socket_accept (ENetSocket, ENetAddress *); -extern int enet_socket_connect (ENetSocket, const ENetAddress *); -extern int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t); -extern int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t); -extern int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32); -extern void enet_socket_destroy (ENetSocket); +ENET_API ENetSocket enet_socket_create (ENetSocketType, const ENetAddress *); +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_uint32); +ENET_API void enet_socket_destroy (ENetSocket); /** @} */ @@ -384,7 +390,7 @@ extern void enet_socket_destroy (ENetSocket); @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 ); +ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName); /** Attempts to do a reserve lookup of the host field in the address parameter. @param address address used for reverse lookup @@ -394,17 +400,18 @@ ENET_API int enet_address_set_host (ENetAddress *address, const char *hostName ) @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 int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength); /** @} */ -ENET_API ENetPacket * enet_packet_create (const void *dataContents, size_t dataLength, enet_uint32 flags); -ENET_API void enet_packet_destroy (ENetPacket *packet ); -ENET_API int enet_packet_resize (ENetPacket *packet, size_t dataLength ); - -ENET_API ENetHost * enet_host_create (const ENetAddress *address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth ); -ENET_API void enet_host_destroy (ENetHost *host ); -ENET_API ENetPeer * enet_host_connect (ENetHost *host, const ENetAddress *address, size_t channelCount ); +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); +extern enet_uint32 enet_crc32 (const ENetBuffer *, size_t); + +ENET_API ENetHost * enet_host_create (const ENetAddress *, 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_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 *); @@ -417,12 +424,15 @@ ENET_API void enet_peer_ping (ENetPeer *); 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 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_uint32); +extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16); + +extern size_t enet_protocol_command_size (enet_uint8); #ifdef __cplusplus } diff --git a/include/enet/protocol.h b/include/enet/protocol.h index 6d4dae9..e5b4a32 100644 --- a/include/enet/protocol.h +++ b/include/enet/protocol.h @@ -15,7 +15,8 @@ enum ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096, ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 32768, ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1, - ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255 + ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255, + ENET_PROTOCOL_MAXIMUM_PEER_ID = 0x7FFF, }; typedef enum @@ -29,41 +30,42 @@ typedef enum ENET_PROTOCOL_COMMAND_SEND_RELIABLE = 6, ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE = 7, ENET_PROTOCOL_COMMAND_SEND_FRAGMENT = 8, - ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 9, - ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 10, - ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 11 + ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 9, + ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 10, + ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11, + ENET_PROTOCOL_COMMAND_COUNT = 12, + + ENET_PROTOCOL_COMMAND_MASK = 0x0F, } ENetProtocolCommand; typedef enum { - ENET_PROTOCOL_FLAG_ACKNOWLEDGE = (1 << 0), - ENET_PROTOCOL_FLAG_UNSEQUENCED = (1 << 1) + ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7), + ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6), + + ENET_PROTOCOL_HEADER_FLAG_SENT_TIME = (1 << 15), + ENET_PROTOCOL_HEADER_FLAG_MASK = 0x8000, } ENetProtocolFlag; typedef struct { + enet_uint32 checksum; enet_uint16 peerID; - enet_uint8 flags; - enet_uint8 commandCount; - enet_uint32 sentTime; - enet_uint32 challenge; + enet_uint16 sentTime; } ENetProtocolHeader; typedef struct { enet_uint8 command; enet_uint8 channelID; - enet_uint8 flags; - enet_uint8 reserved; - enet_uint32 commandLength; - enet_uint32 reliableSequenceNumber; + enet_uint16 reliableSequenceNumber; } ENetProtocolCommandHeader; typedef struct { ENetProtocolCommandHeader header; - enet_uint32 receivedReliableSequenceNumber; - enet_uint32 receivedSentTime; + enet_uint16 receivedReliableSequenceNumber; + enet_uint16 receivedSentTime; } ENetProtocolAcknowledge; typedef struct @@ -78,6 +80,7 @@ typedef struct enet_uint32 packetThrottleInterval; enet_uint32 packetThrottleAcceleration; enet_uint32 packetThrottleDeceleration; + enet_uint32 sessionID; } ENetProtocolConnect; typedef struct @@ -123,24 +126,28 @@ typedef struct typedef struct { ENetProtocolCommandHeader header; + enet_uint16 dataLength; } ENetProtocolSendReliable; typedef struct { ENetProtocolCommandHeader header; - enet_uint32 unreliableSequenceNumber; + enet_uint16 unreliableSequenceNumber; + enet_uint16 dataLength; } ENetProtocolSendUnreliable; typedef struct { ENetProtocolCommandHeader header; - enet_uint32 unsequencedGroup; + enet_uint16 unsequencedGroup; + enet_uint16 dataLength; } ENetProtocolSendUnsequenced; typedef struct { ENetProtocolCommandHeader header; - enet_uint32 startSequenceNumber; + enet_uint16 startSequenceNumber; + enet_uint16 dataLength; enet_uint32 fragmentCount; enet_uint32 fragmentNumber; enet_uint32 totalLength; diff --git a/packet.c b/packet.c index 5226550..77b5583 100644 --- a/packet.c +++ b/packet.c @@ -21,10 +21,15 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags) { ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket)); - packet -> data = (enet_uint8 *) enet_malloc (dataLength); + if(flags & ENET_PACKET_FLAG_NO_ALLOCATE) + packet -> data = (enet_uint8 *) data; + else + { + packet -> data = (enet_uint8 *) enet_malloc (dataLength); - if (data != NULL) - memcpy (packet -> data, data, dataLength); + if (data != NULL) + memcpy (packet -> data, data, dataLength); + }; packet -> referenceCount = 0; packet -> flags = flags; @@ -39,7 +44,8 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags) void enet_packet_destroy (ENetPacket * packet) { - enet_free (packet -> data); + if((packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE) == 0) + enet_free (packet -> data); enet_free (packet); } @@ -54,7 +60,7 @@ enet_packet_resize (ENetPacket * packet, size_t dataLength) { enet_uint8 * newData; - if (dataLength <= packet -> dataLength) + if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE)) { packet -> dataLength = dataLength; @@ -71,4 +77,53 @@ enet_packet_resize (ENetPacket * packet, size_t dataLength) return 0; } +static int initializedCRC32 = 0; +static enet_uint32 crcTable [256]; + +static void initialize_crc32 () +{ + int byte; + + for (byte = 0; byte < 256; ++ byte) + { + enet_uint32 crc = byte << 24; + int offset; + + for(offset = 0; offset < 8; ++ offset) + { + if (crc & 0x80000000) + crc = (crc << 1) ^ 0x04c11db7; + else + crc <<= 1; + } + + crcTable [byte] = crc; + } + + 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) | * data ++) ^ crcTable [crc >> 24]; + } + + ++ buffers; + } + + return ENET_HOST_TO_NET_32 (~ crc); +} + /** @} */ diff --git a/peer.c b/peer.c index 754239f..1a23c4c 100644 --- a/peer.c +++ b/peer.c @@ -48,10 +48,8 @@ enet_peer_throttle_configure (ENetPeer * peer, enet_uint32 interval, enet_uint32 peer -> packetThrottleAcceleration = acceleration; peer -> packetThrottleDeceleration = deceleration; - command.header.command = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE; + command.header.command = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolThrottleConfigure); command.throttleConfigure.packetThrottleInterval = ENET_HOST_TO_NET_32 (interval); command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (acceleration); @@ -113,8 +111,8 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) if (packet -> dataLength > fragmentLength) { + enet_uint16 startSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingReliableSequenceNumber + 1); enet_uint32 fragmentCount = ENET_HOST_TO_NET_32 ((packet -> dataLength + fragmentLength - 1) / fragmentLength), - startSequenceNumber = ENET_HOST_TO_NET_32 (channel -> outgoingReliableSequenceNumber + 1), fragmentNumber, fragmentOffset; @@ -126,19 +124,18 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) ++ fragmentNumber, fragmentOffset += fragmentLength) { - command.header.command = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT; + 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.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolSendFragment); 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); - if (packet -> dataLength - fragmentOffset < fragmentLength) - fragmentLength = packet -> dataLength - fragmentOffset; - enet_peer_queue_outgoing_command (peer, & command, packet, fragmentOffset, fragmentLength); } @@ -149,24 +146,21 @@ enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet) if (packet -> flags & ENET_PACKET_FLAG_RELIABLE) { - command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE; - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolSendReliable); + command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; + command.sendReliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength); } else if (packet -> flags & ENET_PACKET_FLAG_UNSEQUENCED) { - command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED; - command.header.flags = ENET_PROTOCOL_FLAG_UNSEQUENCED; - command.header.commandLength = sizeof (ENetProtocolSendUnsequenced); - command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_32 (peer -> outgoingUnsequencedGroup + 1); + command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED; + command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16 (peer -> outgoingUnsequencedGroup + 1); + command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength); } else { command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE; - command.header.flags = 0; - command.header.commandLength = sizeof (ENetProtocolSendUnreliable); - command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_32 (channel -> outgoingUnreliableSequenceNumber + 1); + command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingUnreliableSequenceNumber + 1); + command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength); } enet_peer_queue_outgoing_command (peer, & command, packet, 0, packet -> dataLength); @@ -186,13 +180,13 @@ enet_peer_receive (ENetPeer * peer, enet_uint8 channelID) ENetIncomingCommand * incomingCommand = NULL; ENetPacket * packet; - if (enet_list_empty (& channel -> incomingUnreliableCommands) == 0) + if (! enet_list_empty (& channel -> incomingUnreliableCommands)) { incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingUnreliableCommands); - if (incomingCommand -> unreliableSequenceNumber > 0) + if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE) { - if (incomingCommand -> reliableSequenceNumber > channel -> incomingReliableSequenceNumber) + if (incomingCommand -> reliableSequenceNumber != channel -> incomingReliableSequenceNumber) incomingCommand = NULL; else channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber; @@ -200,36 +194,12 @@ enet_peer_receive (ENetPeer * peer, enet_uint8 channelID) } if (incomingCommand == NULL && - enet_list_empty (& channel -> incomingReliableCommands) == 0) + ! enet_list_empty (& channel -> incomingReliableCommands)) { - do - { - incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingReliableCommands); + incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingReliableCommands); - if (incomingCommand -> fragmentsRemaining > 0 || - incomingCommand -> reliableSequenceNumber > channel -> incomingReliableSequenceNumber + 1) - return NULL; - - if (incomingCommand -> reliableSequenceNumber <= channel -> incomingReliableSequenceNumber) - { - -- incomingCommand -> packet -> referenceCount; - - if (incomingCommand -> packet -> referenceCount == 0) - enet_packet_destroy (incomingCommand -> packet); - - if (incomingCommand -> fragments != NULL) - enet_free (incomingCommand -> fragments); - - enet_list_remove (& incomingCommand -> incomingCommandList); - - enet_free (incomingCommand); - - incomingCommand = NULL; - } - } while (incomingCommand == NULL && - enet_list_empty (& channel -> incomingReliableCommands) == 0); - - if (incomingCommand == NULL) + if (incomingCommand -> fragmentsRemaining > 0 || + incomingCommand -> reliableSequenceNumber != channel -> incomingReliableSequenceNumber + 1) return NULL; channel -> incomingReliableSequenceNumber = incomingCommand -> reliableSequenceNumber; @@ -260,7 +230,7 @@ enet_peer_reset_outgoing_commands (ENetList * queue) { ENetOutgoingCommand * outgoingCommand; - while (enet_list_empty (queue) == 0) + while (! enet_list_empty (queue)) { outgoingCommand = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (queue)); @@ -281,7 +251,7 @@ enet_peer_reset_incoming_commands (ENetList * queue) { ENetIncomingCommand * incomingCommand; - while (enet_list_empty (queue) == 0) + while (! enet_list_empty (queue)) { incomingCommand = (ENetIncomingCommand *) enet_list_remove (enet_list_begin (queue)); @@ -305,7 +275,7 @@ enet_peer_reset_queues (ENetPeer * peer) { ENetChannel * channel; - while (enet_list_empty (& peer -> acknowledgements) == 0) + while (! enet_list_empty (& peer -> acknowledgements)) enet_free (enet_list_remove (enet_list_begin (& peer -> acknowledgements))); enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands); @@ -338,8 +308,8 @@ enet_peer_reset_queues (ENetPeer * peer) void enet_peer_reset (ENetPeer * peer) { - peer -> outgoingPeerID = 0xFFFF; - peer -> challenge = 0; + peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID; + peer -> sessionID = 0; peer -> address.host = ENET_HOST_ANY; peer -> address.port = 0; @@ -402,10 +372,8 @@ enet_peer_ping (ENetPeer * peer) if (peer -> state != ENET_PEER_STATE_CONNECTED) return; - command.header.command = ENET_PROTOCOL_COMMAND_PING; + command.header.command = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - command.header.commandLength = sizeof (ENetProtocolPing); enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0); } @@ -430,11 +398,9 @@ enet_peer_disconnect_now (ENetPeer * peer, enet_uint32 data) { enet_peer_reset_queues (peer); - command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT; + command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_UNSEQUENCED; - command.header.commandLength = sizeof (ENetProtocolDisconnect); - command.disconnect.data = data; + command.disconnect.data = ENET_HOST_TO_NET_32 (data); enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0); @@ -464,16 +430,16 @@ enet_peer_disconnect (ENetPeer * peer, enet_uint32 data) command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT; command.header.channelID = 0xFF; - command.header.flags = ENET_PROTOCOL_FLAG_UNSEQUENCED; - command.header.commandLength = sizeof (ENetProtocolDisconnect); - command.disconnect.data = data; + command.disconnect.data = ENET_HOST_TO_NET_32 (data); - if (peer -> state == ENET_PEER_STATE_CONNECTED) - command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; + 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) + if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) peer -> state = ENET_PEER_STATE_DISCONNECTING; else { @@ -482,8 +448,29 @@ enet_peer_disconnect (ENetPeer * peer, enet_uint32 data) } } +/** 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 -> disconnectData = data; + } + else + enet_peer_disconnect (peer, data); +} + ENetAcknowledgement * -enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint32 sentTime) +enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint16 sentTime) { ENetAcknowledgement * acknowledgement; @@ -505,7 +492,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, ENetChannel * channel = & peer -> channels [command -> header.channelID]; ENetOutgoingCommand * outgoingCommand; - peer -> outgoingDataTotal += command -> header.commandLength + length; + peer -> outgoingDataTotal += enet_protocol_command_size (command -> header.command) + length; outgoingCommand = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand)); @@ -517,7 +504,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> unreliableSequenceNumber = 0; } else - if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) + if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) { ++ channel -> outgoingReliableSequenceNumber; @@ -525,7 +512,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> unreliableSequenceNumber = 0; } else - if (command -> header.flags & ENET_PROTOCOL_FLAG_UNSEQUENCED) + if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) { ++ peer -> outgoingUnsequencedGroup; @@ -547,12 +534,12 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, outgoingCommand -> fragmentLength = length; outgoingCommand -> packet = packet; outgoingCommand -> command = * command; - outgoingCommand -> command.header.reliableSequenceNumber = ENET_HOST_TO_NET_32 (outgoingCommand -> reliableSequenceNumber); + outgoingCommand -> command.header.reliableSequenceNumber = ENET_HOST_TO_NET_16 (outgoingCommand -> reliableSequenceNumber); if (packet != NULL) ++ packet -> referenceCount; - if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) + if (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); @@ -564,23 +551,44 @@ ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 fragmentCount) { ENetChannel * channel = & peer -> channels [command -> header.channelID]; - enet_uint32 unreliableSequenceNumber = 0; + enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber; ENetIncomingCommand * incomingCommand; ENetListIterator currentCommand; - switch (command -> header.command) + if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) + goto freePacket; + + if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) + { + reliableSequenceNumber = command -> header.reliableSequenceNumber; + + if (channel -> incomingReliableSequenceNumber >= 0xF000 && reliableSequenceNumber < 0x1000) + reliableSequenceNumber += 0x10000; + + if (reliableSequenceNumber < channel -> incomingReliableSequenceNumber || + (channel -> incomingReliableSequenceNumber < 0x1000 && (reliableSequenceNumber & 0xFFFF) >= 0xF000)) + goto freePacket; + } + + 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 freePacket; + 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 (incomingCommand -> reliableSequenceNumber <= command -> header.reliableSequenceNumber) + if (reliableSequenceNumber >= 0x10000 && incomingCommand -> reliableSequenceNumber < 0xF000) + reliableSequenceNumber -= 0x10000; + + if (incomingCommand -> reliableSequenceNumber <= reliableSequenceNumber) { - if (incomingCommand -> reliableSequenceNumber < command -> header.reliableSequenceNumber) + if (incomingCommand -> reliableSequenceNumber < reliableSequenceNumber) break; goto freePacket; @@ -589,12 +597,13 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, break; case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE: - unreliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> sendUnreliable.unreliableSequenceNumber); + unreliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendUnreliable.unreliableSequenceNumber); - if (command -> header.reliableSequenceNumber < channel -> incomingReliableSequenceNumber) - goto freePacket; - - if (unreliableSequenceNumber <= channel -> incomingUnreliableSequenceNumber) + if (channel -> incomingUnreliableSequenceNumber >= 0xF000 && unreliableSequenceNumber < 0x1000) + unreliableSequenceNumber += 0x10000; + + if (unreliableSequenceNumber <= channel -> incomingUnreliableSequenceNumber || + (channel -> incomingUnreliableSequenceNumber < 0x1000 && (unreliableSequenceNumber & 0xFFFF) >= 0xF000)) goto freePacket; for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands)); @@ -603,6 +612,12 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, { incomingCommand = (ENetIncomingCommand *) currentCommand; + if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE) + continue; + + if (unreliableSequenceNumber >= 0x10000 && incomingCommand -> unreliableSequenceNumber < 0xF000) + unreliableSequenceNumber -= 0x10000; + if (incomingCommand -> unreliableSequenceNumber <= unreliableSequenceNumber) { if (incomingCommand -> unreliableSequenceNumber < unreliableSequenceNumber) @@ -624,7 +639,7 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand)); incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber; - incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber; + incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF; incomingCommand -> command = * command; incomingCommand -> fragmentCount = fragmentCount; incomingCommand -> fragmentsRemaining = fragmentCount; diff --git a/protocol.c b/protocol.c index e6263eb..5684dc8 100644 --- a/protocol.c +++ b/protocol.c @@ -11,6 +11,28 @@ static enet_uint32 timeCurrent; +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), +}; + +size_t +enet_protocol_command_size (enet_uint8 commandNumber) +{ + return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK]; +} + static int enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event) { @@ -27,6 +49,7 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event) switch (currentPeer -> state) { case ENET_PEER_STATE_CONNECTION_PENDING: + case ENET_PEER_STATE_CONNECTION_SUCCEEDED: currentPeer -> state = ENET_PEER_STATE_CONNECTED; event -> type = ENET_EVENT_TYPE_CONNECT; @@ -82,7 +105,7 @@ enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * even host -> recalculateBandwidthLimits = 1; if (event == NULL) - peer -> state = ENET_PEER_STATE_CONNECTION_PENDING; + peer -> state = (peer -> state == ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING); else { peer -> state = ENET_PEER_STATE_CONNECTED; @@ -98,7 +121,7 @@ enet_protocol_notify_disconnect (ENetHost * host, ENetPeer * peer, ENetEvent * e if (peer -> state >= ENET_PEER_STATE_CONNECTION_PENDING) host -> recalculateBandwidthLimits = 1; - if (peer -> state < ENET_PEER_STATE_CONNECTED) + if (peer -> state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) enet_peer_reset (peer); else if (event == NULL) @@ -118,7 +141,7 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer) { ENetOutgoingCommand * outgoingCommand; - while (enet_list_empty (& peer -> sentUnreliableCommands) == 0) + while (! enet_list_empty (& peer -> sentUnreliableCommands)) { outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands); @@ -137,7 +160,7 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer) } static ENetProtocolCommand -enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint32 reliableSequenceNumber, enet_uint8 channelID) +enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID) { ENetOutgoingCommand * outgoingCommand; ENetListIterator currentCommand; @@ -157,7 +180,7 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint32 reliabl if (currentCommand == enet_list_end (& peer -> sentReliableCommands)) return ENET_PROTOCOL_COMMAND_NONE; - commandNumber = outgoingCommand -> command.header.command; + commandNumber = outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK; enet_list_remove (& outgoingCommand -> outgoingCommandList); @@ -184,7 +207,7 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint32 reliabl } static ENetPeer * -enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header, const ENetProtocol * command) +enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENetProtocol * command) { enet_uint16 mtu; enet_uint32 windowSize; @@ -193,9 +216,25 @@ enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header ENetPeer * currentPeer; ENetProtocol verifyCommand; - if (command -> header.commandLength < sizeof (ENetProtocolConnect)) - return NULL; +#ifdef USE_CRC32 + { + enet_uint32 crc = header -> checksum; + ENetBuffer buffer; + command -> header.reliableSequenceNumber = ENET_HOST_TO_NET_16 (command -> header.reliableSequenceNumber); + + header -> checksum = command -> connect.sessionID; + + buffer.data = host -> receivedData; + buffer.dataLength = host -> receivedDataLength; + + if (enet_crc32 (& buffer, 1) != crc) + return NULL; + + command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> header.reliableSequenceNumber); + } +#endif + channelCount = ENET_NET_TO_HOST_32 (command -> connect.channelCount); if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || @@ -209,7 +248,7 @@ enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header if (currentPeer -> state != ENET_PEER_STATE_DISCONNECTED && currentPeer -> address.host == host -> receivedAddress.host && currentPeer -> address.port == host -> receivedAddress.port && - currentPeer -> challenge == header -> challenge) + currentPeer -> sessionID == command -> connect.sessionID) return NULL; } @@ -225,7 +264,7 @@ enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header return NULL; currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT; - currentPeer -> challenge = header -> challenge; + currentPeer -> sessionID = command -> connect.sessionID; currentPeer -> address = host -> receivedAddress; currentPeer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID); currentPeer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth); @@ -288,10 +327,8 @@ enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; - verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT; + verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; verifyCommand.header.channelID = 0xFF; - verifyCommand.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE; - verifyCommand.header.commandLength = sizeof (ENetProtocolVerifyConnect); verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID); verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu); verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize); @@ -307,38 +344,50 @@ enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header return currentPeer; } -static void -enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) +static int +enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData) { ENetPacket * packet; + size_t dataLength; - if (command -> header.commandLength <= sizeof (ENetProtocolSendReliable) || - command -> header.channelID >= peer -> channelCount || - peer -> state != ENET_PEER_STATE_CONNECTED) - return; + 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 (* currentData > & host -> receivedData [host -> receivedDataLength]) + return -1; packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable), - command -> header.commandLength - sizeof (ENetProtocolSendReliable), + dataLength, ENET_PACKET_FLAG_RELIABLE); enet_peer_queue_incoming_command (peer, command, packet, 0); + return 0; } -static void -enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) +static int +enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData) { ENetPacket * packet; enet_uint32 unsequencedGroup, index; + size_t dataLength; - if (command -> header.commandLength <= sizeof (ENetProtocolSendUnsequenced) || - command -> header.channelID >= peer -> channelCount || - peer -> state != ENET_PEER_STATE_CONNECTED) - return; + if (command -> header.channelID >= peer -> channelCount || + (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)) + return -1; - unsequencedGroup = ENET_NET_TO_HOST_32 (command -> sendUnsequenced.unsequencedGroup); + dataLength = ENET_NET_TO_HOST_16 (command -> sendUnsequenced.dataLength); + * currentData += dataLength; + if (* 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 + ENET_PEER_UNSEQUENCED_WINDOW_SIZE) + if (unsequencedGroup >= peer -> incomingUnsequencedGroup + ENET_PEER_UNSEQUENCED_WINDOW_SIZE || + peer -> incomingUnsequencedGroup >= 0xF000 && unsequencedGroup < 0x1000) { peer -> incomingUnsequencedGroup = unsequencedGroup - index; @@ -347,37 +396,44 @@ enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const E else if (unsequencedGroup < peer -> incomingUnsequencedGroup || peer -> unsequencedWindow [index / 32] & (1 << (index % 32))) - return; + return 0; peer -> unsequencedWindow [index / 32] |= 1 << (index % 32); packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnsequenced), - command -> header.commandLength - sizeof (ENetProtocolSendUnsequenced), + dataLength, ENET_PACKET_FLAG_UNSEQUENCED); enet_peer_queue_incoming_command (peer, command, packet, 0); + return 0; } -static void -enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) +static int +enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData) { ENetPacket * packet; + size_t dataLength; - if (command -> header.commandLength <= sizeof (ENetProtocolSendUnreliable) || - command -> header.channelID >= peer -> channelCount || - peer -> state != ENET_PEER_STATE_CONNECTED) - return; + 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 (* currentData > & host -> receivedData [host -> receivedDataLength]) + return -1; packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable), - command -> header.commandLength - sizeof (ENetProtocolSendUnreliable), + dataLength, 0); enet_peer_queue_incoming_command (peer, command, packet, 0); + return 0; } -static void -enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) +static int +enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command, enet_uint8 ** currentData) { enet_uint32 fragmentNumber, fragmentCount, @@ -389,36 +445,42 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet ENetListIterator currentCommand; ENetIncomingCommand * startCommand; - if (command -> header.commandLength <= sizeof (ENetProtocolSendFragment) || - command -> header.channelID >= peer -> channelCount || - peer -> state != ENET_PEER_STATE_CONNECTED) - return; + 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 (* currentData > & host -> receivedData [host -> receivedDataLength]) + return -1; + + channel = & peer -> channels [command -> header.channelID]; + startSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendFragment.startSequenceNumber); + if (channel -> incomingReliableSequenceNumber >= 0xF000 && startSequenceNumber < 0x1000) + startSequenceNumber += 0x10000; + + if (startSequenceNumber < channel -> incomingReliableSequenceNumber || + (channel -> incomingReliableSequenceNumber < 0x1000 && (startSequenceNumber & 0xFFFF) >= 0xF000)) + return 0; - startSequenceNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.startSequenceNumber); 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); - fragmentLength = command -> header.commandLength - sizeof (ENetProtocolSendFragment); if (fragmentOffset >= totalLength || fragmentOffset + fragmentLength > totalLength || fragmentNumber >= fragmentCount) - return; + return -1; - channel = & peer -> channels [command -> header.channelID]; - - if (startSequenceNumber <= channel -> incomingReliableSequenceNumber) - return; - for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands)); currentCommand != enet_list_end (& channel -> incomingReliableCommands); currentCommand = enet_list_previous (currentCommand)) { startCommand = (ENetIncomingCommand *) currentCommand; - if (startCommand -> command.header.command == ENET_PROTOCOL_COMMAND_SEND_FRAGMENT && - startCommand -> command.sendFragment.startSequenceNumber == startSequenceNumber) + if ((startCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_FRAGMENT && + startCommand -> command.sendFragment.startSequenceNumber == (startSequenceNumber & 0xFFFF)) break; } @@ -428,6 +490,7 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet hostCommand.header.reliableSequenceNumber = startSequenceNumber; hostCommand.sendFragment.startSequenceNumber = startSequenceNumber; + hostCommand.sendFragment.dataLength = fragmentLength; hostCommand.sendFragment.fragmentNumber = fragmentNumber; hostCommand.sendFragment.fragmentCount = fragmentCount; hostCommand.sendFragment.fragmentOffset = fragmentOffset; @@ -441,7 +504,7 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet else if (totalLength != startCommand -> packet -> dataLength || fragmentCount != startCommand -> fragmentCount) - return; + return -1; if ((startCommand -> fragments [fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) { @@ -456,26 +519,23 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet (enet_uint8 *) command + sizeof (ENetProtocolSendFragment), fragmentLength); } + + return 0; } -static void +static int enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) { - if (command -> header.commandLength < sizeof (ENetProtocolPing)) - return; + return 0; } -static void +static int enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) { - if (command -> header.commandLength < sizeof (ENetProtocolBandwidthLimit)) - return; - 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 -> outgoingBandwidth == 0) + if (peer -> incomingBandwidth == 0 && host -> outgoingBandwidth == 0) peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; else peer -> windowSize = (ENET_MIN (peer -> incomingBandwidth, host -> outgoingBandwidth) / @@ -486,40 +546,42 @@ enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const EN else if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; + + return 0; } -static void +static int enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) { - if (command -> header.commandLength < sizeof (ENetProtocolThrottleConfigure)) - return; - 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 void +static int enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) { - if (command -> header.commandLength < sizeof (ENetProtocolDisconnect)) - return; - enet_peer_reset_queues (peer); - if (peer -> state != ENET_PEER_STATE_CONNECTED) + if (peer -> state == ENET_PEER_STATE_CONNECTION_SUCCEEDED) + peer -> state = 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.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) + if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT; else peer -> state = ENET_PEER_STATE_ZOMBIE; - peer -> disconnectData = command -> disconnect.data; + peer -> disconnectData = ENET_NET_TO_HOST_32 (command -> disconnect.data); + return 0; } static int @@ -530,10 +592,10 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * receivedReliableSequenceNumber; ENetProtocolCommand commandNumber; - if (command -> header.commandLength < sizeof (ENetProtocolAcknowledge)) - return 0; - - receivedSentTime = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedSentTime); + receivedSentTime = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedSentTime); + receivedSentTime |= timeCurrent & 0xFFFF0000; + if ((receivedSentTime & 0x8000) > (timeCurrent & 0x8000)) + receivedSentTime -= 0x10000; if (ENET_TIME_LESS (timeCurrent, receivedSentTime)) return 0; @@ -574,7 +636,7 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * peer -> packetThrottleEpoch = timeCurrent; } - receivedReliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedReliableSequenceNumber); + receivedReliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedReliableSequenceNumber); commandNumber = enet_protocol_remove_sent_reliable_command (peer, receivedReliableSequenceNumber, command -> header.channelID); @@ -582,34 +644,37 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * { case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT: if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT) - return 0; + return -1; enet_protocol_notify_connect (host, peer, event); - - return 1; + break; case ENET_PEER_STATE_DISCONNECTING: if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT) - return 0; + return -1; enet_protocol_notify_disconnect (host, peer, event); + break; - return 1; + 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 -> disconnectData); + break; } return 0; } -static void +static int enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command) { enet_uint16 mtu; enet_uint32 windowSize; - if (event == NULL || - command -> header.commandLength < sizeof (ENetProtocolVerifyConnect) || - peer -> state != ENET_PEER_STATE_CONNECTING) - return; + if (peer -> state != ENET_PEER_STATE_CONNECTING) + return -1; if (ENET_NET_TO_HOST_32 (command -> verifyConnect.channelCount) != peer -> channelCount || ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleInterval) != peer -> packetThrottleInterval || @@ -618,9 +683,11 @@ enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPee { peer -> state = ENET_PEER_STATE_ZOMBIE; - return; + return -1; } + enet_protocol_remove_sent_reliable_command (peer, 1, 0xFF); + peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> verifyConnect.outgoingPeerID); mtu = ENET_NET_TO_HOST_16 (command -> verifyConnect.mtu); @@ -649,6 +716,7 @@ enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPee peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.outgoingBandwidth); enet_protocol_notify_connect (host, peer, event); + return 0; } static int @@ -658,135 +726,175 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event) ENetProtocol * command; ENetPeer * peer; enet_uint8 * currentData; - size_t commandCount; + size_t headerSize; + enet_uint16 peerID, flags; if (host -> receivedDataLength < sizeof (ENetProtocolHeader)) return 0; header = (ENetProtocolHeader *) host -> receivedData; - header -> peerID = ENET_NET_TO_HOST_16 (header -> peerID); - header -> sentTime = ENET_NET_TO_HOST_32 (header -> sentTime); + peerID = ENET_NET_TO_HOST_16 (header -> peerID); + flags = peerID & ENET_PROTOCOL_HEADER_FLAG_MASK; + peerID &= ~ ENET_PROTOCOL_HEADER_FLAG_MASK; - if (header -> peerID == 0xFFFF) + if (peerID == ENET_PROTOCOL_MAXIMUM_PEER_ID) peer = NULL; else - if (header -> peerID >= host -> peerCount) + if (peerID >= host -> peerCount) return 0; else { - peer = & host -> peers [header -> peerID]; + peer = & host -> peers [peerID]; if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE || (host -> receivedAddress.host != peer -> address.host && - peer -> address.host != ENET_HOST_BROADCAST) || - header -> challenge != peer -> challenge) + peer -> address.host != ENET_HOST_BROADCAST)) return 0; - else + +#ifdef USE_CRC32 { - peer -> address.host = host -> receivedAddress.host; - peer -> address.port = host -> receivedAddress.port; + enet_uint32 crc = header -> checksum; + ENetBuffer buffer; + + header -> checksum = peer -> sessionID; + + buffer.data = host -> receivedData; + buffer.dataLength = host -> receivedDataLength; + + if (enet_crc32 (& buffer, 1) != crc) + return 0; } +#else + if (header -> checksum != peer -> sessionID) + return 0; +#endif + + peer -> address.host = host -> receivedAddress.host; + peer -> address.port = host -> receivedAddress.port; + peer -> incomingDataTotal += host -> receivedDataLength; } - - if (peer != NULL) - peer -> incomingDataTotal += host -> receivedDataLength; - - commandCount = header -> commandCount; - currentData = host -> receivedData + sizeof (ENetProtocolHeader); + + headerSize = (flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME ? sizeof (ENetProtocolHeader) : (size_t) & ((ENetProtocolHeader *) 0) -> sentTime); + currentData = host -> receivedData + headerSize; - while (commandCount > 0 && - currentData < & host -> receivedData [host -> receivedDataLength]) + while (currentData < & host -> receivedData [host -> receivedDataLength]) { + enet_uint8 commandNumber; + size_t commandSize; + command = (ENetProtocol *) currentData; if (currentData + sizeof (ENetProtocolCommandHeader) > & host -> receivedData [host -> receivedDataLength]) break; - command -> header.commandLength = ENET_NET_TO_HOST_32 (command -> header.commandLength); - - if (command -> header.commandLength <= 0 || - command -> header.commandLength > & host -> receivedData [host -> receivedDataLength] - currentData) + 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; - -- commandCount; - currentData += command -> header.commandLength; + currentData += commandSize; - if (peer == NULL && command -> header.command != ENET_PROTOCOL_COMMAND_CONNECT) + if (peer == NULL && commandNumber != ENET_PROTOCOL_COMMAND_CONNECT) break; - command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> header.reliableSequenceNumber); + command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> header.reliableSequenceNumber); - switch (command -> header.command) + switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK) { case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE: - enet_protocol_handle_acknowledge (host, event, peer, command); + if (enet_protocol_handle_acknowledge (host, event, peer, command)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_CONNECT: peer = enet_protocol_handle_connect (host, header, command); + if (peer == NULL) + goto commandError; break; case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT: - enet_protocol_handle_verify_connect (host, event, peer, command); + if (enet_protocol_handle_verify_connect (host, event, peer, command)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_DISCONNECT: - enet_protocol_handle_disconnect (host, peer, command); + if (enet_protocol_handle_disconnect (host, peer, command)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_PING: - enet_protocol_handle_ping (host, peer, command); + if (enet_protocol_handle_ping (host, peer, command)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_SEND_RELIABLE: - enet_protocol_handle_send_reliable (host, peer, command); + if (enet_protocol_handle_send_reliable (host, peer, command, & currentData)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE: - enet_protocol_handle_send_unreliable (host, peer, command); + if (enet_protocol_handle_send_unreliable (host, peer, command, & currentData)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED: - enet_protocol_handle_send_unsequenced (host, peer, command); + if (enet_protocol_handle_send_unsequenced (host, peer, command, & currentData)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT: - enet_protocol_handle_send_fragment (host, peer, command); + if (enet_protocol_handle_send_fragment (host, peer, command, & currentData)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT: - enet_protocol_handle_bandwidth_limit (host, peer, command); + if (enet_protocol_handle_bandwidth_limit (host, peer, command)) + goto commandError; break; case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE: - enet_protocol_handle_throttle_configure (host, peer, command); + if (enet_protocol_handle_throttle_configure (host, peer, command)) + goto commandError; break; default: - break; + goto commandError; } if (peer != NULL && - (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) != 0) + (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: break; case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT: - if (command -> header.command != ENET_PROTOCOL_COMMAND_DISCONNECT) - break; + 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, header -> sentTime); + enet_peer_queue_acknowledgement (peer, command, sentTime); break; } } } +commandError: if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE) return 1; @@ -848,7 +956,11 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer) if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] || buffer >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] || peer -> mtu - host -> packetSize < sizeof (ENetProtocolAcknowledge)) - break; + { + host -> continueSending = 1; + + break; + } acknowledgement = (ENetAcknowledgement *) currentAcknowledgement; @@ -861,12 +973,10 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer) command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE; command -> header.channelID = acknowledgement -> command.header.channelID; - command -> header.flags = 0; - command -> header.commandLength = ENET_HOST_TO_NET_32 (sizeof (ENetProtocolAcknowledge)); - command -> acknowledge.receivedReliableSequenceNumber = ENET_HOST_TO_NET_32 (acknowledgement -> command.header.reliableSequenceNumber); - command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_32 (acknowledgement -> sentTime); + command -> acknowledge.receivedReliableSequenceNumber = ENET_HOST_TO_NET_16 (acknowledgement -> command.header.reliableSequenceNumber); + command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_16 (acknowledgement -> sentTime); - if (acknowledgement -> command.header.command == ENET_PROTOCOL_COMMAND_DISCONNECT) + if ((acknowledgement -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) peer -> state = ENET_PEER_STATE_ZOMBIE; enet_list_remove (& acknowledgement -> acknowledgementList); @@ -892,15 +1002,21 @@ enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * pee 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 < outgoingCommand -> command.header.commandLength || + peer -> mtu - host -> packetSize < commandSize || (outgoingCommand -> packet != NULL && - peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength + - outgoingCommand -> packet -> dataLength)) - break; + peer -> mtu - host -> packetSize < commandSize + outgoingCommand -> packet -> dataLength)) + { + host -> continueSending = 1; + + break; + } currentCommand = enet_list_next (currentCommand); @@ -924,7 +1040,7 @@ enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * pee } buffer -> data = command; - buffer -> dataLength = outgoingCommand -> command.header.commandLength; + buffer -> dataLength = commandSize; host -> packetSize += buffer -> dataLength; @@ -939,8 +1055,6 @@ enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * pee buffer -> data = outgoingCommand -> packet -> data; buffer -> dataLength = outgoingCommand -> packet -> dataLength; - command -> header.commandLength += buffer -> dataLength; - host -> packetSize += buffer -> dataLength; enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand); @@ -948,14 +1062,18 @@ enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * pee else enet_free (outgoingCommand); - command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength); - ++ 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 -> disconnectData); } static int @@ -1000,7 +1118,7 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even enet_list_remove (& outgoingCommand -> outgoingCommandList)); if (currentCommand == enet_list_begin (& peer -> sentReliableCommands) && - enet_list_empty (& peer -> sentReliableCommands) == 0) + ! enet_list_empty (& peer -> sentReliableCommands)) { outgoingCommand = (ENetOutgoingCommand *) currentCommand; @@ -1023,22 +1141,33 @@ enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer) while (currentCommand != enet_list_end (& peer -> outgoingReliableCommands)) { - outgoingCommand = (ENetOutgoingCommand *) currentCommand; + 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 < outgoingCommand -> command.header.commandLength) - break; + peer -> mtu - host -> packetSize < commandSize) + { + host -> continueSending = 1; + + break; + } currentCommand = enet_list_next (currentCommand); if (outgoingCommand -> packet != NULL) { - if ((enet_uint16) (peer -> mtu - host -> packetSize) < - (enet_uint16) (outgoingCommand -> command.header.commandLength + - outgoingCommand -> fragmentLength) || - peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > peer -> windowSize) + if (peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > peer -> windowSize) break; + + if ((enet_uint16) (peer -> mtu - host -> packetSize) < (enet_uint16) (commandSize + outgoingCommand -> fragmentLength)) + { + host -> continueSending = 1; + + break; + } } if (outgoingCommand -> roundTripTimeout == 0) @@ -1056,9 +1185,10 @@ enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer) outgoingCommand -> sentTime = timeCurrent; buffer -> data = command; - buffer -> dataLength = outgoingCommand -> command.header.commandLength; + buffer -> dataLength = commandSize; host -> packetSize += buffer -> dataLength; + host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME; * command = outgoingCommand -> command; @@ -1069,15 +1199,11 @@ enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer) buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset; buffer -> dataLength = outgoingCommand -> fragmentLength; - command -> header.commandLength += outgoingCommand -> fragmentLength; - host -> packetSize += outgoingCommand -> fragmentLength; peer -> reliableDataInTransit += outgoingCommand -> fragmentLength; } - command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength); - ++ peer -> packetsSent; ++ command; @@ -1091,14 +1217,15 @@ enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer) static int enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int checkForTimeouts) { - size_t packetsSent = 1; ENetProtocolHeader header; ENetPeer * currentPeer; int sentLength; - while (packetsSent > 0) - for (currentPeer = host -> peers, - packetsSent = 0; + host -> continueSending = 1; + + while (host -> continueSending) + for (host -> continueSending = 0, + currentPeer = host -> peers; currentPeer < & host -> peers [host -> peerCount]; ++ currentPeer) { @@ -1106,22 +1233,21 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch 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) == 0) + if (! enet_list_empty (& currentPeer -> acknowledgements)) enet_protocol_send_acknowledgements (host, currentPeer); - - if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol)) - { - if (checkForTimeouts != 0 && - enet_list_empty (& currentPeer -> sentReliableCommands) == 0 && - ENET_TIME_GREATER_EQUAL (timeCurrent, currentPeer -> nextTimeout) && - enet_protocol_check_timeouts (host, currentPeer, event) == 1) - return 1; - } - if (enet_list_empty (& currentPeer -> outgoingReliableCommands) == 0) + + if (checkForTimeouts != 0 && + ! enet_list_empty (& currentPeer -> sentReliableCommands) && + ENET_TIME_GREATER_EQUAL (timeCurrent, currentPeer -> nextTimeout) && + enet_protocol_check_timeouts (host, currentPeer, event) == 1) + return 1; + + if (! enet_list_empty (& currentPeer -> outgoingReliableCommands)) enet_protocol_send_reliable_outgoing_commands (host, currentPeer); else if (enet_list_empty (& currentPeer -> sentReliableCommands) && @@ -1132,8 +1258,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch enet_protocol_send_reliable_outgoing_commands (host, currentPeer); } - if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol) && - enet_list_empty (& currentPeer -> outgoingUnreliableCommands) == 0) + if (! enet_list_empty (& currentPeer -> outgoingUnreliableCommands)) enet_protocol_send_unreliable_outgoing_commands (host, currentPeer); if (host -> commandCount == 0) @@ -1174,19 +1299,25 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch currentPeer -> packetsLost = 0; } - header.peerID = ENET_HOST_TO_NET_16 (currentPeer -> outgoingPeerID); - header.flags = 0; - header.commandCount = host -> commandCount; - header.sentTime = ENET_HOST_TO_NET_32 (timeCurrent); - header.challenge = currentPeer -> challenge; - + header.checksum = currentPeer -> sessionID; + header.peerID = ENET_HOST_TO_NET_16 (currentPeer -> outgoingPeerID | host -> headerFlags); + host -> buffers -> data = & header; - host -> buffers -> dataLength = sizeof (ENetProtocolHeader); + if (host -> headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) + { + header.sentTime = ENET_HOST_TO_NET_16 (timeCurrent & 0xFFFF); + + host -> buffers -> dataLength = sizeof (ENetProtocolHeader); + } + else + host -> buffers -> dataLength = (size_t) & ((ENetProtocolHeader *) 0) -> sentTime; + +#ifdef USE_CRC32 + header.checksum = enet_crc32 (host -> buffers, host -> bufferCount); +#endif currentPeer -> lastSendTime = timeCurrent; - ++ packetsSent; - sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount); enet_protocol_remove_sent_unreliable_commands (currentPeer); diff --git a/unix.c b/unix.c index 3772fef..75385a8 100644 --- a/unix.c +++ b/unix.c @@ -80,7 +80,7 @@ enet_address_set_host (ENetAddress * address, const char * name) char buffer [2048]; int errnum; -#ifdef linux +#if defined(linux) || defined(FREEBSD) gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum); #else hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum); @@ -118,7 +118,7 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng in.s_addr = address -> host; -#ifdef linux +#if defined(linux) || defined(FREEBSD) 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); @@ -153,6 +153,7 @@ enet_socket_create (ENetSocketType type, const ENetAddress * address) { ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0); int receiveBufferSize = ENET_HOST_RECEIVE_BUFFER_SIZE, + sendBufferSize = ENET_HOST_SEND_BUFFER_SIZE, allowBroadcasting = 1; #ifndef HAS_FCNTL int nonBlocking = 1; @@ -171,6 +172,7 @@ enet_socket_create (ENetSocketType type, const ENetAddress * address) #endif setsockopt (newSocket, SOL_SOCKET, SO_RCVBUF, (char *) & receiveBufferSize, sizeof (int)); + setsockopt (newSocket, SOL_SOCKET, SO_SNDBUF, (char *) & sendBufferSize, sizeof (int)); setsockopt (newSocket, SOL_SOCKET, SO_BROADCAST, (char *) & allowBroadcasting, sizeof (int)); } diff --git a/win32.c b/win32.c index 2300071..8fdd746 100644 --- a/win32.c +++ b/win32.c @@ -102,6 +102,7 @@ enet_socket_create (ENetSocketType type, const ENetAddress * address) ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0); u_long nonBlocking = 1; int receiveBufferSize = ENET_HOST_RECEIVE_BUFFER_SIZE, + sendBufferSize = ENET_HOST_SEND_BUFFER_SIZE, allowBroadcasting = 1; struct sockaddr_in sin; @@ -113,6 +114,7 @@ enet_socket_create (ENetSocketType type, const ENetAddress * address) ioctlsocket (newSocket, FIONBIO, & nonBlocking); setsockopt (newSocket, SOL_SOCKET, SO_RCVBUF, (char *) & receiveBufferSize, sizeof (int)); + setsockopt (newSocket, SOL_SOCKET, SO_SNDBUF, (char *) & sendBufferSize, sizeof (int)); setsockopt (newSocket, SOL_SOCKET, SO_BROADCAST, (char *) & allowBroadcasting, sizeof (int)); }