zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-25 11:10:47 +00:00
Code Issues Projects Releases Packages Wiki Activity

Upgrade ENet library

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@4388 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx 2014-03-22 09:27:21 +00:00
parent 2177591619
commit 6baf8f96f1
12 changed files with 516 additions and 296 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
polymer/eduke32/source/enet/include/enet/enet.h
View file

@ -6,7 +6,8 @@
#define __ENET_ENET_H__ #define __ENET_ENET_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
#include <stdlib.h> #include <stdlib.h>
@ -17,23 +18,30 @@ extern "C" {
#include "enet/unix.h" #include "enet/unix.h"
#endif #endif
#ifndef UNREFERENCED_PARAMETER
# define UNREFERENCED_PARAMETER(x) x=x
#endif
#include "enet/types.h" #include "enet/types.h"
#include "enet/protocol.h" #include "enet/protocol.h"
#include "enet/list.h" #include "enet/list.h"
#include "enet/callbacks.h" #include "enet/callbacks.h"
#ifndef UNREFERENCED_PARAMETER
# define UNREFERENCED_PARAMETER(x) x=x
#endif
#define ENET_VERSION_MAJOR 1 #define ENET_VERSION_MAJOR 1
#define ENET_VERSION_MINOR 3 #define ENET_VERSION_MINOR 3
#define ENET_VERSION_PATCH 5 #define ENET_VERSION_PATCH 11
#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch)) #define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH) #define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
typedef enet_uint32 ENetVersion; typedef enet_uint32 ENetVersion;
struct _ENetHost;
struct _ENetEvent;
struct _ENetPacket;
typedef enum _ENetSocketType typedef enum _ENetSocketType
{ {
ENET_SOCKET_TYPE_STREAM = 1, ENET_SOCKET_TYPE_STREAM = 1,
@ -42,9 +50,10 @@ typedef enum _ENetSocketType
typedef enum _ENetSocketWait typedef enum _ENetSocketWait
{ {
ENET_SOCKET_WAIT_NONE = 0, ENET_SOCKET_WAIT_NONE = 0,
ENET_SOCKET_WAIT_SEND = (1 << 0), ENET_SOCKET_WAIT_SEND = (1 << 0),
ENET_SOCKET_WAIT_RECEIVE = (1 << 1) ENET_SOCKET_WAIT_RECEIVE = (1 << 1),
ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
} ENetSocketWait; } ENetSocketWait;
typedef enum _ENetSocketOption typedef enum _ENetSocketOption
@ -55,7 +64,9 @@ typedef enum _ENetSocketOption
ENET_SOCKOPT_SNDBUF = 4, ENET_SOCKOPT_SNDBUF = 4,
ENET_SOCKOPT_REUSEADDR = 5, ENET_SOCKOPT_REUSEADDR = 5,
ENET_SOCKOPT_RCVTIMEO = 6, ENET_SOCKOPT_RCVTIMEO = 6,
ENET_SOCKOPT_SNDTIMEO = 7 ENET_SOCKOPT_SNDTIMEO = 7,
ENET_SOCKOPT_ERROR = 8,
ENET_SOCKOPT_NODELAY = 9
} ENetSocketOption; } ENetSocketOption;
typedef enum _ENetSocketShutdown typedef enum _ENetSocketShutdown
@ -65,13 +76,9 @@ typedef enum _ENetSocketShutdown
ENET_SOCKET_SHUTDOWN_READ_WRITE = 2 ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
} ENetSocketShutdown; } ENetSocketShutdown;
enum #define ENET_HOST_ANY 0
{ #define ENET_HOST_BROADCAST 0xFFFFFFFFU
ENET_HOST_ANY = 0, /**< specifies the default server host */ #define ENET_PORT_ANY 0
ENET_HOST_BROADCAST = 0xFFFFFFFF, /**< specifies a subnet-wide broadcast */
ENET_PORT_ANY = 0 /**< specifies that a port should be automatically chosen */
};
/** /**
* Portable internet address structure. * Portable internet address structure.
@ -111,10 +118,12 @@ typedef enum _ENetPacketFlag
ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2), ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
/** packet will be fragmented using unreliable (instead of reliable) sends /** packet will be fragmented using unreliable (instead of reliable) sends
* if it exceeds the MTU */ * if it exceeds the MTU */
ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3) ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
/** whether the packet has been sent from all queues it has been entered into */
ENET_PACKET_FLAG_SENT = (1<<8)
} ENetPacketFlag; } ENetPacketFlag;
struct _ENetPacket;
typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *); typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
/** /**
@ -143,6 +152,7 @@ typedef struct _ENetPacket
enet_uint8 * data; /**< allocated data for packet */ enet_uint8 * data; /**< allocated data for packet */
size_t dataLength; /**< length of data */ size_t dataLength; /**< length of data */
ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */ ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
void * userData; /**< application private data, may be freely modified */
} ENetPacket; } ENetPacket;
typedef struct _ENetAcknowledgement typedef struct _ENetAcknowledgement
@ -322,6 +332,9 @@ typedef struct _ENetCompressor
/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */ /** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount); typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
/** An ENet host for communicating with peers. /** An ENet host for communicating with peers.
* *
@ -371,6 +384,10 @@ typedef struct _ENetHost
enet_uint32 totalSentPackets; /**< total UDP packets 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 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 */ enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
ENetInterceptCallback intercept; /**< callback the user can set to intercept received raw UDP packets */
size_t connectedPeers;
size_t bandwidthLimitedPeers;
size_t duplicatePeers; /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
} ENetHost; } ENetHost;
/** /**
@ -433,7 +450,7 @@ ENET_API int enet_initialize (void);
Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored. 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 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 @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
@returns 0 on success, < 0 on failure @returns 0 on success, < 0 on failure
*/ */
ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits); ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
@ -444,6 +461,12 @@ ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCall
*/ */
ENET_API void enet_deinitialize (void); ENET_API void enet_deinitialize (void);
/**
Gives the linked version of the ENet library.
@returns the version number
*/
ENET_API ENetVersion enet_linked_version (void);
/** @} */ /** @} */
/** @defgroup private ENet private implementation functions */ /** @defgroup private ENet private implementation functions */
@ -463,6 +486,7 @@ ENET_API void enet_time_set (enet_uint32);
*/ */
ENET_API ENetSocket enet_socket_create (ENetSocketType); ENET_API ENetSocket enet_socket_create (ENetSocketType);
ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *); ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
ENET_API int enet_socket_listen (ENetSocket, int); ENET_API int enet_socket_listen (ENetSocket, int);
ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *); ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *); ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
@ -470,6 +494,7 @@ ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENe
ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, 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 int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int); ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown); ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
ENET_API void enet_socket_destroy (ENetSocket); ENET_API void enet_socket_destroy (ENetSocket);
ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32); ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
@ -489,7 +514,7 @@ ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSock
*/ */
ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName); ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
/** Gives the printable form of the ip address specified in the address parameter. /** Gives the printable form of the IP address specified in the address parameter.
@param address address printed @param address address printed
@param hostName destination for name, must not be NULL @param hostName destination for name, must not be NULL
@param nameLength maximum length of hostName. @param nameLength maximum length of hostName.
@ -528,6 +553,7 @@ ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
ENET_API void enet_host_channel_limit (ENetHost *, size_t); ENET_API void enet_host_channel_limit (ENetHost *, size_t);
ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32); ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
extern void enet_host_bandwidth_throttle (ENetHost *); extern void enet_host_bandwidth_throttle (ENetHost *);
extern enet_uint32 enet_host_random_seed (void);
ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *); ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID); ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
@ -547,6 +573,8 @@ extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const
extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16); extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *); extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *); extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
extern void enet_peer_on_connect (ENetPeer *);
extern void enet_peer_on_disconnect (ENetPeer *);
ENET_API void * enet_range_coder_create (void); ENET_API void * enet_range_coder_create (void);
ENET_API void enet_range_coder_destroy (void *); ENET_API void enet_range_coder_destroy (void *);

8
polymer/eduke32/source/enet/include/enet/protocol.h
View file

@ -13,7 +13,7 @@ enum
ENET_PROTOCOL_MAXIMUM_MTU = 4096, ENET_PROTOCOL_MAXIMUM_MTU = 4096,
ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32, ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096, ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096,
ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 32768, ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 65536,
ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1, ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1,
ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255, ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255,
ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF, ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF,
@ -54,10 +54,10 @@ typedef enum _ENetProtocolFlag
ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12 ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12
} ENetProtocolFlag; } ENetProtocolFlag;
#ifdef _MSC_VER_ #ifdef _MSC_VER
#pragma pack(push, 1) #pragma pack(push, 1)
#define ENET_PACKED #define ENET_PACKED
#elif defined(__GNUC__) #elif defined(__GNUC__) || defined(__clang__)
#define ENET_PACKED __attribute__ ((packed)) #define ENET_PACKED __attribute__ ((packed))
#else #else
#define ENET_PACKED #define ENET_PACKED
@ -191,7 +191,7 @@ typedef union _ENetProtocol
ENetProtocolThrottleConfigure throttleConfigure; ENetProtocolThrottleConfigure throttleConfigure;
} ENET_PACKED ENetProtocol; } ENET_PACKED ENetProtocol;
#ifdef _MSC_VER_ #ifdef _MSC_VER
#pragma pack(pop) #pragma pack(pop)
#endif #endif

16
polymer/eduke32/source/enet/include/enet/unix.h
View file

@ -8,21 +8,21 @@
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h>
#if defined(GEKKO) #if defined(GEKKO)
# include <network.h> # include <network.h>
#else #else
# include <netinet/in.h> #include <netinet/in.h>
#endif #endif
#include <unistd.h> #include <unistd.h>
#ifdef MSG_MAXIOVLEN
#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
#endif
typedef int ENetSocket; typedef int ENetSocket;
enum #define ENET_SOCKET_NULL -1
{
ENET_SOCKET_NULL = -1
};
#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */ #define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */ #define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
@ -44,7 +44,7 @@ typedef fd_set ENetSocketSet;
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset)) #define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset)) #define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset)) #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset)) #define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
#endif /* __ENET_UNIX_H__ */ #endif /* __ENET_UNIX_H__ */

15
polymer/eduke32/source/enet/include/enet/win32.h
View file

@ -5,12 +5,12 @@
#ifndef __ENET_WIN32_H__ #ifndef __ENET_WIN32_H__
#define __ENET_WIN32_H__ #define __ENET_WIN32_H__
#ifdef ENET_BUILDING_LIB
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning (disable: 4996) // 'strncpy' was declared deprecated #ifdef ENET_BUILDING_LIB
#pragma warning (disable: 4267) // size_t to int conversion #pragma warning (disable: 4267) // size_t to int conversion
#pragma warning (disable: 4244) // 64bit to 32bit int #pragma warning (disable: 4244) // 64bit to 32bit int
#pragma warning (disable: 4018) // signed/unsigned mismatch #pragma warning (disable: 4018) // signed/unsigned mismatch
#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
#endif #endif
#endif #endif
@ -19,10 +19,7 @@
typedef SOCKET ENetSocket; typedef SOCKET ENetSocket;
enum #define ENET_SOCKET_NULL INVALID_SOCKET
{
ENET_SOCKET_NULL = INVALID_SOCKET
};
#define ENET_HOST_TO_NET_16(value) (htons (value)) #define ENET_HOST_TO_NET_16(value) (htons (value))
#define ENET_HOST_TO_NET_32(value) (htonl (value)) #define ENET_HOST_TO_NET_32(value) (htonl (value))
@ -38,8 +35,8 @@ typedef struct
#define ENET_CALLBACK __cdecl #define ENET_CALLBACK __cdecl
#if defined ENET_DLL #ifdef ENET_DLL
#if defined ENET_BUILDING_LIB #ifdef ENET_BUILDING_LIB
#define ENET_API __declspec( dllexport ) #define ENET_API __declspec( dllexport )
#else #else
#define ENET_API __declspec( dllimport ) #define ENET_API __declspec( dllimport )
@ -52,7 +49,7 @@ typedef fd_set ENetSocketSet;
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset)) #define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset)) #define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset)) #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset)) #define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
#endif /* __ENET_WIN32_H__ */ #endif /* __ENET_WIN32_H__ */

6
polymer/eduke32/source/enet/src/callbacks.c
View file

@ -27,6 +27,12 @@ enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits
return enet_initialize (); return enet_initialize ();
} }
ENetVersion
enet_linked_version (void)
{
return ENET_VERSION;
}
void * void *
enet_malloc (size_t size) enet_malloc (size_t size)

4
polymer/eduke32/source/enet/src/compress.c
View file

@ -128,7 +128,7 @@ enet_symbol_rescale (ENetSymbol * symbol)
if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \ if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
{ \ { \
if(encodeRange >= ENET_RANGE_CODER_BOTTOM) break; \ if(encodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
encodeRange = -(signed)encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \ encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
} \ } \
ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \ ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \
encodeRange <<= 8; \ encodeRange <<= 8; \
@ -360,7 +360,7 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
if((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \ if((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \
{ \ { \
if(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \ if(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
decodeRange = -(signed)decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \ decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
} \ } \
decodeCode <<= 8; \ decodeCode <<= 8; \
if (inData < inEnd) \ if (inData < inEnd) \

103
polymer/eduke32/source/enet/src/host.c
View file

@ -3,9 +3,7 @@
@brief ENet host management functions @brief ENet host management functions
*/ */
#define ENET_BUILDING_LIB 1 #define ENET_BUILDING_LIB 1
#define __MINGW_USE_VC2005_COMPAT 1
#include <string.h> #include <string.h>
#include <time.h>
#include "enet/enet.h" #include "enet/enet.h"
/** @defgroup host ENet host functions /** @defgroup host ENet host functions
@ -67,7 +65,7 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE); enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE); enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
if (address != NULL) if (address != NULL && enet_socket_get_address (host -> socket, & host -> address) < 0)
host -> address = * address; host -> address = * address;
if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
@ -76,7 +74,8 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT; channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
host -> randomSeed = (enet_uint32) time(NULL) + (enet_uint32) (size_t) host; host -> randomSeed = (enet_uint32) (size_t) host;
host -> randomSeed += enet_host_random_seed ();
host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16); host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16);
host -> channelLimit = channelLimit; host -> channelLimit = channelLimit;
host -> incomingBandwidth = incomingBandwidth; host -> incomingBandwidth = incomingBandwidth;
@ -98,11 +97,17 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
host -> totalReceivedData = 0; host -> totalReceivedData = 0;
host -> totalReceivedPackets = 0; host -> totalReceivedPackets = 0;
host -> connectedPeers = 0;
host -> bandwidthLimitedPeers = 0;
host -> duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID;
host -> compressor.context = NULL; host -> compressor.context = NULL;
host -> compressor.compress = NULL; host -> compressor.compress = NULL;
host -> compressor.decompress = NULL; host -> compressor.decompress = NULL;
host -> compressor.destroy = NULL; host -> compressor.destroy = NULL;
host -> intercept = NULL;
enet_list_clear (& host -> dispatchQueue); enet_list_clear (& host -> dispatchQueue);
for (currentPeer = host -> peers; for (currentPeer = host -> peers;
@ -322,46 +327,44 @@ enet_host_bandwidth_throttle (ENetHost * host)
{ {
enet_uint32 timeCurrent = enet_time_get (), enet_uint32 timeCurrent = enet_time_get (),
elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch, elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
peersTotal = 0, peersRemaining = (enet_uint32) host -> connectedPeers,
dataTotal = 0, dataTotal = ~0,
peersRemaining, bandwidth = ~0,
bandwidth,
throttle = 0, throttle = 0,
bandwidthLimit = 0; bandwidthLimit = 0;
int needsAdjustment; int needsAdjustment = host -> bandwidthLimitedPeers > 0 ? 1 : 0;
ENetPeer * peer; ENetPeer * peer;
ENetProtocol command; ENetProtocol command;
if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
return; return;
for (peer = host -> peers; host -> bandwidthThrottleEpoch = timeCurrent;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
continue;
++ peersTotal; if (peersRemaining == 0)
dataTotal += peer -> outgoingDataTotal;
}
if (peersTotal == 0)
return; return;
peersRemaining = peersTotal; if (host -> outgoingBandwidth != 0)
needsAdjustment = 1; {
dataTotal = 0;
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
if (host -> outgoingBandwidth == 0) for (peer = host -> peers;
bandwidth = ~0; peer < & host -> peers [host -> peerCount];
else ++ peer)
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000; {
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
continue;
dataTotal += peer -> outgoingDataTotal;
}
}
while (peersRemaining > 0 && needsAdjustment != 0) while (peersRemaining > 0 && needsAdjustment != 0)
{ {
needsAdjustment = 0; needsAdjustment = 0;
if (dataTotal < bandwidth) if (dataTotal <= bandwidth)
throttle = ENET_PEER_PACKET_THROTTLE_SCALE; throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
else else
throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal; throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
@ -392,7 +395,9 @@ enet_host_bandwidth_throttle (ENetHost * host)
peer -> outgoingBandwidthThrottleEpoch = timeCurrent; peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
peer -> incomingDataTotal = 0;
peer -> outgoingDataTotal = 0;
needsAdjustment = 1; needsAdjustment = 1;
-- peersRemaining; -- peersRemaining;
bandwidth -= peerBandwidth; bandwidth -= peerBandwidth;
@ -401,25 +406,35 @@ enet_host_bandwidth_throttle (ENetHost * host)
} }
if (peersRemaining > 0) if (peersRemaining > 0)
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{ {
if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || if (dataTotal <= bandwidth)
peer -> outgoingBandwidthThrottleEpoch == timeCurrent) throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
continue; else
throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
peer -> packetThrottleLimit = throttle; for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
continue;
if (peer -> packetThrottle > peer -> packetThrottleLimit) peer -> packetThrottleLimit = throttle;
peer -> packetThrottle = peer -> packetThrottleLimit;
if (peer -> packetThrottle > peer -> packetThrottleLimit)
peer -> packetThrottle = peer -> packetThrottleLimit;
peer -> incomingDataTotal = 0;
peer -> outgoingDataTotal = 0;
}
} }
if (host -> recalculateBandwidthLimits) if (host -> recalculateBandwidthLimits)
{ {
host -> recalculateBandwidthLimits = 0; host -> recalculateBandwidthLimits = 0;
peersRemaining = peersTotal; peersRemaining = (enet_uint32) host -> connectedPeers;
bandwidth = host -> incomingBandwidth; bandwidth = host -> incomingBandwidth;
needsAdjustment = 1; needsAdjustment = 1;
@ -470,16 +485,6 @@ enet_host_bandwidth_throttle (ENetHost * host)
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0); enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
} }
} }
host -> bandwidthThrottleEpoch = timeCurrent;
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
peer -> incomingDataTotal = 0;
peer -> outgoingDataTotal = 0;
}
} }
/** @} */ /** @} */

5
polymer/eduke32/source/enet/src/packet.c
View file

@ -11,7 +11,7 @@
*/ */
/** Creates a packet that may be sent to a peer. /** Creates a packet that may be sent to a peer.
@param dataContents initial contents of the packet's data; the packet's data will remain uninitialized if dataContents is NULL. @param data initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL.
@param dataLength size of the data allocated for this packet @param dataLength size of the data allocated for this packet
@param flags flags for this packet as described for the ENetPacket structure. @param flags flags for this packet as described for the ENetPacket structure.
@returns the packet on success, NULL on failure @returns the packet on success, NULL on failure
@ -45,6 +45,7 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
packet -> flags = flags; packet -> flags = flags;
packet -> dataLength = dataLength; packet -> dataLength = dataLength;
packet -> freeCallback = NULL; packet -> freeCallback = NULL;
packet -> userData = NULL;
return packet; return packet;
} }
@ -115,7 +116,7 @@ reflect_crc (int val, int bits)
} }
static void static void
initialize_crc32 () initialize_crc32 (void)
{ {
int byte; int byte;

84
polymer/eduke32/source/enet/src/peer.c
View file

@ -271,7 +271,7 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm
ENetListIterator currentCommand; ENetListIterator currentCommand;
UNREFERENCED_PARAMETER(queue); UNREFERENCED_PARAMETER(queue);
for (currentCommand = startCommand; currentCommand != endCommand; ) for (currentCommand = startCommand; currentCommand != endCommand; )
{ {
ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand; ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
@ -298,7 +298,7 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm
static void static void
enet_peer_reset_incoming_commands (ENetList * queue) enet_peer_reset_incoming_commands (ENetList * queue)
{ {
enet_peer_remove_incoming_commands(queue, enet_list_begin (queue), enet_list_end(queue)); enet_peer_remove_incoming_commands(queue, enet_list_begin (queue), enet_list_end (queue));
} }
void void
@ -339,6 +339,30 @@ enet_peer_reset_queues (ENetPeer * peer)
peer -> channelCount = 0; peer -> channelCount = 0;
} }
void
enet_peer_on_connect (ENetPeer * peer)
{
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
{
if (peer -> incomingBandwidth != 0)
++ peer -> host -> bandwidthLimitedPeers;
++ peer -> host -> connectedPeers;
}
}
void
enet_peer_on_disconnect (ENetPeer * peer)
{
if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
{
if (peer -> incomingBandwidth != 0)
-- peer -> host -> bandwidthLimitedPeers;
-- peer -> host -> connectedPeers;
}
}
/** Forcefully disconnects a peer. /** Forcefully disconnects a peer.
@param peer peer to forcefully disconnect @param peer peer to forcefully disconnect
@remarks The foreign host represented by the peer is not notified of the disconnection and will timeout @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
@ -347,6 +371,8 @@ enet_peer_reset_queues (ENetPeer * peer)
void void
enet_peer_reset (ENetPeer * peer) enet_peer_reset (ENetPeer * peer)
{ {
enet_peer_on_disconnect (peer);
peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID; peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
peer -> connectID = 0; peer -> connectID = 0;
@ -400,7 +426,7 @@ enet_peer_reset (ENetPeer * peer)
/** Sends a ping request to a peer. /** Sends a ping request to a peer.
@param peer destination for the ping request @param peer destination for the ping request
@remarks ping requests factor into the mean round trip time as designated by the @remarks ping requests factor into the mean round trip time as designated by the
roundTripTime field in the ENetPeer structure. Enet automatically pings all connected roundTripTime field in the ENetPeer structure. ENet automatically pings all connected
peers at regular intervals, however, this function may be called to ensure more peers at regular intervals, however, this function may be called to ensure more
frequent ping requests. frequent ping requests.
*/ */
@ -430,7 +456,7 @@ enet_peer_ping (ENetPeer * peer)
void void
enet_peer_ping_interval (ENetPeer * peer, enet_uint32 pingInterval) enet_peer_ping_interval (ENetPeer * peer, enet_uint32 pingInterval)
{ {
peer -> pingInterval = pingInterval ? pingInterval : (enet_uint32)ENET_PEER_PING_INTERVAL; peer -> pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
} }
/** Sets the timeout parameters for a peer. /** Sets the timeout parameters for a peer.
@ -453,16 +479,16 @@ enet_peer_ping_interval (ENetPeer * peer, enet_uint32 pingInterval)
void void
enet_peer_timeout (ENetPeer * peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum) enet_peer_timeout (ENetPeer * peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum)
{ {
peer -> timeoutLimit = timeoutLimit ? timeoutLimit : (enet_uint32)ENET_PEER_TIMEOUT_LIMIT; peer -> timeoutLimit = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
peer -> timeoutMinimum = timeoutMinimum ? timeoutMinimum : (enet_uint32)ENET_PEER_TIMEOUT_MINIMUM; peer -> timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
peer -> timeoutMaximum = timeoutMaximum ? timeoutMaximum : (enet_uint32)ENET_PEER_TIMEOUT_MAXIMUM; peer -> timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
} }
/** Force an immediate disconnection from a peer. /** Force an immediate disconnection from a peer.
@param peer peer to disconnect @param peer peer to disconnect
@param data data describing the disconnection @param data data describing the disconnection
@remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not @remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
guarenteed to receive the disconnect notification, and is reset immediately upon guaranteed to receive the disconnect notification, and is reset immediately upon
return from this function. return from this function.
*/ */
void void
@ -521,7 +547,11 @@ enet_peer_disconnect (ENetPeer * peer, enet_uint32 data)
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0); enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
peer -> state = ENET_PEER_STATE_DISCONNECTING; {
enet_peer_on_disconnect (peer);
peer -> state = ENET_PEER_STATE_DISCONNECTING;
}
else else
{ {
enet_host_flush (peer -> host); enet_host_flush (peer -> host);
@ -586,7 +616,7 @@ void
enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoingCommand) enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoingCommand)
{ {
ENetChannel * channel = & peer -> channels [outgoingCommand -> command.header.channelID]; ENetChannel * channel = & peer -> channels [outgoingCommand -> command.header.channelID];
peer -> outgoingDataTotal += enet_protocol_command_size (outgoingCommand -> command.header.command) + outgoingCommand -> fragmentLength; peer -> outgoingDataTotal += enet_protocol_command_size (outgoingCommand -> command.header.command) + outgoingCommand -> fragmentLength;
if (outgoingCommand -> command.header.channelID == 0xFF) if (outgoingCommand -> command.header.channelID == 0xFF)
@ -683,9 +713,9 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
if (incomingCommand -> reliableSequenceNumber == channel -> incomingReliableSequenceNumber) if (incomingCommand -> reliableSequenceNumber == channel -> incomingReliableSequenceNumber)
{ {
if (incomingCommand -> fragmentsRemaining <= 0) if (incomingCommand -> fragmentsRemaining <= 0)
{ {
channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber; channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber;
continue; continue;
} }
@ -702,11 +732,11 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
droppedCommand = currentCommand; droppedCommand = currentCommand;
} }
else else
if (droppedCommand != currentCommand) if (droppedCommand != currentCommand)
droppedCommand = enet_list_previous (currentCommand); droppedCommand = enet_list_previous (currentCommand);
} }
else else
{ {
enet_uint16 reliableWindow = incomingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE, enet_uint16 reliableWindow = incomingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE; currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
@ -719,30 +749,30 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
if (startCommand != currentCommand) if (startCommand != currentCommand)
{ {
enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand)); enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));
if (! peer -> needsDispatch) if (! peer -> needsDispatch)
{ {
enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList); enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
peer -> needsDispatch = 1; peer -> needsDispatch = 1;
} }
}
} }
}
startCommand = enet_list_next (currentCommand); startCommand = enet_list_next (currentCommand);
} }
if (startCommand != currentCommand) if (startCommand != currentCommand)
{ {
enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand)); enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));
if (! peer -> needsDispatch) if (! peer -> needsDispatch)
{ {
enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList); enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
peer -> needsDispatch = 1; peer -> needsDispatch = 1;
} }
droppedCommand = currentCommand; droppedCommand = currentCommand;
} }
@ -786,7 +816,7 @@ enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * ch
} }
if (! enet_list_empty (& channel -> incomingUnreliableCommands)) if (! enet_list_empty (& channel -> incomingUnreliableCommands))
enet_peer_dispatch_incoming_unreliable_commands (peer, channel); enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
} }
ENetIncomingCommand * ENetIncomingCommand *

271
polymer/eduke32/source/enet/src/protocol.c
View file

@ -32,6 +32,32 @@ enet_protocol_command_size (enet_uint8 commandNumber)
return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK]; return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK];
} }
static void
enet_protocol_change_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
{
UNREFERENCED_PARAMETER(host);
if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER)
enet_peer_on_connect (peer);
else
enet_peer_on_disconnect (peer);
peer -> state = state;
}
static void
enet_protocol_dispatch_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
{
enet_protocol_change_state (host, peer, state);
if (! peer -> needsDispatch)
{
enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);
peer -> needsDispatch = 1;
}
}
static int static int
enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event) enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
{ {
@ -45,7 +71,7 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
{ {
case ENET_PEER_STATE_CONNECTION_PENDING: case ENET_PEER_STATE_CONNECTION_PENDING:
case ENET_PEER_STATE_CONNECTION_SUCCEEDED: case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
peer -> state = ENET_PEER_STATE_CONNECTED; enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
event -> type = ENET_EVENT_TYPE_CONNECT; event -> type = ENET_EVENT_TYPE_CONNECT;
event -> peer = peer; event -> peer = peer;
@ -92,19 +118,6 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
return 0; 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 static void
enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event) enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
{ {
@ -112,7 +125,7 @@ enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * even
if (event != NULL) if (event != NULL)
{ {
peer -> state = ENET_PEER_STATE_CONNECTED; enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
event -> type = ENET_EVENT_TYPE_CONNECT; event -> type = ENET_EVENT_TYPE_CONNECT;
event -> peer = peer; event -> peer = peer;
@ -163,7 +176,11 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
-- outgoingCommand -> packet -> referenceCount; -- outgoingCommand -> packet -> referenceCount;
if (outgoingCommand -> packet -> referenceCount == 0) if (outgoingCommand -> packet -> referenceCount == 0)
enet_packet_destroy (outgoingCommand -> packet); {
outgoingCommand -> packet -> flags |= ENET_PACKET_FLAG_SENT;
enet_packet_destroy (outgoingCommand -> packet);
}
} }
enet_free (outgoingCommand); enet_free (outgoingCommand);
@ -237,7 +254,11 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliabl
-- outgoingCommand -> packet -> referenceCount; -- outgoingCommand -> packet -> referenceCount;
if (outgoingCommand -> packet -> referenceCount == 0) if (outgoingCommand -> packet -> referenceCount == 0)
enet_packet_destroy (outgoingCommand -> packet); {
outgoingCommand -> packet -> flags |= ENET_PACKET_FLAG_SENT;
enet_packet_destroy (outgoingCommand -> packet);
}
} }
enet_free (outgoingCommand); enet_free (outgoingCommand);
@ -258,8 +279,8 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
enet_uint8 incomingSessionID, outgoingSessionID; enet_uint8 incomingSessionID, outgoingSessionID;
enet_uint32 mtu, windowSize; enet_uint32 mtu, windowSize;
ENetChannel * channel; ENetChannel * channel;
size_t channelCount; size_t channelCount, duplicatePeers = 0;
ENetPeer * currentPeer; ENetPeer * currentPeer, * peer = NULL;
ENetProtocol verifyCommand; ENetProtocol verifyCommand;
UNREFERENCED_PARAMETER(header); UNREFERENCED_PARAMETER(header);
@ -270,59 +291,61 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
return NULL; return NULL;
for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount];
++ currentPeer)
{
if (currentPeer -> state != ENET_PEER_STATE_DISCONNECTED &&
currentPeer -> address.host == host -> receivedAddress.host &&
currentPeer -> address.port == host -> receivedAddress.port &&
currentPeer -> connectID == command -> connect.connectID)
return NULL;
}
for (currentPeer = host -> peers; for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount]; currentPeer < & host -> peers [host -> peerCount];
++ currentPeer) ++ currentPeer)
{ {
if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED) if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
break; {
if (peer == NULL)
peer = currentPeer;
}
else
if (currentPeer -> state != ENET_PEER_STATE_CONNECTING &&
currentPeer -> address.host == host -> receivedAddress.host)
{
if (currentPeer -> address.port == host -> receivedAddress.port &&
currentPeer -> connectID == command -> connect.connectID)
return NULL;
++ duplicatePeers;
}
} }
if (currentPeer >= & host -> peers [host -> peerCount]) if (peer == NULL || duplicatePeers >= host -> duplicatePeers)
return NULL; return NULL;
if (channelCount > host -> channelLimit) if (channelCount > host -> channelLimit)
channelCount = host -> channelLimit; channelCount = host -> channelLimit;
currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); peer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
if (currentPeer -> channels == NULL) if (peer -> channels == NULL)
return NULL; return NULL;
currentPeer -> channelCount = channelCount; peer -> channelCount = channelCount;
currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT; peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
currentPeer -> connectID = command -> connect.connectID; peer -> connectID = command -> connect.connectID;
currentPeer -> address = host -> receivedAddress; peer -> address = host -> receivedAddress;
currentPeer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID); peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
currentPeer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth); peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
currentPeer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth); peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
currentPeer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval); peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);
currentPeer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration); peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);
currentPeer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration); peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);
currentPeer -> eventData = ENET_NET_TO_HOST_32 (command -> connect.data); peer -> eventData = ENET_NET_TO_HOST_32 (command -> connect.data);
incomingSessionID = command -> connect.incomingSessionID == 0xFF ? currentPeer -> outgoingSessionID : command -> connect.incomingSessionID; incomingSessionID = command -> connect.incomingSessionID == 0xFF ? peer -> outgoingSessionID : command -> connect.incomingSessionID;
incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT); incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
if (incomingSessionID == currentPeer -> outgoingSessionID) if (incomingSessionID == peer -> outgoingSessionID)
incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT); incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
currentPeer -> outgoingSessionID = incomingSessionID; peer -> outgoingSessionID = incomingSessionID;
outgoingSessionID = command -> connect.outgoingSessionID == 0xFF ? currentPeer -> incomingSessionID : command -> connect.outgoingSessionID; outgoingSessionID = command -> connect.outgoingSessionID == 0xFF ? peer -> incomingSessionID : command -> connect.outgoingSessionID;
outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT); outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
if (outgoingSessionID == currentPeer -> incomingSessionID) if (outgoingSessionID == peer -> incomingSessionID)
outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT); outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
currentPeer -> incomingSessionID = outgoingSessionID; peer -> incomingSessionID = outgoingSessionID;
for (channel = currentPeer -> channels; for (channel = peer -> channels;
channel < & currentPeer -> channels [channelCount]; channel < & peer -> channels [channelCount];
++ channel) ++ channel)
{ {
channel -> outgoingReliableSequenceNumber = 0; channel -> outgoingReliableSequenceNumber = 0;
@ -345,27 +368,27 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
mtu = ENET_PROTOCOL_MAXIMUM_MTU; mtu = ENET_PROTOCOL_MAXIMUM_MTU;
currentPeer -> mtu = mtu; peer -> mtu = mtu;
if (host -> outgoingBandwidth == 0 && if (host -> outgoingBandwidth == 0 &&
currentPeer -> incomingBandwidth == 0) peer -> incomingBandwidth == 0)
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
else else
if (host -> outgoingBandwidth == 0 || if (host -> outgoingBandwidth == 0 ||
currentPeer -> incomingBandwidth == 0) peer -> incomingBandwidth == 0)
currentPeer -> windowSize = (ENET_MAX (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) / peer -> windowSize = (ENET_MAX (host -> outgoingBandwidth, peer -> incomingBandwidth) /
ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PEER_WINDOW_SIZE_SCALE) *
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
else else
currentPeer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) / peer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, peer -> incomingBandwidth) /
ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PEER_WINDOW_SIZE_SCALE) *
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
else else
if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
if (host -> incomingBandwidth == 0) if (host -> incomingBandwidth == 0)
windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
@ -384,22 +407,22 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
verifyCommand.header.channelID = 0xFF; verifyCommand.header.channelID = 0xFF;
verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID); verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (peer -> incomingPeerID);
verifyCommand.verifyConnect.incomingSessionID = incomingSessionID; verifyCommand.verifyConnect.incomingSessionID = incomingSessionID;
verifyCommand.verifyConnect.outgoingSessionID = outgoingSessionID; verifyCommand.verifyConnect.outgoingSessionID = outgoingSessionID;
verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_32 (currentPeer -> mtu); verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_32 (peer -> mtu);
verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize); verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize);
verifyCommand.verifyConnect.channelCount = ENET_HOST_TO_NET_32 (channelCount); verifyCommand.verifyConnect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth); verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth); verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval); verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (peer -> packetThrottleInterval);
verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration); verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleAcceleration);
verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration); verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleDeceleration);
verifyCommand.verifyConnect.connectID = currentPeer -> connectID; verifyCommand.verifyConnect.connectID = peer -> connectID;
enet_peer_queue_outgoing_command (currentPeer, & verifyCommand, NULL, 0, 0); enet_peer_queue_outgoing_command (peer, & verifyCommand, NULL, 0, 0);
return currentPeer; return peer;
} }
static int static int
@ -745,20 +768,29 @@ static int
enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
{ {
UNREFERENCED_PARAMETER(host); UNREFERENCED_PARAMETER(host);
UNREFERENCED_PARAMETER(peer);
UNREFERENCED_PARAMETER(command); UNREFERENCED_PARAMETER(command);
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
return -1;
return 0; return 0;
} }
static int static int
enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
{ {
UNREFERENCED_PARAMETER(host); if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
return -1;
if (peer -> incomingBandwidth != 0)
-- host -> bandwidthLimitedPeers;
peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.incomingBandwidth); peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.incomingBandwidth);
peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth); peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth);
if (peer -> incomingBandwidth != 0)
++ host -> bandwidthLimitedPeers;
if (peer -> incomingBandwidth == 0 && host -> outgoingBandwidth == 0) if (peer -> incomingBandwidth == 0 && host -> outgoingBandwidth == 0)
peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
else else
@ -779,6 +811,9 @@ enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const
{ {
UNREFERENCED_PARAMETER(host); UNREFERENCED_PARAMETER(host);
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
return -1;
peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleInterval); peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleInterval);
peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration); peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration);
peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleDeceleration); peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleDeceleration);
@ -789,12 +824,12 @@ enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const
static int static int
enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command) enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
{ {
if (peer -> state == ENET_PEER_STATE_ZOMBIE || peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT) if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE || peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT)
return 0; return 0;
enet_peer_reset_queues (peer); enet_peer_reset_queues (peer);
if (peer -> state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer -> state == ENET_PEER_STATE_DISCONNECTING) if (peer -> state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer -> state == ENET_PEER_STATE_DISCONNECTING || peer -> state == ENET_PEER_STATE_CONNECTING)
enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE); enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
else else
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
@ -805,7 +840,7 @@ enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetPro
} }
else else
if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT; enet_protocol_change_state (host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
else else
enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE); enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
@ -823,6 +858,9 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer *
receivedReliableSequenceNumber; receivedReliableSequenceNumber;
ENetProtocolCommand commandNumber; ENetProtocolCommand commandNumber;
if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE)
return 0;
receivedSentTime = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedSentTime); receivedSentTime = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedSentTime);
receivedSentTime |= host -> serviceTime & 0xFFFF0000; receivedSentTime |= host -> serviceTime & 0xFFFF0000;
if ((receivedSentTime & 0x8000) > (host -> serviceTime & 0x8000)) if ((receivedSentTime & 0x8000) > (host -> serviceTime & 0x8000))
@ -1075,7 +1113,7 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> header.reliableSequenceNumber); command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> header.reliableSequenceNumber);
switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK) switch (commandNumber)
{ {
case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE: case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
if (enet_protocol_handle_acknowledge (host, event, peer, command)) if (enet_protocol_handle_acknowledge (host, event, peer, command))
@ -1083,6 +1121,8 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
break; break;
case ENET_PROTOCOL_COMMAND_CONNECT: case ENET_PROTOCOL_COMMAND_CONNECT:
if (peer != NULL)
goto commandError;
peer = enet_protocol_handle_connect (host, header, command); peer = enet_protocol_handle_connect (host, header, command);
if (peer == NULL) if (peer == NULL)
goto commandError; goto commandError;
@ -1156,6 +1196,8 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
{ {
case ENET_PEER_STATE_DISCONNECTING: case ENET_PEER_STATE_DISCONNECTING:
case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT: case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
case ENET_PEER_STATE_DISCONNECTED:
case ENET_PEER_STATE_ZOMBIE:
break; break;
case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT: case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
@ -1204,7 +1246,25 @@ enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
host -> totalReceivedData += receivedLength; host -> totalReceivedData += receivedLength;
host -> totalReceivedPackets ++; host -> totalReceivedPackets ++;
if (host -> intercept != NULL)
{
switch (host -> intercept (host, event))
{
case 1:
if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
return 1;
continue;
case -1:
return -1;
default:
break;
}
}
switch (enet_protocol_handle_incoming_commands (host, event)) switch (enet_protocol_handle_incoming_commands (host, event))
{ {
case 1: case 1:
@ -1228,7 +1288,8 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
ENetBuffer * buffer = & host -> buffers [host -> bufferCount]; ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
ENetAcknowledgement * acknowledgement; ENetAcknowledgement * acknowledgement;
ENetListIterator currentAcknowledgement; ENetListIterator currentAcknowledgement;
enet_uint16 reliableSequenceNumber;
currentAcknowledgement = enet_list_begin (& peer -> acknowledgements); currentAcknowledgement = enet_list_begin (& peer -> acknowledgements);
while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements)) while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements))
@ -1250,10 +1311,13 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
buffer -> dataLength = sizeof (ENetProtocolAcknowledge); buffer -> dataLength = sizeof (ENetProtocolAcknowledge);
host -> packetSize += buffer -> dataLength; host -> packetSize += buffer -> dataLength;
reliableSequenceNumber = ENET_HOST_TO_NET_16 (acknowledgement -> command.header.reliableSequenceNumber);
command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE; command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
command -> header.channelID = acknowledgement -> command.header.channelID; command -> header.channelID = acknowledgement -> command.header.channelID;
command -> acknowledge.receivedReliableSequenceNumber = ENET_HOST_TO_NET_16 (acknowledgement -> command.header.reliableSequenceNumber); command -> header.reliableSequenceNumber = reliableSequenceNumber;
command -> acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_16 (acknowledgement -> sentTime); command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_16 (acknowledgement -> sentTime);
if ((acknowledgement -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) if ((acknowledgement -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT)
@ -1613,12 +1677,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent; enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;
#ifdef ENET_DEBUG #ifdef ENET_DEBUG
#ifdef _WIN32 printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
printf (
#else
fprintf (stderr,
#endif
"peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
#endif #endif
currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4; currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;
@ -1663,12 +1722,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED; host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED;
shouldCompress = compressedSize; shouldCompress = compressedSize;
#ifdef ENET_DEBUG_COMPRESS #ifdef ENET_DEBUG_COMPRESS
#ifdef _WIN32 printf ("peer %u: compressed %u -> %u (%u%%)\n", currentPeer -> incomingPeerID, originalSize, compressedSize, (compressedSize * 100) / originalSize);
printf (
#else
fprintf (stderr,
#endif
"peer %u: compressed %u -> %u (%u%%)\n", currentPeer -> incomingPeerID, originalSize, compressedSize, (compressedSize * 100) / originalSize);
#endif #endif
} }
} }
@ -1772,7 +1826,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
return 1; return 1;
case -1: case -1:
#ifdef ENET_DEBUG
perror ("Error dispatching incoming packets"); perror ("Error dispatching incoming packets");
#endif
return -1; return -1;
@ -1796,7 +1852,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
return 1; return 1;
case -1: case -1:
#ifdef ENET_DEBUG
perror ("Error sending outgoing packets"); perror ("Error sending outgoing packets");
#endif
return -1; return -1;
@ -1810,7 +1868,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
return 1; return 1;
case -1: case -1:
#ifdef ENET_DEBUG
perror ("Error receiving incoming packets"); perror ("Error receiving incoming packets");
#endif
return -1; return -1;
@ -1824,7 +1884,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
return 1; return 1;
case -1: case -1:
#ifdef ENET_DEBUG
perror ("Error sending outgoing packets"); perror ("Error sending outgoing packets");
#endif
return -1; return -1;
@ -1840,7 +1902,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
return 1; return 1;
case -1: case -1:
#ifdef ENET_DEBUG
perror ("Error dispatching incoming packets"); perror ("Error dispatching incoming packets");
#endif
return -1; return -1;
@ -1849,18 +1913,25 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
} }
} }
host -> serviceTime = enet_time_get ();
if (ENET_TIME_GREATER_EQUAL (host -> serviceTime, timeout)) if (ENET_TIME_GREATER_EQUAL (host -> serviceTime, timeout))
return 0; return 0;
waitCondition = ENET_SOCKET_WAIT_RECEIVE; do
{
host -> serviceTime = enet_time_get ();
if (ENET_TIME_GREATER_EQUAL (host -> serviceTime, timeout))
return 0;
waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, host -> serviceTime)) != 0)
return -1;
}
while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, host -> serviceTime)) != 0)
return -1;
host -> serviceTime = enet_time_get (); host -> serviceTime = enet_time_get ();
} while (waitCondition == ENET_SOCKET_WAIT_RECEIVE); } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
return 0; return 0;
} }

167
polymer/eduke32/source/enet/src/unix.c
View file

@ -4,45 +4,13 @@
*/ */
#ifndef _WIN32 #ifndef _WIN32
#ifndef UNREFERENCED_PARAMETER #include <sys/types.h>
#define UNREFERENCED_PARAMETER(x) x=x #include <sys/socket.h>
#endif #include <sys/ioctl.h>
#if defined(GEKKO)
# include <network.h>
# define gethostbyname net_gethostbyname
# define gethostbyaddr(...) (NULL)
# define bind net_bind
# define listen net_listen
# define socket net_socket
# define ioctl net_ioctl
# define connect net_connect
# define setsockopt net_setsockopt
# define accept net_accept
# define select net_select
# define shutdown net_shutdown
struct msghdr {
void *msg_name; /* optional address */
socklen_t msg_namelen; /* size of address */
struct iovec *msg_iov; /* scatter/gather array */
size_t msg_iovlen; /* # elements in msg_iov */
void *msg_control; /* ancillary data, see below */
socklen_t msg_controllen; /* ancillary data buffer len */
int msg_flags; /* flags on received message */
};
# define sendmsg(...) (-1)
# define recvmsg(...) (-1)
# define SOMAXCONN 5
#else
# include <sys/types.h>
# include <sys/socket.h>
# include <sys/ioctl.h>
# include <arpa/inet.h>
# include <netdb.h>
#endif
#include <sys/time.h> #include <sys/time.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <unistd.h> #include <unistd.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
@ -80,11 +48,9 @@ struct msghdr {
#include <sys/poll.h> #include <sys/poll.h>
#endif #endif
/*
#ifndef HAS_SOCKLEN_T #ifndef HAS_SOCKLEN_T
typedef int socklen_t; typedef int socklen_t;
#endif #endif
*/
#ifndef MSG_NOSIGNAL #ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0 #define MSG_NOSIGNAL 0
@ -103,6 +69,12 @@ enet_deinitialize (void)
{ {
} }
enet_uint32
enet_host_random_seed (void)
{
return (enet_uint32) time (NULL);
}
enet_uint32 enet_uint32
enet_time_get (void) enet_time_get (void)
{ {
@ -166,7 +138,12 @@ enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameL
#else #else
char * addr = inet_ntoa (* (struct in_addr *) & address -> host); char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
if (addr != NULL) if (addr != NULL)
strncpy (name, addr, nameLength); {
size_t addrLen = strlen(addr);
if (addrLen >= nameLength)
return -1;
memcpy (name, addr, addrLen + 1);
}
else else
#endif #endif
return -1; return -1;
@ -176,9 +153,8 @@ enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameL
int int
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength) enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
{ {
struct hostent * hostEntry = NULL;
#ifndef GEKKO
struct in_addr in; struct in_addr in;
struct hostent * hostEntry = NULL;
#ifdef HAS_GETHOSTBYADDR_R #ifdef HAS_GETHOSTBYADDR_R
struct hostent hostData; struct hostent hostData;
char buffer [2048]; char buffer [2048];
@ -195,13 +171,17 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
in.s_addr = address -> host; in.s_addr = address -> host;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET); hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
#endif
#endif #endif
if (hostEntry == NULL) if (hostEntry == NULL)
return enet_address_get_host_ip (address, name, nameLength); return enet_address_get_host_ip (address, name, nameLength);
else
strncpy (name, hostEntry -> h_name, nameLength); {
size_t hostLen = strlen (hostEntry -> h_name);
if (hostLen >= nameLength)
return -1;
memcpy (name, hostEntry -> h_name, hostLen + 1);
}
return 0; return 0;
} }
@ -231,6 +211,21 @@ enet_socket_bind (ENetSocket socket, const ENetAddress * address)
sizeof (struct sockaddr_in)); sizeof (struct sockaddr_in));
} }
int
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
{
struct sockaddr_in sin;
socklen_t sinLength = sizeof (struct sockaddr_in);
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
return -1;
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
return 0;
}
int int
enet_socket_listen (ENetSocket socket, int backlog) enet_socket_listen (ENetSocket socket, int backlog)
{ {
@ -274,11 +269,43 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
break; break;
case ENET_SOCKOPT_RCVTIMEO: case ENET_SOCKOPT_RCVTIMEO:
result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & value, sizeof (int)); {
struct timeval timeVal;
timeVal.tv_sec = value / 1000;
timeVal.tv_usec = (value % 1000) * 1000;
result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & timeVal, sizeof (struct timeval));
break; break;
}
case ENET_SOCKOPT_SNDTIMEO: case ENET_SOCKOPT_SNDTIMEO:
result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int)); {
struct timeval timeVal;
timeVal.tv_sec = value / 1000;
timeVal.tv_usec = (value % 1000) * 1000;
result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & timeVal, sizeof (struct timeval));
break;
}
case ENET_SOCKOPT_NODELAY:
result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
break;
default:
break;
}
return result == -1 ? -1 : 0;
}
int
enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
{
int result = -1;
socklen_t len;
switch (option)
{
case ENET_SOCKOPT_ERROR:
len = sizeof (int);
result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len);
break; break;
default: default:
@ -339,7 +366,7 @@ void
enet_socket_destroy (ENetSocket socket) enet_socket_destroy (ENetSocket socket)
{ {
if (socket != -1) if (socket != -1)
close (socket); close (socket);
} }
int int
@ -348,10 +375,9 @@ enet_socket_send (ENetSocket socket,
const ENetBuffer * buffers, const ENetBuffer * buffers,
size_t bufferCount) size_t bufferCount)
{ {
int sentLength = -1;
#ifndef GEKKO
struct msghdr msgHdr; struct msghdr msgHdr;
struct sockaddr_in sin; struct sockaddr_in sin;
int sentLength;
memset (& msgHdr, 0, sizeof (struct msghdr)); memset (& msgHdr, 0, sizeof (struct msghdr));
@ -371,12 +397,6 @@ enet_socket_send (ENetSocket socket,
msgHdr.msg_iovlen = bufferCount; msgHdr.msg_iovlen = bufferCount;
sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL); sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
#else
UNREFERENCED_PARAMETER(socket);
UNREFERENCED_PARAMETER(address);
UNREFERENCED_PARAMETER(buffers);
UNREFERENCED_PARAMETER(bufferCount);
#endif
if (sentLength == -1) if (sentLength == -1)
{ {
@ -395,10 +415,9 @@ enet_socket_receive (ENetSocket socket,
ENetBuffer * buffers, ENetBuffer * buffers,
size_t bufferCount) size_t bufferCount)
{ {
int recvLength = -1;
#ifndef GEKKO
struct msghdr msgHdr; struct msghdr msgHdr;
struct sockaddr_in sin; struct sockaddr_in sin;
int recvLength;
memset (& msgHdr, 0, sizeof (struct msghdr)); memset (& msgHdr, 0, sizeof (struct msghdr));
@ -412,12 +431,6 @@ enet_socket_receive (ENetSocket socket,
msgHdr.msg_iovlen = bufferCount; msgHdr.msg_iovlen = bufferCount;
recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL); recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
#else
UNREFERENCED_PARAMETER(socket);
UNREFERENCED_PARAMETER(address);
UNREFERENCED_PARAMETER(buffers);
UNREFERENCED_PARAMETER(bufferCount);
#endif
if (recvLength == -1) if (recvLength == -1)
{ {
@ -427,7 +440,6 @@ enet_socket_receive (ENetSocket socket,
return -1; return -1;
} }
#ifndef GEKKO
#ifdef HAS_MSGHDR_FLAGS #ifdef HAS_MSGHDR_FLAGS
if (msgHdr.msg_flags & MSG_TRUNC) if (msgHdr.msg_flags & MSG_TRUNC)
return -1; return -1;
@ -438,7 +450,6 @@ enet_socket_receive (ENetSocket socket,
address -> host = (enet_uint32) sin.sin_addr.s_addr; address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
} }
#endif
return recvLength; return recvLength;
} }
@ -473,7 +484,16 @@ enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeou
pollCount = poll (& pollSocket, 1, timeout); pollCount = poll (& pollSocket, 1, timeout);
if (pollCount < 0) if (pollCount < 0)
return -1; {
if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
{
* condition = ENET_SOCKET_WAIT_INTERRUPT;
return 0;
}
return -1;
}
* condition = ENET_SOCKET_WAIT_NONE; * condition = ENET_SOCKET_WAIT_NONE;
@ -507,7 +527,16 @@ enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeou
selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal); selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
if (selectCount < 0) if (selectCount < 0)
return -1; {
if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
{
* condition = ENET_SOCKET_WAIT_INTERRUPT;
return 0;
}
return -1;
}
* condition = ENET_SOCKET_WAIT_NONE; * condition = ENET_SOCKET_WAIT_NONE;

63
polymer/eduke32/source/enet/src/win32.c
View file

@ -40,6 +40,12 @@ enet_deinitialize (void)
WSACleanup (); WSACleanup ();
} }
enet_uint32
enet_host_random_seed (void)
{
return (enet_uint32) timeGetTime ();
}
enet_uint32 enet_uint32
enet_time_get (void) enet_time_get (void)
{ {
@ -79,7 +85,13 @@ enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameL
char * addr = inet_ntoa (* (struct in_addr *) & address -> host); char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
if (addr == NULL) if (addr == NULL)
return -1; return -1;
strncpy (name, addr, nameLength); else
{
size_t addrLen = strlen(addr);
if (addrLen >= nameLength)
return -1;
memcpy (name, addr, addrLen + 1);
}
return 0; return 0;
} }
@ -88,14 +100,19 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
{ {
struct in_addr in; struct in_addr in;
struct hostent * hostEntry; struct hostent * hostEntry;
in.s_addr = address -> host; in.s_addr = address -> host;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET); hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
if (hostEntry == NULL) if (hostEntry == NULL)
return enet_address_get_host_ip (address, name, nameLength); return enet_address_get_host_ip (address, name, nameLength);
else
strncpy (name, hostEntry -> h_name, nameLength); {
size_t hostLen = strlen (hostEntry -> h_name);
if (hostLen >= nameLength)
return -1;
memcpy (name, hostEntry -> h_name, hostLen + 1);
}
return 0; return 0;
} }
@ -125,6 +142,21 @@ enet_socket_bind (ENetSocket socket, const ENetAddress * address)
sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0; sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
} }
int
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
{
struct sockaddr_in sin;
int sinLength = sizeof (struct sockaddr_in);
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
return -1;
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
return 0;
}
int int
enet_socket_listen (ENetSocket socket, int backlog) enet_socket_listen (ENetSocket socket, int backlog)
{ {
@ -174,6 +206,27 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int)); result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int));
break; break;
case ENET_SOCKOPT_NODELAY:
result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
break;
default:
break;
}
return result == SOCKET_ERROR ? -1 : 0;
}
int
enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
{
int result = SOCKET_ERROR, len;
switch (option)
{
case ENET_SOCKOPT_ERROR:
len = sizeof(int);
result = getsockopt (socket, SOL_SOCKET, SO_ERROR, (char *) value, & len);
break;
default: default:
break; break;
} }
@ -232,7 +285,7 @@ void
enet_socket_destroy (ENetSocket socket) enet_socket_destroy (ENetSocket socket)
{ {
if (socket != INVALID_SOCKET) if (socket != INVALID_SOCKET)
closesocket (socket); closesocket (socket);
} }
int int