mirror of
https://github.com/ZDoom/Raze.git
synced 2024-11-16 01:11:44 +00:00
Upgrade ENet library
git-svn-id: https://svn.eduke32.com/eduke32@4388 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx
parent
2177591619
commit
6baf8f96f1
12 changed files with 516 additions and 296 deletions
|
|
@ -6,7 +6,8 @@
|
|||
#define __ENET_ENET_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
|
@ -17,23 +18,30 @@ extern "C" {
|
|||
#include "enet/unix.h"
|
||||
#endif
|
||||
|
||||
#ifndef UNREFERENCED_PARAMETER
|
||||
# define UNREFERENCED_PARAMETER(x) x=x
|
||||
#endif
|
||||
|
||||
#include "enet/types.h"
|
||||
#include "enet/protocol.h"
|
||||
#include "enet/list.h"
|
||||
#include "enet/callbacks.h"
|
||||
|
||||
#ifndef UNREFERENCED_PARAMETER
|
||||
# define UNREFERENCED_PARAMETER(x) x=x
|
||||
#endif
|
||||
|
||||
#define ENET_VERSION_MAJOR 1
|
||||
#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_GET_MAJOR(version) (((version)>>16)&0xFF)
|
||||
#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
|
||||
#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
|
||||
#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
|
||||
|
||||
typedef enet_uint32 ENetVersion;
|
||||
|
||||
struct _ENetHost;
|
||||
struct _ENetEvent;
|
||||
struct _ENetPacket;
|
||||
|
||||
typedef enum _ENetSocketType
|
||||
{
|
||||
ENET_SOCKET_TYPE_STREAM = 1,
|
||||
|
|
@ -42,9 +50,10 @@ typedef enum _ENetSocketType
|
|||
|
||||
typedef enum _ENetSocketWait
|
||||
{
|
||||
ENET_SOCKET_WAIT_NONE = 0,
|
||||
ENET_SOCKET_WAIT_SEND = (1 << 0),
|
||||
ENET_SOCKET_WAIT_RECEIVE = (1 << 1)
|
||||
ENET_SOCKET_WAIT_NONE = 0,
|
||||
ENET_SOCKET_WAIT_SEND = (1 << 0),
|
||||
ENET_SOCKET_WAIT_RECEIVE = (1 << 1),
|
||||
ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
|
||||
} ENetSocketWait;
|
||||
|
||||
typedef enum _ENetSocketOption
|
||||
|
|
@ -55,7 +64,9 @@ typedef enum _ENetSocketOption
|
|||
ENET_SOCKOPT_SNDBUF = 4,
|
||||
ENET_SOCKOPT_REUSEADDR = 5,
|
||||
ENET_SOCKOPT_RCVTIMEO = 6,
|
||||
ENET_SOCKOPT_SNDTIMEO = 7
|
||||
ENET_SOCKOPT_SNDTIMEO = 7,
|
||||
ENET_SOCKOPT_ERROR = 8,
|
||||
ENET_SOCKOPT_NODELAY = 9
|
||||
} ENetSocketOption;
|
||||
|
||||
typedef enum _ENetSocketShutdown
|
||||
|
|
@ -65,13 +76,9 @@ typedef enum _ENetSocketShutdown
|
|||
ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
|
||||
} ENetSocketShutdown;
|
||||
|
||||
enum
|
||||
{
|
||||
ENET_HOST_ANY = 0, /**< specifies the default server host */
|
||||
ENET_HOST_BROADCAST = 0xFFFFFFFF, /**< specifies a subnet-wide broadcast */
|
||||
|
||||
ENET_PORT_ANY = 0 /**< specifies that a port should be automatically chosen */
|
||||
};
|
||||
#define ENET_HOST_ANY 0
|
||||
#define ENET_HOST_BROADCAST 0xFFFFFFFFU
|
||||
#define ENET_PORT_ANY 0
|
||||
|
||||
/**
|
||||
* Portable internet address structure.
|
||||
|
|
@ -111,10 +118,12 @@ typedef enum _ENetPacketFlag
|
|||
ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
|
||||
/** packet will be fragmented using unreliable (instead of reliable) sends
|
||||
* if it exceeds the MTU */
|
||||
ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3)
|
||||
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;
|
||||
|
||||
struct _ENetPacket;
|
||||
typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
|
||||
|
||||
/**
|
||||
|
|
@ -143,6 +152,7 @@ typedef struct _ENetPacket
|
|||
enet_uint8 * data; /**< allocated data for packet */
|
||||
size_t dataLength; /**< length of data */
|
||||
ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
|
||||
void * userData; /**< application private data, may be freely modified */
|
||||
} ENetPacket;
|
||||
|
||||
typedef struct _ENetAcknowledgement
|
||||
|
|
@ -322,6 +332,9 @@ typedef struct _ENetCompressor
|
|||
|
||||
/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
|
||||
typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
|
||||
|
||||
/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
|
||||
typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
|
||||
|
||||
/** An ENet host for communicating with peers.
|
||||
*
|
||||
|
|
@ -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 totalReceivedData; /**< total data received, user should reset to 0 as needed to prevent overflow */
|
||||
enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
|
||||
ENetInterceptCallback intercept; /**< callback the user can set to intercept received raw UDP packets */
|
||||
size_t connectedPeers;
|
||||
size_t bandwidthLimitedPeers;
|
||||
size_t duplicatePeers; /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
|
||||
} 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.
|
||||
|
||||
@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
|
||||
*/
|
||||
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);
|
||||
|
||||
/**
|
||||
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 */
|
||||
|
|
@ -463,6 +486,7 @@ ENET_API void enet_time_set (enet_uint32);
|
|||
*/
|
||||
ENET_API ENetSocket enet_socket_create (ENetSocketType);
|
||||
ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
|
||||
ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
|
||||
ENET_API int enet_socket_listen (ENetSocket, int);
|
||||
ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
|
||||
ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
|
||||
|
|
@ -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_wait (ENetSocket, enet_uint32 *, enet_uint32);
|
||||
ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
|
||||
ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
|
||||
ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
|
||||
ENET_API void enet_socket_destroy (ENetSocket);
|
||||
ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
|
||||
|
|
@ -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);
|
||||
|
||||
/** 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 hostName destination for name, must not be NULL
|
||||
@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_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
|
||||
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 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 void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
|
||||
extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
|
||||
extern void enet_peer_on_connect (ENetPeer *);
|
||||
extern void enet_peer_on_disconnect (ENetPeer *);
|
||||
|
||||
ENET_API void * enet_range_coder_create (void);
|
||||
ENET_API void enet_range_coder_destroy (void *);
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ enum
|
|||
ENET_PROTOCOL_MAXIMUM_MTU = 4096,
|
||||
ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
|
||||
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_MAXIMUM_CHANNEL_COUNT = 255,
|
||||
ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF,
|
||||
|
|
@ -54,10 +54,10 @@ typedef enum _ENetProtocolFlag
|
|||
ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12
|
||||
} ENetProtocolFlag;
|
||||
|
||||
#ifdef _MSC_VER_
|
||||
#ifdef _MSC_VER
|
||||
#pragma pack(push, 1)
|
||||
#define ENET_PACKED
|
||||
#elif defined(__GNUC__)
|
||||
#elif defined(__GNUC__) || defined(__clang__)
|
||||
#define ENET_PACKED __attribute__ ((packed))
|
||||
#else
|
||||
#define ENET_PACKED
|
||||
|
|
@ -191,7 +191,7 @@ typedef union _ENetProtocol
|
|||
ENetProtocolThrottleConfigure throttleConfigure;
|
||||
} ENET_PACKED ENetProtocol;
|
||||
|
||||
#ifdef _MSC_VER_
|
||||
#ifdef _MSC_VER
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -8,21 +8,21 @@
|
|||
#include <stdlib.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <sys/socket.h>
|
||||
#if defined(GEKKO)
|
||||
# include <network.h>
|
||||
#else
|
||||
# include <netinet/in.h>
|
||||
#include <netinet/in.h>
|
||||
#endif
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef MSG_MAXIOVLEN
|
||||
#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
|
||||
#endif
|
||||
|
||||
typedef int ENetSocket;
|
||||
|
||||
enum
|
||||
{
|
||||
ENET_SOCKET_NULL = -1
|
||||
};
|
||||
#define ENET_SOCKET_NULL -1
|
||||
|
||||
#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
|
||||
#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
|
||||
|
|
@ -44,7 +44,7 @@ typedef fd_set ENetSocketSet;
|
|||
|
||||
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
|
||||
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
|
||||
|
||||
#endif /* __ENET_UNIX_H__ */
|
||||
|
|
|
|||
|
|
@ -5,12 +5,12 @@
|
|||
#ifndef __ENET_WIN32_H__
|
||||
#define __ENET_WIN32_H__
|
||||
|
||||
#ifdef ENET_BUILDING_LIB
|
||||
#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: 4244) // 64bit to 32bit int
|
||||
#pragma warning (disable: 4018) // signed/unsigned mismatch
|
||||
#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
|
@ -19,10 +19,7 @@
|
|||
|
||||
typedef SOCKET ENetSocket;
|
||||
|
||||
enum
|
||||
{
|
||||
ENET_SOCKET_NULL = INVALID_SOCKET
|
||||
};
|
||||
#define ENET_SOCKET_NULL INVALID_SOCKET
|
||||
|
||||
#define ENET_HOST_TO_NET_16(value) (htons (value))
|
||||
#define ENET_HOST_TO_NET_32(value) (htonl (value))
|
||||
|
|
@ -38,8 +35,8 @@ typedef struct
|
|||
|
||||
#define ENET_CALLBACK __cdecl
|
||||
|
||||
#if defined ENET_DLL
|
||||
#if defined ENET_BUILDING_LIB
|
||||
#ifdef ENET_DLL
|
||||
#ifdef ENET_BUILDING_LIB
|
||||
#define ENET_API __declspec( dllexport )
|
||||
#else
|
||||
#define ENET_API __declspec( dllimport )
|
||||
|
|
@ -52,7 +49,7 @@ typedef fd_set ENetSocketSet;
|
|||
|
||||
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
|
||||
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
|
||||
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
|
||||
|
||||
#endif /* __ENET_WIN32_H__ */
|
||||
|
|
|
|||
|
|
@ -27,6 +27,12 @@ enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits
|
|||
|
||||
return enet_initialize ();
|
||||
}
|
||||
|
||||
ENetVersion
|
||||
enet_linked_version (void)
|
||||
{
|
||||
return ENET_VERSION;
|
||||
}
|
||||
|
||||
void *
|
||||
enet_malloc (size_t size)
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ enet_symbol_rescale (ENetSymbol * symbol)
|
|||
if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \
|
||||
{ \
|
||||
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); \
|
||||
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(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \
|
||||
decodeRange = -(signed)decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
|
||||
decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \
|
||||
} \
|
||||
decodeCode <<= 8; \
|
||||
if (inData < inEnd) \
|
||||
|
|
|
|||
|
|
@ -3,9 +3,7 @@
|
|||
@brief ENet host management functions
|
||||
*/
|
||||
#define ENET_BUILDING_LIB 1
|
||||
#define __MINGW_USE_VC2005_COMPAT 1
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include "enet/enet.h"
|
||||
|
||||
/** @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_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
|
||||
|
||||
if (address != NULL)
|
||||
if (address != NULL && enet_socket_get_address (host -> socket, & host -> address) < 0)
|
||||
host -> address = * address;
|
||||
|
||||
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)
|
||||
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 -> channelLimit = channelLimit;
|
||||
host -> incomingBandwidth = incomingBandwidth;
|
||||
|
|
@ -98,11 +97,17 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
|
|||
host -> totalReceivedData = 0;
|
||||
host -> totalReceivedPackets = 0;
|
||||
|
||||
host -> connectedPeers = 0;
|
||||
host -> bandwidthLimitedPeers = 0;
|
||||
host -> duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID;
|
||||
|
||||
host -> compressor.context = NULL;
|
||||
host -> compressor.compress = NULL;
|
||||
host -> compressor.decompress = NULL;
|
||||
host -> compressor.destroy = NULL;
|
||||
|
||||
host -> intercept = NULL;
|
||||
|
||||
enet_list_clear (& host -> dispatchQueue);
|
||||
|
||||
for (currentPeer = host -> peers;
|
||||
|
|
@ -322,46 +327,44 @@ enet_host_bandwidth_throttle (ENetHost * host)
|
|||
{
|
||||
enet_uint32 timeCurrent = enet_time_get (),
|
||||
elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
|
||||
peersTotal = 0,
|
||||
dataTotal = 0,
|
||||
peersRemaining,
|
||||
bandwidth,
|
||||
peersRemaining = (enet_uint32) host -> connectedPeers,
|
||||
dataTotal = ~0,
|
||||
bandwidth = ~0,
|
||||
throttle = 0,
|
||||
bandwidthLimit = 0;
|
||||
int needsAdjustment;
|
||||
int needsAdjustment = host -> bandwidthLimitedPeers > 0 ? 1 : 0;
|
||||
ENetPeer * peer;
|
||||
ENetProtocol command;
|
||||
|
||||
if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
|
||||
return;
|
||||
|
||||
for (peer = host -> peers;
|
||||
peer < & host -> peers [host -> peerCount];
|
||||
++ peer)
|
||||
{
|
||||
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
|
||||
continue;
|
||||
host -> bandwidthThrottleEpoch = timeCurrent;
|
||||
|
||||
++ peersTotal;
|
||||
dataTotal += peer -> outgoingDataTotal;
|
||||
}
|
||||
|
||||
if (peersTotal == 0)
|
||||
if (peersRemaining == 0)
|
||||
return;
|
||||
|
||||
peersRemaining = peersTotal;
|
||||
needsAdjustment = 1;
|
||||
if (host -> outgoingBandwidth != 0)
|
||||
{
|
||||
dataTotal = 0;
|
||||
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
|
||||
|
||||
if (host -> outgoingBandwidth == 0)
|
||||
bandwidth = ~0;
|
||||
else
|
||||
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
|
||||
for (peer = host -> peers;
|
||||
peer < & host -> peers [host -> peerCount];
|
||||
++ peer)
|
||||
{
|
||||
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
|
||||
continue;
|
||||
|
||||
dataTotal += peer -> outgoingDataTotal;
|
||||
}
|
||||
}
|
||||
|
||||
while (peersRemaining > 0 && needsAdjustment != 0)
|
||||
{
|
||||
needsAdjustment = 0;
|
||||
|
||||
if (dataTotal < bandwidth)
|
||||
if (dataTotal <= bandwidth)
|
||||
throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
|
||||
else
|
||||
throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
|
||||
|
|
@ -392,7 +395,9 @@ enet_host_bandwidth_throttle (ENetHost * host)
|
|||
|
||||
peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
|
||||
|
||||
|
||||
peer -> incomingDataTotal = 0;
|
||||
peer -> outgoingDataTotal = 0;
|
||||
|
||||
needsAdjustment = 1;
|
||||
-- peersRemaining;
|
||||
bandwidth -= peerBandwidth;
|
||||
|
|
@ -401,25 +406,35 @@ enet_host_bandwidth_throttle (ENetHost * host)
|
|||
}
|
||||
|
||||
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) ||
|
||||
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
|
||||
continue;
|
||||
if (dataTotal <= bandwidth)
|
||||
throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
|
||||
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 -> packetThrottle = peer -> packetThrottleLimit;
|
||||
peer -> packetThrottleLimit = throttle;
|
||||
|
||||
if (peer -> packetThrottle > peer -> packetThrottleLimit)
|
||||
peer -> packetThrottle = peer -> packetThrottleLimit;
|
||||
|
||||
peer -> incomingDataTotal = 0;
|
||||
peer -> outgoingDataTotal = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (host -> recalculateBandwidthLimits)
|
||||
{
|
||||
host -> recalculateBandwidthLimits = 0;
|
||||
|
||||
peersRemaining = peersTotal;
|
||||
peersRemaining = (enet_uint32) host -> connectedPeers;
|
||||
bandwidth = host -> incomingBandwidth;
|
||||
needsAdjustment = 1;
|
||||
|
||||
|
|
@ -470,16 +485,6 @@ enet_host_bandwidth_throttle (ENetHost * host)
|
|||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/** @} */
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
*/
|
||||
|
||||
/** 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 flags flags for this packet as described for the ENetPacket structure.
|
||||
@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 -> dataLength = dataLength;
|
||||
packet -> freeCallback = NULL;
|
||||
packet -> userData = NULL;
|
||||
|
||||
return packet;
|
||||
}
|
||||
|
|
@ -115,7 +116,7 @@ reflect_crc (int val, int bits)
|
|||
}
|
||||
|
||||
static void
|
||||
initialize_crc32 ()
|
||||
initialize_crc32 (void)
|
||||
{
|
||||
int byte;
|
||||
|
||||
|
|
|
|||
|
|
@ -271,7 +271,7 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm
|
|||
ENetListIterator currentCommand;
|
||||
|
||||
UNREFERENCED_PARAMETER(queue);
|
||||
|
||||
|
||||
for (currentCommand = startCommand; currentCommand != endCommand; )
|
||||
{
|
||||
ENetIncomingCommand * incomingCommand = (ENetIncomingCommand *) currentCommand;
|
||||
|
|
@ -298,7 +298,7 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm
|
|||
static void
|
||||
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
|
||||
|
|
@ -339,6 +339,30 @@ enet_peer_reset_queues (ENetPeer * peer)
|
|||
peer -> channelCount = 0;
|
||||
}
|
||||
|
||||
void
|
||||
enet_peer_on_connect (ENetPeer * peer)
|
||||
{
|
||||
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
|
||||
{
|
||||
if (peer -> incomingBandwidth != 0)
|
||||
++ peer -> host -> bandwidthLimitedPeers;
|
||||
|
||||
++ peer -> host -> connectedPeers;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
enet_peer_on_disconnect (ENetPeer * peer)
|
||||
{
|
||||
if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
|
||||
{
|
||||
if (peer -> incomingBandwidth != 0)
|
||||
-- peer -> host -> bandwidthLimitedPeers;
|
||||
|
||||
-- peer -> host -> connectedPeers;
|
||||
}
|
||||
}
|
||||
|
||||
/** Forcefully disconnects a peer.
|
||||
@param peer peer to forcefully disconnect
|
||||
@remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
|
||||
|
|
@ -347,6 +371,8 @@ enet_peer_reset_queues (ENetPeer * peer)
|
|||
void
|
||||
enet_peer_reset (ENetPeer * peer)
|
||||
{
|
||||
enet_peer_on_disconnect (peer);
|
||||
|
||||
peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
|
||||
peer -> connectID = 0;
|
||||
|
||||
|
|
@ -400,7 +426,7 @@ enet_peer_reset (ENetPeer * peer)
|
|||
/** Sends a ping request to a peer.
|
||||
@param peer destination for the ping request
|
||||
@remarks ping requests factor into the mean round trip time as designated by the
|
||||
roundTripTime field in the ENetPeer structure. Enet automatically pings all connected
|
||||
roundTripTime field in the ENetPeer structure. ENet automatically pings all connected
|
||||
peers at regular intervals, however, this function may be called to ensure more
|
||||
frequent ping requests.
|
||||
*/
|
||||
|
|
@ -430,7 +456,7 @@ enet_peer_ping (ENetPeer * peer)
|
|||
void
|
||||
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.
|
||||
|
|
@ -453,16 +479,16 @@ enet_peer_ping_interval (ENetPeer * peer, enet_uint32 pingInterval)
|
|||
void
|
||||
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 -> timeoutMinimum = timeoutMinimum ? timeoutMinimum : (enet_uint32)ENET_PEER_TIMEOUT_MINIMUM;
|
||||
peer -> timeoutMaximum = timeoutMaximum ? timeoutMaximum : (enet_uint32)ENET_PEER_TIMEOUT_MAXIMUM;
|
||||
peer -> timeoutLimit = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
|
||||
peer -> timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
|
||||
peer -> timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
|
||||
}
|
||||
|
||||
/** Force an immediate disconnection from a peer.
|
||||
@param peer peer to disconnect
|
||||
@param data data describing the disconnection
|
||||
@remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
|
||||
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.
|
||||
*/
|
||||
void
|
||||
|
|
@ -521,7 +547,11 @@ enet_peer_disconnect (ENetPeer * peer, enet_uint32 data)
|
|||
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
|
||||
|
||||
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
|
||||
{
|
||||
enet_host_flush (peer -> host);
|
||||
|
|
@ -586,7 +616,7 @@ void
|
|||
enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoingCommand)
|
||||
{
|
||||
ENetChannel * channel = & peer -> channels [outgoingCommand -> command.header.channelID];
|
||||
|
||||
|
||||
peer -> outgoingDataTotal += enet_protocol_command_size (outgoingCommand -> command.header.command) + outgoingCommand -> fragmentLength;
|
||||
|
||||
if (outgoingCommand -> command.header.channelID == 0xFF)
|
||||
|
|
@ -683,9 +713,9 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
|
|||
|
||||
if (incomingCommand -> reliableSequenceNumber == channel -> incomingReliableSequenceNumber)
|
||||
{
|
||||
if (incomingCommand -> fragmentsRemaining <= 0)
|
||||
if (incomingCommand -> fragmentsRemaining <= 0)
|
||||
{
|
||||
channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber;
|
||||
channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber;
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -702,11 +732,11 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
|
|||
|
||||
droppedCommand = currentCommand;
|
||||
}
|
||||
else
|
||||
else
|
||||
if (droppedCommand != currentCommand)
|
||||
droppedCommand = enet_list_previous (currentCommand);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
enet_uint16 reliableWindow = incomingCommand -> reliableSequenceNumber / 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)
|
||||
{
|
||||
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);
|
||||
|
||||
peer -> needsDispatch = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
startCommand = enet_list_next (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)
|
||||
{
|
||||
enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
|
||||
if (! peer -> needsDispatch)
|
||||
{
|
||||
enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);
|
||||
|
||||
peer -> needsDispatch = 1;
|
||||
}
|
||||
peer -> needsDispatch = 1;
|
||||
}
|
||||
|
||||
droppedCommand = currentCommand;
|
||||
}
|
||||
|
|
@ -786,7 +816,7 @@ enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * ch
|
|||
}
|
||||
|
||||
if (! enet_list_empty (& channel -> incomingUnreliableCommands))
|
||||
enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
|
||||
enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
|
||||
}
|
||||
|
||||
ENetIncomingCommand *
|
||||
|
|
|
|||
|
|
@ -32,6 +32,32 @@ enet_protocol_command_size (enet_uint8 commandNumber)
|
|||
return commandSizes [commandNumber & ENET_PROTOCOL_COMMAND_MASK];
|
||||
}
|
||||
|
||||
static void
|
||||
enet_protocol_change_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
|
||||
{
|
||||
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
|
||||
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_SUCCEEDED:
|
||||
peer -> state = ENET_PEER_STATE_CONNECTED;
|
||||
enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
|
||||
|
||||
event -> type = ENET_EVENT_TYPE_CONNECT;
|
||||
event -> peer = peer;
|
||||
|
|
@ -92,19 +118,6 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
enet_protocol_dispatch_state (ENetHost * host, ENetPeer * peer, ENetPeerState state)
|
||||
{
|
||||
peer -> state = state;
|
||||
|
||||
if (! peer -> needsDispatch)
|
||||
{
|
||||
enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);
|
||||
|
||||
peer -> needsDispatch = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
|
||||
{
|
||||
|
|
@ -112,7 +125,7 @@ enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * even
|
|||
|
||||
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 -> peer = peer;
|
||||
|
|
@ -163,7 +176,11 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
|
|||
-- outgoingCommand -> packet -> referenceCount;
|
||||
|
||||
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);
|
||||
|
|
@ -237,7 +254,11 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliabl
|
|||
-- outgoingCommand -> packet -> referenceCount;
|
||||
|
||||
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);
|
||||
|
|
@ -258,8 +279,8 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
|
|||
enet_uint8 incomingSessionID, outgoingSessionID;
|
||||
enet_uint32 mtu, windowSize;
|
||||
ENetChannel * channel;
|
||||
size_t channelCount;
|
||||
ENetPeer * currentPeer;
|
||||
size_t channelCount, duplicatePeers = 0;
|
||||
ENetPeer * currentPeer, * peer = NULL;
|
||||
ENetProtocol verifyCommand;
|
||||
|
||||
UNREFERENCED_PARAMETER(header);
|
||||
|
|
@ -270,59 +291,61 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
|
|||
channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
|
||||
return NULL;
|
||||
|
||||
for (currentPeer = host -> peers;
|
||||
currentPeer < & host -> peers [host -> peerCount];
|
||||
++ currentPeer)
|
||||
{
|
||||
if (currentPeer -> state != ENET_PEER_STATE_DISCONNECTED &&
|
||||
currentPeer -> address.host == host -> receivedAddress.host &&
|
||||
currentPeer -> address.port == host -> receivedAddress.port &&
|
||||
currentPeer -> connectID == command -> connect.connectID)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (currentPeer = host -> peers;
|
||||
currentPeer < & host -> peers [host -> peerCount];
|
||||
++ currentPeer)
|
||||
{
|
||||
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;
|
||||
|
||||
if (channelCount > host -> channelLimit)
|
||||
channelCount = host -> channelLimit;
|
||||
currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
|
||||
if (currentPeer -> channels == NULL)
|
||||
peer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
|
||||
if (peer -> channels == NULL)
|
||||
return NULL;
|
||||
currentPeer -> channelCount = channelCount;
|
||||
currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
|
||||
currentPeer -> connectID = command -> connect.connectID;
|
||||
currentPeer -> address = host -> receivedAddress;
|
||||
currentPeer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
|
||||
currentPeer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
|
||||
currentPeer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
|
||||
currentPeer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);
|
||||
currentPeer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);
|
||||
currentPeer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);
|
||||
currentPeer -> eventData = ENET_NET_TO_HOST_32 (command -> connect.data);
|
||||
peer -> channelCount = channelCount;
|
||||
peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
|
||||
peer -> connectID = command -> connect.connectID;
|
||||
peer -> address = host -> receivedAddress;
|
||||
peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
|
||||
peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
|
||||
peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
|
||||
peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);
|
||||
peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);
|
||||
peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);
|
||||
peer -> eventData = ENET_NET_TO_HOST_32 (command -> connect.data);
|
||||
|
||||
incomingSessionID = command -> connect.incomingSessionID == 0xFF ? 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);
|
||||
if (incomingSessionID == currentPeer -> outgoingSessionID)
|
||||
if (incomingSessionID == peer -> outgoingSessionID)
|
||||
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);
|
||||
if (outgoingSessionID == currentPeer -> incomingSessionID)
|
||||
if (outgoingSessionID == peer -> incomingSessionID)
|
||||
outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
|
||||
currentPeer -> incomingSessionID = outgoingSessionID;
|
||||
peer -> incomingSessionID = outgoingSessionID;
|
||||
|
||||
for (channel = currentPeer -> channels;
|
||||
channel < & currentPeer -> channels [channelCount];
|
||||
for (channel = peer -> channels;
|
||||
channel < & peer -> channels [channelCount];
|
||||
++ channel)
|
||||
{
|
||||
channel -> outgoingReliableSequenceNumber = 0;
|
||||
|
|
@ -345,27 +368,27 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
|
|||
if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
|
||||
mtu = ENET_PROTOCOL_MAXIMUM_MTU;
|
||||
|
||||
currentPeer -> mtu = mtu;
|
||||
peer -> mtu = mtu;
|
||||
|
||||
if (host -> outgoingBandwidth == 0 &&
|
||||
currentPeer -> incomingBandwidth == 0)
|
||||
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
peer -> incomingBandwidth == 0)
|
||||
peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
else
|
||||
if (host -> outgoingBandwidth == 0 ||
|
||||
currentPeer -> incomingBandwidth == 0)
|
||||
currentPeer -> windowSize = (ENET_MAX (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) /
|
||||
peer -> incomingBandwidth == 0)
|
||||
peer -> windowSize = (ENET_MAX (host -> outgoingBandwidth, peer -> incomingBandwidth) /
|
||||
ENET_PEER_WINDOW_SIZE_SCALE) *
|
||||
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
||||
else
|
||||
currentPeer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) /
|
||||
peer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, peer -> incomingBandwidth) /
|
||||
ENET_PEER_WINDOW_SIZE_SCALE) *
|
||||
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
||||
|
||||
if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
|
||||
currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
||||
if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
|
||||
peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
|
||||
else
|
||||
if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
|
||||
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
|
||||
peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
|
||||
if (host -> incomingBandwidth == 0)
|
||||
windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
|
|
@ -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.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.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.channelCount = ENET_HOST_TO_NET_32 (channelCount);
|
||||
verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
|
||||
verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
|
||||
verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
|
||||
verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
|
||||
verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
|
||||
verifyCommand.verifyConnect.connectID = currentPeer -> connectID;
|
||||
verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (peer -> packetThrottleInterval);
|
||||
verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleAcceleration);
|
||||
verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (peer -> packetThrottleDeceleration);
|
||||
verifyCommand.verifyConnect.connectID = peer -> connectID;
|
||||
|
||||
enet_peer_queue_outgoing_command (currentPeer, & verifyCommand, NULL, 0, 0);
|
||||
enet_peer_queue_outgoing_command (peer, & verifyCommand, NULL, 0, 0);
|
||||
|
||||
return currentPeer;
|
||||
return peer;
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -745,20 +768,29 @@ static int
|
|||
enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(host);
|
||||
UNREFERENCED_PARAMETER(peer);
|
||||
UNREFERENCED_PARAMETER(command);
|
||||
|
||||
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
|
||||
{
|
||||
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 -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth);
|
||||
|
||||
if (peer -> incomingBandwidth != 0)
|
||||
++ host -> bandwidthLimitedPeers;
|
||||
|
||||
if (peer -> incomingBandwidth == 0 && host -> outgoingBandwidth == 0)
|
||||
peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
|
||||
else
|
||||
|
|
@ -779,6 +811,9 @@ enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const
|
|||
{
|
||||
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 -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration);
|
||||
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
|
||||
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;
|
||||
|
||||
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);
|
||||
else
|
||||
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
|
||||
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
|
||||
enet_protocol_dispatch_state (host, peer, ENET_PEER_STATE_ZOMBIE);
|
||||
|
||||
|
|
@ -823,6 +858,9 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer *
|
|||
receivedReliableSequenceNumber;
|
||||
ENetProtocolCommand commandNumber;
|
||||
|
||||
if (peer -> state == ENET_PEER_STATE_DISCONNECTED || peer -> state == ENET_PEER_STATE_ZOMBIE)
|
||||
return 0;
|
||||
|
||||
receivedSentTime = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedSentTime);
|
||||
receivedSentTime |= host -> serviceTime & 0xFFFF0000;
|
||||
if ((receivedSentTime & 0x8000) > (host -> serviceTime & 0x8000))
|
||||
|
|
@ -1075,7 +1113,7 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
|
|||
|
||||
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:
|
||||
if (enet_protocol_handle_acknowledge (host, event, peer, command))
|
||||
|
|
@ -1083,6 +1121,8 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
|
|||
break;
|
||||
|
||||
case ENET_PROTOCOL_COMMAND_CONNECT:
|
||||
if (peer != NULL)
|
||||
goto commandError;
|
||||
peer = enet_protocol_handle_connect (host, header, command);
|
||||
if (peer == NULL)
|
||||
goto commandError;
|
||||
|
|
@ -1156,6 +1196,8 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
|
|||
{
|
||||
case ENET_PEER_STATE_DISCONNECTING:
|
||||
case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
|
||||
case ENET_PEER_STATE_DISCONNECTED:
|
||||
case ENET_PEER_STATE_ZOMBIE:
|
||||
break;
|
||||
|
||||
case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
|
||||
|
|
@ -1204,7 +1246,25 @@ enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
|
|||
|
||||
host -> totalReceivedData += receivedLength;
|
||||
host -> totalReceivedPackets ++;
|
||||
|
||||
|
||||
if (host -> intercept != NULL)
|
||||
{
|
||||
switch (host -> intercept (host, event))
|
||||
{
|
||||
case 1:
|
||||
if (event != NULL && event -> type != ENET_EVENT_TYPE_NONE)
|
||||
return 1;
|
||||
|
||||
continue;
|
||||
|
||||
case -1:
|
||||
return -1;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
switch (enet_protocol_handle_incoming_commands (host, event))
|
||||
{
|
||||
case 1:
|
||||
|
|
@ -1228,7 +1288,8 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
|
|||
ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
|
||||
ENetAcknowledgement * acknowledgement;
|
||||
ENetListIterator currentAcknowledgement;
|
||||
|
||||
enet_uint16 reliableSequenceNumber;
|
||||
|
||||
currentAcknowledgement = enet_list_begin (& peer -> acknowledgements);
|
||||
|
||||
while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements))
|
||||
|
|
@ -1250,10 +1311,13 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
|
|||
buffer -> dataLength = sizeof (ENetProtocolAcknowledge);
|
||||
|
||||
host -> packetSize += buffer -> dataLength;
|
||||
|
||||
|
||||
reliableSequenceNumber = ENET_HOST_TO_NET_16 (acknowledgement -> command.header.reliableSequenceNumber);
|
||||
|
||||
command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
|
||||
command -> header.channelID = acknowledgement -> command.header.channelID;
|
||||
command -> 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);
|
||||
|
||||
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;
|
||||
|
||||
#ifdef ENET_DEBUG
|
||||
#ifdef _WIN32
|
||||
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);
|
||||
printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
|
||||
#endif
|
||||
|
||||
currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;
|
||||
|
|
@ -1663,12 +1722,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
|
|||
host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED;
|
||||
shouldCompress = compressedSize;
|
||||
#ifdef ENET_DEBUG_COMPRESS
|
||||
#ifdef _WIN32
|
||||
printf (
|
||||
#else
|
||||
fprintf (stderr,
|
||||
#endif
|
||||
"peer %u: compressed %u -> %u (%u%%)\n", currentPeer -> incomingPeerID, originalSize, compressedSize, (compressedSize * 100) / originalSize);
|
||||
printf ("peer %u: compressed %u -> %u (%u%%)\n", currentPeer -> incomingPeerID, originalSize, compressedSize, (compressedSize * 100) / originalSize);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -1772,7 +1826,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
|
|||
return 1;
|
||||
|
||||
case -1:
|
||||
#ifdef ENET_DEBUG
|
||||
perror ("Error dispatching incoming packets");
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
|
||||
|
|
@ -1796,7 +1852,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
|
|||
return 1;
|
||||
|
||||
case -1:
|
||||
#ifdef ENET_DEBUG
|
||||
perror ("Error sending outgoing packets");
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
|
||||
|
|
@ -1810,7 +1868,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
|
|||
return 1;
|
||||
|
||||
case -1:
|
||||
#ifdef ENET_DEBUG
|
||||
perror ("Error receiving incoming packets");
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
|
||||
|
|
@ -1824,7 +1884,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
|
|||
return 1;
|
||||
|
||||
case -1:
|
||||
#ifdef ENET_DEBUG
|
||||
perror ("Error sending outgoing packets");
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
|
||||
|
|
@ -1840,7 +1902,9 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
|
|||
return 1;
|
||||
|
||||
case -1:
|
||||
#ifdef ENET_DEBUG
|
||||
perror ("Error dispatching incoming packets");
|
||||
#endif
|
||||
|
||||
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))
|
||||
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 ();
|
||||
} while (waitCondition == ENET_SOCKET_WAIT_RECEIVE);
|
||||
} while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,45 +4,13 @@
|
|||
*/
|
||||
#ifndef _WIN32
|
||||
|
||||
#ifndef UNREFERENCED_PARAMETER
|
||||
#define UNREFERENCED_PARAMETER(x) x=x
|
||||
#endif
|
||||
|
||||
#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/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/time.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <netdb.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
|
@ -80,11 +48,9 @@ struct msghdr {
|
|||
#include <sys/poll.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifndef HAS_SOCKLEN_T
|
||||
typedef int socklen_t;
|
||||
#endif
|
||||
*/
|
||||
|
||||
#ifndef MSG_NOSIGNAL
|
||||
#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_time_get (void)
|
||||
{
|
||||
|
|
@ -166,7 +138,12 @@ enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameL
|
|||
#else
|
||||
char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
|
||||
if (addr != NULL)
|
||||
strncpy (name, addr, nameLength);
|
||||
{
|
||||
size_t addrLen = strlen(addr);
|
||||
if (addrLen >= nameLength)
|
||||
return -1;
|
||||
memcpy (name, addr, addrLen + 1);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
return -1;
|
||||
|
|
@ -176,9 +153,8 @@ enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameL
|
|||
int
|
||||
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
|
||||
{
|
||||
struct hostent * hostEntry = NULL;
|
||||
#ifndef GEKKO
|
||||
struct in_addr in;
|
||||
struct hostent * hostEntry = NULL;
|
||||
#ifdef HAS_GETHOSTBYADDR_R
|
||||
struct hostent hostData;
|
||||
char buffer [2048];
|
||||
|
|
@ -195,13 +171,17 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
|
|||
in.s_addr = address -> host;
|
||||
|
||||
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (hostEntry == NULL)
|
||||
return enet_address_get_host_ip (address, name, nameLength);
|
||||
|
||||
strncpy (name, hostEntry -> h_name, nameLength);
|
||||
else
|
||||
{
|
||||
size_t hostLen = strlen (hostEntry -> h_name);
|
||||
if (hostLen >= nameLength)
|
||||
return -1;
|
||||
memcpy (name, hostEntry -> h_name, hostLen + 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -231,6 +211,21 @@ enet_socket_bind (ENetSocket socket, const ENetAddress * address)
|
|||
sizeof (struct sockaddr_in));
|
||||
}
|
||||
|
||||
int
|
||||
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
socklen_t sinLength = sizeof (struct sockaddr_in);
|
||||
|
||||
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
|
||||
return -1;
|
||||
|
||||
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
||||
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
enet_socket_listen (ENetSocket socket, int backlog)
|
||||
{
|
||||
|
|
@ -274,11 +269,43 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
|
|||
break;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
default:
|
||||
|
|
@ -339,7 +366,7 @@ void
|
|||
enet_socket_destroy (ENetSocket socket)
|
||||
{
|
||||
if (socket != -1)
|
||||
close (socket);
|
||||
close (socket);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -348,10 +375,9 @@ enet_socket_send (ENetSocket socket,
|
|||
const ENetBuffer * buffers,
|
||||
size_t bufferCount)
|
||||
{
|
||||
int sentLength = -1;
|
||||
#ifndef GEKKO
|
||||
struct msghdr msgHdr;
|
||||
struct sockaddr_in sin;
|
||||
int sentLength;
|
||||
|
||||
memset (& msgHdr, 0, sizeof (struct msghdr));
|
||||
|
||||
|
|
@ -371,12 +397,6 @@ enet_socket_send (ENetSocket socket,
|
|||
msgHdr.msg_iovlen = bufferCount;
|
||||
|
||||
sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
|
||||
#else
|
||||
UNREFERENCED_PARAMETER(socket);
|
||||
UNREFERENCED_PARAMETER(address);
|
||||
UNREFERENCED_PARAMETER(buffers);
|
||||
UNREFERENCED_PARAMETER(bufferCount);
|
||||
#endif
|
||||
|
||||
if (sentLength == -1)
|
||||
{
|
||||
|
|
@ -395,10 +415,9 @@ enet_socket_receive (ENetSocket socket,
|
|||
ENetBuffer * buffers,
|
||||
size_t bufferCount)
|
||||
{
|
||||
int recvLength = -1;
|
||||
#ifndef GEKKO
|
||||
struct msghdr msgHdr;
|
||||
struct sockaddr_in sin;
|
||||
int recvLength;
|
||||
|
||||
memset (& msgHdr, 0, sizeof (struct msghdr));
|
||||
|
||||
|
|
@ -412,12 +431,6 @@ enet_socket_receive (ENetSocket socket,
|
|||
msgHdr.msg_iovlen = bufferCount;
|
||||
|
||||
recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
|
||||
#else
|
||||
UNREFERENCED_PARAMETER(socket);
|
||||
UNREFERENCED_PARAMETER(address);
|
||||
UNREFERENCED_PARAMETER(buffers);
|
||||
UNREFERENCED_PARAMETER(bufferCount);
|
||||
#endif
|
||||
|
||||
if (recvLength == -1)
|
||||
{
|
||||
|
|
@ -427,7 +440,6 @@ enet_socket_receive (ENetSocket socket,
|
|||
return -1;
|
||||
}
|
||||
|
||||
#ifndef GEKKO
|
||||
#ifdef HAS_MSGHDR_FLAGS
|
||||
if (msgHdr.msg_flags & MSG_TRUNC)
|
||||
return -1;
|
||||
|
|
@ -438,7 +450,6 @@ enet_socket_receive (ENetSocket socket,
|
|||
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
||||
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
||||
}
|
||||
#endif
|
||||
|
||||
return recvLength;
|
||||
}
|
||||
|
|
@ -473,7 +484,16 @@ enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeou
|
|||
pollCount = poll (& pollSocket, 1, timeout);
|
||||
|
||||
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;
|
||||
|
||||
|
|
@ -507,7 +527,16 @@ enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeou
|
|||
selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
|
||||
|
||||
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;
|
||||
|
||||
|
|
|
|||
|
|
@ -40,6 +40,12 @@ enet_deinitialize (void)
|
|||
WSACleanup ();
|
||||
}
|
||||
|
||||
enet_uint32
|
||||
enet_host_random_seed (void)
|
||||
{
|
||||
return (enet_uint32) timeGetTime ();
|
||||
}
|
||||
|
||||
enet_uint32
|
||||
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);
|
||||
if (addr == NULL)
|
||||
return -1;
|
||||
strncpy (name, addr, nameLength);
|
||||
else
|
||||
{
|
||||
size_t addrLen = strlen(addr);
|
||||
if (addrLen >= nameLength)
|
||||
return -1;
|
||||
memcpy (name, addr, addrLen + 1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -88,14 +100,19 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
|
|||
{
|
||||
struct in_addr in;
|
||||
struct hostent * hostEntry;
|
||||
|
||||
|
||||
in.s_addr = address -> host;
|
||||
|
||||
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
|
||||
if (hostEntry == NULL)
|
||||
return enet_address_get_host_ip (address, name, nameLength);
|
||||
|
||||
strncpy (name, hostEntry -> h_name, nameLength);
|
||||
else
|
||||
{
|
||||
size_t hostLen = strlen (hostEntry -> h_name);
|
||||
if (hostLen >= nameLength)
|
||||
return -1;
|
||||
memcpy (name, hostEntry -> h_name, hostLen + 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -125,6 +142,21 @@ enet_socket_bind (ENetSocket socket, const ENetAddress * address)
|
|||
sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
|
||||
}
|
||||
|
||||
int
|
||||
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
int sinLength = sizeof (struct sockaddr_in);
|
||||
|
||||
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
|
||||
return -1;
|
||||
|
||||
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
||||
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
enet_socket_listen (ENetSocket socket, int backlog)
|
||||
{
|
||||
|
|
@ -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));
|
||||
break;
|
||||
|
||||
case ENET_SOCKOPT_NODELAY:
|
||||
result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return result == SOCKET_ERROR ? -1 : 0;
|
||||
}
|
||||
|
||||
int
|
||||
enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
|
||||
{
|
||||
int result = SOCKET_ERROR, len;
|
||||
switch (option)
|
||||
{
|
||||
case ENET_SOCKOPT_ERROR:
|
||||
len = sizeof(int);
|
||||
result = getsockopt (socket, SOL_SOCKET, SO_ERROR, (char *) value, & len);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -232,7 +285,7 @@ void
|
|||
enet_socket_destroy (ENetSocket socket)
|
||||
{
|
||||
if (socket != INVALID_SOCKET)
|
||||
closesocket (socket);
|
||||
closesocket (socket);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
|
|||
Loading…
Reference in a new issue