ref: bfdb982f6fa34daa9aa9d819097a673d53a3cd12
parent: befdc2c0e10c8a7a41efd8f4110beee4af49e0d8
author: darealshinji <[email protected]>
date: Sat Aug 29 12:00:59 EDT 2015
Update ENet headers to release 1.3.13
--- /dev/null
+++ b/Engine/src/enet/ChangeLog
@@ -1,0 +1,177 @@
+ENet 1.3.13 (April 30, 2015):
+
+* miscellaneous bug fixes
+* added premake and cmake support
+* miscellaneous documentation cleanups
+
+ENet 1.3.12 (April 24, 2014):
+
+* added maximumPacketSize and maximumWaitingData fields to ENetHost to limit the amount of
+data waiting to be delivered on a peer (beware that the default maximumPacketSize is
+32MB and should be set higher if desired as should maximumWaitingData)
+
+ENet 1.3.11 (December 26, 2013):
+
+* allow an ENetHost to connect to itself
+* fixed possible bug with disconnect notifications during connect attempts
+* fixed some preprocessor definition bugs
+
+ENet 1.3.10 (October 23, 2013);
+
+* doubled maximum reliable window size
+* fixed RCVTIMEO/SNDTIMEO socket options and also added NODELAY
+
+ENet 1.3.9 (August 19, 2013):
+
+* added duplicatePeers option to ENetHost which can limit the number of peers from duplicate IPs
+* added enet_socket_get_option() and ENET_SOCKOPT_ERROR
+* added enet_host_random_seed() platform stub
+
+ENet 1.3.8 (June 2, 2013):
+
+* added enet_linked_version() for checking the linked version
+* added enet_socket_get_address() for querying the local address of a socket
+* silenced some debugging prints unless ENET_DEBUG is defined during compilation
+* handle EINTR in enet_socket_wait() so that enet_host_service() doesn't propagate errors from signals
+* optimized enet_host_bandwidth_throttle() to be less expensive for large numbers of peers
+
+ENet 1.3.7 (March 6, 2013):
+
+* added ENET_PACKET_FLAG_SENT to indicate that a packet is being freed because it has been sent
+* added userData field to ENetPacket
+* changed how random seed is generated on Windows to avoid import warnings
+* fixed case where disconnects could be generated with no preceding connect event
+
+ENet 1.3.6 (December 11, 2012):
+
+* added support for intercept callback in ENetHost that can be used to process raw packets before ENet
+* added enet_socket_shutdown() for issuing shutdown on a socket
+* fixed enet_socket_connect() to not error on non-blocking connects
+* fixed bug in MTU negotiation during connections
+
+ENet 1.3.5 (July 31, 2012):
+
+* fixed bug in unreliable packet fragment queuing
+
+ENet 1.3.4 (May 29, 2012):
+
+* added enet_peer_ping_interval() for configuring per-peer ping intervals
+* added enet_peer_timeout() for configuring per-peer timeouts
+* added protocol packet size limits
+
+ENet 1.3.3 (June 28, 2011):
+
+* fixed bug with simultaneous disconnects not dispatching events
+
+ENet 1.3.2 (May 31, 2011):
+
+* added support for unreliable packet fragmenting via the packet flag
+ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT
+* fixed regression in unreliable packet queuing
+* added check against received port to limit some forms of IP-spoofing
+
+ENet 1.3.1 (February 10, 2011):
+
+* fixed bug in tracking of reliable data in transit
+* reliable data window size now scales with the throttle
+* fixed bug in fragment length calculation when checksums are used
+
+ENet 1.3.0 (June 5, 2010):
+
+* enet_host_create() now requires the channel limit to be specified as
+a parameter
+* enet_host_connect() now accepts a data parameter which is supplied
+to the receiving receiving host in the event data field for a connect event
+* added an adaptive order-2 PPM range coder as a built-in compressor option
+which can be set with enet_host_compress_with_range_coder()
+* added support for packet compression configurable with a callback
+* improved session number handling to not rely on the packet checksum
+field, saving 4 bytes per packet unless the checksum option is used
+* removed the dependence on the rand callback for session number handling
+
+Caveats: This version is not protocol compatible with the 1.2 series or
+earlier. The enet_host_connect and enet_host_create API functions require
+supplying additional parameters.
+
+ENet 1.2.5 (June 28, 2011):
+
+* fixed bug with simultaneous disconnects not dispatching events
+
+ENet 1.2.4 (May 31, 2011):
+
+* fixed regression in unreliable packet queuing
+* added check against received port to limit some forms of IP-spoofing
+
+ENet 1.2.3 (February 10, 2011):
+
+* fixed bug in tracking reliable data in transit
+
+ENet 1.2.2 (June 5, 2010):
+
+* checksum functionality is now enabled by setting a checksum callback
+inside ENetHost instead of being a configure script option
+* added totalSentData, totalSentPackets, totalReceivedData, and
+totalReceivedPackets counters inside ENetHost for getting usage
+statistics
+* added enet_host_channel_limit() for limiting the maximum number of
+channels allowed by connected peers
+* now uses dispatch queues for event dispatch rather than potentially
+unscalable array walking
+* added no_memory callback that is called when a malloc attempt fails,
+such that if no_memory returns rather than aborts (the default behavior),
+then the error is propagated to the return value of the API calls
+* now uses packed attribute for protocol structures on platforms with
+strange alignment rules
+* improved autoconf build system contributed by Nathan Brink allowing
+for easier building as a shared library
+
+Caveats: If you were using the compile-time option that enabled checksums,
+make sure to set the checksum callback inside ENetHost to enet_crc32 to
+regain the old behavior. The ENetCallbacks structure has added new fields,
+so make sure to clear the structure to zero before use if
+using enet_initialize_with_callbacks().
+
+ENet 1.2.1 (November 12, 2009):
+
+* fixed bug that could cause disconnect events to be dropped
+* added thin wrapper around select() for portable usage
+* added ENET_SOCKOPT_REUSEADDR socket option
+* factored enet_socket_bind()/enet_socket_listen() out of enet_socket_create()
+* added contributed Code::Blocks build file
+
+ENet 1.2 (February 12, 2008):
+
+* fixed bug in VERIFY_CONNECT acknowledgement that could cause connect
+attempts to occasionally timeout
+* fixed acknowledgements to check both the outgoing and sent queues
+when removing acknowledged packets
+* fixed accidental bit rot in the MSVC project file
+* revised sequence number overflow handling to address some possible
+disconnect bugs
+* added enet_host_check_events() for getting only local queued events
+* factored out socket option setting into enet_socket_set_option() so
+that socket options are now set separately from enet_socket_create()
+
+Caveats: While this release is superficially protocol compatible with 1.1,
+differences in the sequence number overflow handling can potentially cause
+random disconnects.
+
+ENet 1.1 (June 6, 2007):
+
+* optional CRC32 just in case someone needs a stronger checksum than UDP
+provides (--enable-crc32 configure option)
+* the size of packet headers are half the size they used to be (so less
+overhead when sending small packets)
+* enet_peer_disconnect_later() that waits till all queued outgoing
+packets get sent before issuing an actual disconnect
+* freeCallback field in individual packets for notification of when a
+packet is about to be freed
+* ENET_PACKET_FLAG_NO_ALLOCATE for supplying pre-allocated data to a
+packet (can be used in concert with freeCallback to support some custom
+allocation schemes that the normal memory allocation callbacks would
+normally not allow)
+* enet_address_get_host_ip() for printing address numbers
+* promoted the enet_socket_*() functions to be part of the API now
+* a few stability/crash fixes
+
+
--- a/Engine/src/enet/LICENSE
+++ b/Engine/src/enet/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2002 Lee Salzman
+Copyright (c) 2002-2015 Lee Salzman
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
--- a/Engine/src/enet/README
+++ b/Engine/src/enet/README
@@ -1,16 +1,15 @@
-Please visit the ENet homepage at http://enet.cubik.org for installation
+Please visit the ENet homepage at http://enet.bespin.org for installation
and usage instructions.
-If you obtained this package from CVS, the quick description on how to build
+If you obtained this package from github, the quick description on how to build
is:
# Generate the build system.
-aclocal && automake -a -c --foreign && autoconf
+autoreconf -vfi
# Compile and install the library.
./configure && make && make install
-See pyenet/readme.txt for further information on Ling Lo's Python wrapper for
-ENet.
+
--- a/Engine/src/enet/api.txt
+++ /dev/null
@@ -1,290 +1,0 @@
-enet.h - The file that should be included to use the ENet API.
-
-enet_uint8 - unsigned 8 bit integer
-enet_uint16 - unsigned 16 bit integer
-enet_uint32 - unsigned 32 bit integer
-
-typedef struct
-{ - enet_uint32 host;
- enet_uint16 port;
-} ENetAddress;
-
- Portable internet address structure. The host must be specified in network
-byte-order, and the port must be in host byte-order. The constant ENET_HOST_ANY
-may be used to specify the default server host.
-
-typedef struct
-{- enet_uint32 flags;
- enet_uint8 * data;
- size_t dataLength;
-} ENetPacket;
-
- An ENet data packet that may be sent to or received from a peer. The shown fields
-should only be read and never modified. The data field contains the allocated data
-for the packet. The dataLength fields specifies the length of the allocated data.
-The flags field is either 0 (specifying no flags), or a bitwise-or of any
-combination of the following flags:
-
- ENET_PACKET_FLAG_RELIABLE -
-
- Specifies that the packet must be received by the target peer and that resend
- attempts should be made should delivery of the packet fail.
-
-typedef struct
-{- ENetAddress address;
- void * data;
- size_t channelCount;
- enet_uint32 incomingBandwidth;
- enet_uint32 outgoingBandwidth;
- enet_uint32 roundTripTime;
- enet_uint32 packetLoss;
-} ENetPeer;
-
- An ENet peer which data packets may be sent or received from. No fields should be
-modified unless otherwise specified. The address field contains the internet address
-of the peer. The data fields may be used to associate any desired data with the peer
-and may be freely modified. The channelCount field tells the number of channels that
-have been allocated for use to communnicate with the peer. The incomingBandwidth field
-specifies the downstream bandwidth of the client in bytes per second. The
-outgoingBandwidth field specifies the upstream bandwidth of the client in bytes per
-second. The roundTripTime field tells the mean round trip time from the sending of
-a reliable packet until the receipt of its acknowledgement in milliseconds. The
-packetLoss field tells the mean packet loss of reliable packets as a ratio with
-respect to the constant ENET_PEER_PACKET_LOSS_SCALE.
-
-typedef enum
-{- ENET_EVENT_TYPE_NONE,
- ENET_EVENT_TYPE_CONNECT,
- ENET_EVENT_TYPE_DISCONNECT,
- ENET_EVENT_TYPE_RECEIVE
-} ENetEventType;
-
-typedef struct _ENetEvent
-{- ENetEventType type;
- ENetPeer * peer;
- enet_uint8 channelID;
- ENetPacket * packet;
-} ENetEvent;
-
- An ENet event as returned by enet_host_service. The type field contains the type
-of the event, which may be any one of the following:
-
- ENET_EVENT_TYPE_NONE - No event occurred within the specified time limit.
- ENET_EVENT_TYPE_CONNECT -
-
- A connection request initiated by enet_host_connect has completed. The peer field
- contains the peer which successfully connected.
-
- ENET_EVENT_TYPE_DISCONNECT -
-
- A peer has disconnected. This event is generated on successful completion of a
- disconnect iniated by enet_peer_disconnect, if a peer has timed out, or if a
- connection request initialized by enet_host_connect has timed out. The peer field
- contains the peer which disconnected.
-
- ENET_EVENT_TYPE_RECEIVE -
-
- A packet has been received from a peer. The peer field specifies the peer which
- send the packet. The channelID field specifies the channel number upon which the
- packet was received. The packet field contains the packet that was destroyed; this
- packet must be destroyed with enet_packet_destroy after use.
-
-typedef struct
-{- ENetAddress address;
- enet_uint32 incomingBandwidth;
- enet_uint32 outgoingBandwidth;
- ENetPeer * peers;
- size_t peerCount;
-} ENetHost;
-
- An ENet host for communicating with peers. No fields should be modified. The address
-field tells the internet address of the host. The incomingBandwidth field tells the downstream
-bandwidth of the host. The outgoingBandwidth field specifies the upstream bandwidth of the host.
-The peers field contains an array of the peers that have been allocated for this host. The
-peerCount field specifies the number of peers that have been allocated for this host.
-
-unsigned ENET_HOST_TO_NET_8 (uint32_t);
-unsigned ENET_HOST_TO_NET_16 (uint32_t);
-unsigned ENET_HOST_TO_NET_32 (uint32_t);
-
- Macros that convert from host byte-order to network byte-order (big
-endian) for unsigned integers of 8 bits, 16 bits, and 32 bits repectively.
-
-unsigned ENET_NET_TO_HOST_8 (uint32_t);
-unsigned ENET_NET_TO_HOST_16 (uint32_t);
-unsigned ENET_NET_TO_HOST_32 (uint32_t);
-
- Macros that convert from network byte-order (big endian) to host
-byte-order for unsigned integers of 8 bits, 16 bits, and 32 bits repectively.
-
-enet_uint32 enet_time_get (void);
-
- Returns the wall-time in milliseconds. Its initial value is unspecified unless
-otherwise set.
-
-void enet_time_set (enet_uint32);
-
- Sets the current wall-time in milliseconds.
-
-int enet_initialize (void);
-
- Initialize ENet for use. Must be called prior to using any functions in ENet.
-Returns 0 on success and -1 on failure.
-
-void enet_deinitialize (void);
-
- Clean-up ENet after use. Should be called when a program that has initialized
-and used ENet exits.
-
-int enet_address_set_host (ENetAddress * address, const uint8_t * hostName);
-
- Attempts to resolve the host named by the parameter hostName and sets the host
-field in the address parameter if successful. Returns 0 on success and -1 on
-failure.
-
-int enet_address_get_host (const ENetAddress * address, uint8_t * hostName, size_t nameLength);
-
- Attempts to do a reverse lookup of the host field in the address parameter.
-If successful, the name of the host is placed in the string described by
-hostName and nameLength. The host name is always null-delimited and will
-not exceed nameLength in length. Returns 0 on success and -1 on failure.
-
-ENetPacket * enet_packet_create (const void * dataContents, size_t dataLength, enet_uint32 flags);
-
- Creates a packet that may be sent to a peer. The dataContents parameter
-specifies the initial contents of the packet's data; the packet's data will
-remain uninitialized if dataContents is NULL. The dataLength parameter specifies
-the size of the data that is allocated for this packet. The flags parameter
-specifies flags for this packet as described for the ENetPacket structure.
-Returns the packet on success and NULL on failure.
-
-void enet_packet_destroy (ENetPacket * packet);
-
- Destroys the packet and deallocates its data.
-
-int enet_packet_resize (ENetPacket * packet, size_t dataLength);
-
- Attempts to resize the data in the packet to the length specified in the
-dataLength parameter. Returns 0 on success and -1 on failure.
-
-ENetHost * enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth);
-
- Creates a host for communicating with peers. The address parameter specifies
-the address at which other peers may connect to this host; if the address parameter
-is NULL, then no peers may connect to the host. The peerCount parameter specifies
-the numbers of peers that should be allocated for the host; this limits the maximum
-number of peers that may connect to this host to peerCount. The incomingBandwidth
-parameter specifies the downstream bandwidth of the host in bytes per second; if
-the incomingBandwidth parameter is 0, ENet will assume the host has unlimited
-downstream bandwidth. The outgoingBandwidth parameter specifies the upstream bandwidth
-of the host in bytes per second; if the outgoingBandwidth parameter is 0, ENet will
-assume the host has unlimited upstream bandwidth. ENet will strategically drop packets
-on specific sides of a connection between hosts to ensure the host's bandwidth is not
-overwhelmed; the bandwidth parameters also determine the window size of a connection
-which limits the amount of reliable packets that may be in transit at any given time.
-Returns the host on success and NULL on failure.
-
-void enet_host_destroy (ENetHost * host);
-
- Destroys the host and all resources associated with it.
-
-ENetPeer * enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount);
-
- Initiates a connection from the host specified in the host parameter to a foreign
-host whose internet address is specified by the address parameter. The channelCount
-parameter specifies the number of channels that should be allocated for communicating
-with the foreign host. Returns a peer representing the foreign host on success and NULL
-on failure. The peer returned will have not completed the connection until enet_host_service
-notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
-
-int enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout);
-
- Waits for events on the host specified by the host parameters and shuttles packets
-between the host and its peers. The event parameter specifies an event structure
-where event details will be placed if one occurs. The timeout field specifies an
-amount of time in milliseconds that ENet should wait for events. Returns 1 if an
-event occured within the specified time limit, 0 if no event occurred within the
-time limit, and -1 on failure. This function must be called frequently for adequate
-performance.
-
-void enet_host_flush (ENetHost * host);
-
- Sends out any queued packets on the host specified in the host parameters to
-the designated peers. This function need only be used in circumstances where one
-wishes to send queued packets earlier than in a call to enet_host_service.
-
-void enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet);
-
- Queues a packet to be sent to all peers on the host specified in the host parameter
-over the channel number identified by the channelID parameter.
-
-void enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth);
-
- Adjusts the bandwidth limits of the host specified in the host parameter. The
-incomingBandwidth and outgoingBandwidth parameters are as specified in a call to
-enet_host_create.
-
-int enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet);
-
- Queues a packet to be sent to the peer specified by the peer parameter over the
-channel number identified by the channelID parameter. Returns 0 on success and -1
-on failure.
-
-ENetPacket * enet_peer_receive (ENetPeer * peer, enet_uint8 channelID);
-
- Attempts to dequeue any incoming queued packets on the peer specified by the peer
-parameter on the channel number identified by the channelID parameter. Returns a packet
-if one is available and NULL if there are no available incoming queued packets.
-
-void enet_peer_ping (ENetPeer * peer);
-
- Sends a ping request to the peer specified by the peer parameter. Ping requests factor
-into the mean round trip time as designated by the roundTripTime field in the ENetPeer
-structure. ENet automatically pings all connected peer at an interval, however, this
-function may be called to ensure more frequent ping requests.
-
-void enet_peer_reset (ENetPeer * peer);
-
- Forcefully disconnects the peer specified by the peer parameter. The foreign host
-represented by the peer is not notified of the disconnection and so will timeout on its
-connection to the local host.
-
-void enet_peer_disconnect (ENetPeer * peer);
-
- Request a disconnection from the peer specified by the peer parameter. An
-ENET_EVENT_DISCONNECT event will be generated by enet_host_service once the
-disconnection is complete.
-
-void enet_peer_throttle_configure (ENetPeer * peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration);
-
- Configures throttle parameter for the peer specified by the peer parameter.
-Unreliable packets are dropped by ENet in response to the varying conditions of
-the internet connection to the peer. The throttle represents a probability that
-an unreliable packet should not be dropped and thus sent by ENet to the peer.
-The lowest mean round trip time from the sending of a reliable packet to the
-receipt of its acknowledgement is measured over an amount of time specified
-by the interval parameter in milliseconds; the constant ENET_PEER_PACKET_THROTTLE_INTERVAL
-is the default value for this parameter. If a measured round trip time happens
-to be signifigantly less than the mean round trip time measured over the interval,
-then the throttle probability is increased to allow more traffic by an amount
-specified in the acceleration parameter which is in ratio to the
-ENET_PEER_PACKET_THROTTLE_SCALE constant. If a measured round trip time happens
-to be signifigantly greater than the mean round trip time measured over the interval,
-then the throttle probability is decreased to limit traffic by an amount specified
-in the deceleration parameter which is in ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
-constant. When the throttle has a value of ENET_PEER_PACKET_THROTTLE_SCALE, no unreliable
-packets are dropped by ENET, and so 100% of all unreliable packets will be sent. When the
-throttle has a value of 0, all unreliable packets are dropped by ENet, and so 0% of all
-unreliable packets will be sent. Intermediate values for the throttle represent intermediate
-probabilities between 0% and 100% of unreliable packets being sent. The bandwidth limits
-of the local and foreign host are taken into account to determine a sensible limit for
-the throttle probability above which it should not raise even in the best of conditions.
-
-
-
--- a/Engine/src/enet/design.txt
+++ /dev/null
@@ -1,117 +1,0 @@
-* Why ENet?
-
- ENet evolved specifically as a UDP networking layer for the multiplayer
-first person shooter Cube. Cube necessitated low latency communcation with
-data sent out very frequently, so TCP was an unsuitable choice due to its
-high latency and stream orientation. UDP, however, lacks many sometimes
-necessary features from TCP such as reliability, sequencing, unrestricted
-packet sizes, and connection management. So UDP by itself was not suitable
-as a network protocol either. No suitable freely available networking
-libraries existed at the time of ENet's creation to fill this niche.
-
- UDP and TCP could have been used together in Cube to benefit somewhat
-from both of their features, however, the resulting combinations of protocols
-still leaves much to be desired. TCP lacks multiple streams of communication
-without resorting to opening many sockets and complicates delineation of
-packets due to its buffering behavior. UDP lacks sequencing, connection
-management, management of bandwidth resources, and imposes limitations on
-the size of packets. A significant investment is required to integrate these
-two protocols, and the end result is worse off in features and performance
-than the uniform protocol presented by ENet.
-
- ENet thus attempts to address these issues and provide a single, uniform
-protocol layered over UDP to the developer with the best features of UDP and
-TCP as well as some useful features neither provide, with a much cleaner
-integration than any resulting from a mixture of UDP and TCP.
-
-* Connection management
-
- ENet provides a simple connection interface over which to communicate
-with a foreign host. The liveness of the connection is actively monitored
-by pinging the foreign host at frequent intervals, and also monitors the
-network conditions from the local host to the foreign host such as the
-mean round trip time and packet loss in this fashion.
-
-* Sequencing
-
- Rather than a single byte stream that complicates the delineation
-of packets, ENet presents connections as multiple, properly sequenced packet
-streams that simplify the transfer of various types of data.
-
- ENet provides sequencing for all packets by assigning to each sent
-packet a sequence number that is incremented as packets are sent. ENet
-guarentees that no packet with a higher sequence number will be delivered
-before a packet with a lower sequence number, thus ensuring packets are
-delivered exactly in the order they are sent.
-
- For unreliable packets, ENet will simply discard the lower sequence
-number packet if a packet with a higher sequence number has already been
-delivered. This allows the packets to be dispatched immediately as they
-arrive, and reduce latency of unreliable packets to an absolute minimum.
-For reliable packets, if a higher sequence number packet arrives, but the
-preceding packets in the sequence have not yet arrived, ENet will stall
-delivery of the higher sequence number packets until its predecessors
-have arrived.
-
-* Channels
-
- Since ENet will stall delivery of reliable packets to ensure proper
-sequencing, and consequently any packets of higher sequence number whether
-reliable or unreliable, in the event the reliable packet's predecessors
-have not yet arrived, this can introduce latency into the delivery of other
-packets which may not need to be as strictly ordered with respect to the
-packet that stalled their delivery.
-
- To combat this latency and reduce the ordering restrictions on packets,
-ENet provides multiple channels of communication over a given connection.
-Each channel is independently sequenced, and so the delivery status of
-a packet in one channel will not stall the delivery of other packets
-in another channel.
-
-* Reliability
-
- ENet provides optional reliability of packet delivery by ensuring the
-foreign host acknowledges receipt of all reliable packets. ENet will attempt
-to resend the packet up to a reasonable amount of times, if no acknowledgement
-of the packet's receipt happens within a specified timeout. Retry timeouts
-are progressive and become more lenient with every failed attempt to allow
-for temporary turbulence in network conditions.
-
-* Fragmentation and reassembly
-
- ENet will send and deliver packets regardless of size. Large packets are
-fragmented into many smaller packets of suitable size, and reassembled on
-the foreign host to recover the original packet for delivery. The process
-is entirely transparent to the developer.
-
-* Aggregation
-
- ENet aggregates all protocol commands, including acknowledgements and
-packet transfer, into larger protocol packets to ensure the proper utilization
-of the connection and to limit the opportunities for packet loss that might
-otherwise result in further delivery latency.
-
-* Adaptability
-
- ENet provides an in-flight data window for reliable packets to ensure
-connections are not overwhelmed by volumes of packets. It also provides a
-static bandwidth allocation mechanism to ensure the total volume of packets
-sent and received to a host don't exceed the host's capabilities. Further,
-ENet also provides a dynamic throttle that responds to deviations from normal
-network connections to rectify various types of network congestion by further
-limiting the volume of packets sent.
-
-* Portability
-
- ENet works on Windows and any other Unix or Unix-like platform providing
-a BSD sockets interface. The library has a small and stable code base that
-can easily be extended to support other platforms and integrates easily.
-
-* Freedom
-
- ENet demands no royalties and doesn't carry a viral license that would
-restrict you in how you might use it in your programs. ENet is licensed under
-a short-and-sweet MIT-style license, which gives you the freedom to do anything
-you want with it (well, almost anything).
-
-
--- a/Engine/src/enet/host.c
+++ /dev/null
@@ -1,390 +1,0 @@
-/**
- @file host.c
- @brief ENet host management functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "memory.h"
-#include "enet.h"
-
-/** @defgroup host ENet host functions
- @{-*/
-
-/** Creates a host for communicating to peers.
-
- @param address the address at which other peers may connect to this host. If NULL, then no peers may connect to the host.
- @param peerCount the maximum number of peers that should be allocated for the host.
- @param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
- @param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
-
- @returns the host on success and NULL on failure
-
- @remarks ENet will strategically drop packets on specific sides of a connection between hosts
- to ensure the host's bandwidth is not overwhelmed. The bandwidth parameters also determine
- the window size of a connection which limits the amount of reliable packets that may be in transit
- at any given time.
-*/
-ENetHost *
-enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
-{- ENetHost * host = (ENetHost *) enet_malloc (sizeof (ENetHost));
- ENetPeer * currentPeer;
-
- host -> peers = (ENetPeer *) enet_calloc (peerCount, sizeof (ENetPeer));
-
- host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM, address);
- if (host -> socket == ENET_SOCKET_NULL)
- {- enet_free (host -> peers);
- enet_free (host);
-
- return NULL;
- }
-
- if (address != NULL)
- host -> address = * address;
-
- host -> incomingBandwidth = incomingBandwidth;
- host -> outgoingBandwidth = outgoingBandwidth;
- host -> bandwidthThrottleEpoch = 0;
- host -> recalculateBandwidthLimits = 0;
- host -> mtu = ENET_HOST_DEFAULT_MTU;
- host -> peerCount = peerCount;
- host -> lastServicedPeer = host -> peers;
- host -> commandCount = 0;
- host -> bufferCount = 0;
- host -> receivedAddress.host = ENET_HOST_ANY;
- host -> receivedAddress.port = 0;
- host -> receivedDataLength = 0;
-
- for (currentPeer = host -> peers;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- currentPeer -> host = host;
- currentPeer -> incomingPeerID = currentPeer - host -> peers;
- currentPeer -> data = NULL;
-
- enet_list_clear (& currentPeer -> acknowledgements);
- enet_list_clear (& currentPeer -> sentReliableCommands);
- enet_list_clear (& currentPeer -> sentUnreliableCommands);
- enet_list_clear (& currentPeer -> outgoingReliableCommands);
- enet_list_clear (& currentPeer -> outgoingUnreliableCommands);
-
- enet_peer_reset (currentPeer);
- }
-
- return host;
-}
-
-/** Destroys the host and all resources associated with it.
- @param host pointer to the host to destroy
-*/
-void
-enet_host_destroy (ENetHost * host)
-{- ENetPeer * currentPeer;
-
- enet_socket_destroy (host -> socket);
-
- for (currentPeer = host -> peers;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- enet_peer_reset (currentPeer);
- }
-
- enet_free (host -> peers);
- enet_free (host);
-}
-
-/** Initiates a connection to a foreign host.
- @param host host seeking the connection
- @param address destination for the connection
- @param channelCount number of channels to allocate
- @returns a peer representing the foreign host on success, NULL on failure
- @remarks The peer returned will have not completed the connection until enet_host_service()
- notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
-*/
-ENetPeer *
-enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount)
-{- ENetPeer * currentPeer;
- ENetChannel * channel;
- ENetProtocol command;
-
- if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
- channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
- else
- if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
- channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-
- for (currentPeer = host -> peers;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
- break;
- }
-
- if (currentPeer >= & host -> peers [host -> peerCount])
- return NULL;
-
- currentPeer -> state = ENET_PEER_STATE_CONNECTING;
- currentPeer -> address = * address;
- currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
- currentPeer -> channelCount = channelCount;
- currentPeer -> challenge = (enet_uint32) rand ();
-
- if (host -> outgoingBandwidth == 0)
- currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
- else
- currentPeer -> windowSize = (host -> outgoingBandwidth /
- ENET_PEER_WINDOW_SIZE_SCALE) *
- ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
- if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
- currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
- else
- if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
- currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
- for (channel = currentPeer -> channels;
- channel < & currentPeer -> channels [channelCount];
- ++ channel)
- {- channel -> outgoingReliableSequenceNumber = 0;
- channel -> outgoingUnreliableSequenceNumber = 0;
- channel -> incomingReliableSequenceNumber = 0;
- channel -> incomingUnreliableSequenceNumber = 0;
-
- enet_list_clear (& channel -> incomingReliableCommands);
- enet_list_clear (& channel -> incomingUnreliableCommands);
- }
-
- command.header.command = ENET_PROTOCOL_COMMAND_CONNECT;
- command.header.channelID = 0xFF;
- command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
- command.header.commandLength = sizeof (ENetProtocolConnect);
- command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
- command.connect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu);
- command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize);
- command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
- command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
- command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
- command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
- command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
- command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
-
- enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0);
-
- return currentPeer;
-}
-
-/** Queues a packet to be sent to all peers associated with the host.
- @param host host on which to broadcast the packet
- @param channelID channel on which to broadcast
- @param packet packet to broadcast
-*/
-void
-enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
-{- ENetPeer * currentPeer;
-
- for (currentPeer = host -> peers;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
- continue;
-
- enet_peer_send (currentPeer, channelID, packet);
- }
-
- if (packet -> referenceCount == 0)
- enet_packet_destroy (packet);
-}
-
-/** Adjusts the bandwidth limits of a host.
- @param host host to adjust
- @param incomingBandwidth new incoming bandwidth
- @param outgoingBandwidth new outgoing bandwidth
- @remarks the incoming and outgoing bandwidth parameters are identical in function to those
- specified in enet_host_create().
-*/
-void
-enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
-{- host -> incomingBandwidth = incomingBandwidth;
- host -> outgoingBandwidth = outgoingBandwidth;
- host -> recalculateBandwidthLimits = 1;
-}
-
-void
-enet_host_bandwidth_throttle (ENetHost * host)
-{- enet_uint32 timeCurrent = enet_time_get (),
- elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
- peersTotal = 0,
- dataTotal = 0,
- peersRemaining,
- bandwidth,
- throttle = 0,
- bandwidthLimit = 0;
- int needsAdjustment;
- 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)
- continue;
-
- ++ peersTotal;
- dataTotal += peer -> outgoingDataTotal;
- }
-
- if (peersTotal == 0)
- return;
-
- peersRemaining = peersTotal;
- needsAdjustment = 1;
-
- if (host -> outgoingBandwidth == 0)
- bandwidth = ~0;
- else
- bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
-
- while (peersRemaining > 0 && needsAdjustment != 0)
- {- needsAdjustment = 0;
-
- if (dataTotal < bandwidth)
- throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
- else
- throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
-
- for (peer = host -> peers;
- peer < & host -> peers [host -> peerCount];
- ++ peer)
- {- enet_uint32 peerBandwidth;
-
- if (peer -> state != ENET_PEER_STATE_CONNECTED ||
- peer -> incomingBandwidth == 0 ||
- peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
- continue;
-
- peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000;
- if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth)
- continue;
-
- peer -> packetThrottleLimit = (peerBandwidth *
- ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal;
-
- if (peer -> packetThrottleLimit == 0)
- peer -> packetThrottleLimit = 1;
-
- if (peer -> packetThrottle > peer -> packetThrottleLimit)
- peer -> packetThrottle = peer -> packetThrottleLimit;
-
- peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
-
-
- needsAdjustment = 1;
- -- peersRemaining;
- bandwidth -= peerBandwidth;
- dataTotal -= peerBandwidth;
- }
- }
-
- if (peersRemaining > 0)
- for (peer = host -> peers;
- peer < & host -> peers [host -> peerCount];
- ++ peer)
- {- if (peer -> state != ENET_PEER_STATE_CONNECTED ||
- peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
- continue;
-
- peer -> packetThrottleLimit = throttle;
-
- if (peer -> packetThrottle > peer -> packetThrottleLimit)
- peer -> packetThrottle = peer -> packetThrottleLimit;
- }
-
- if (host -> recalculateBandwidthLimits)
- {- host -> recalculateBandwidthLimits = 0;
-
- peersRemaining = peersTotal;
- bandwidth = host -> incomingBandwidth;
- needsAdjustment = 1;
-
- if (bandwidth == 0)
- bandwidthLimit = 0;
- else
- while (peersRemaining > 0 && needsAdjustment != 0)
- {- needsAdjustment = 0;
- bandwidthLimit = bandwidth / peersRemaining;
-
- for (peer = host -> peers;
- peer < & host -> peers [host -> peerCount];
- ++ peer)
- {- if (peer -> state != ENET_PEER_STATE_CONNECTED ||
- peer -> incomingBandwidthThrottleEpoch == timeCurrent)
- continue;
-
- if (peer -> outgoingBandwidth > 0 &&
- bandwidthLimit > peer -> outgoingBandwidth)
- continue;
-
- peer -> incomingBandwidthThrottleEpoch = timeCurrent;
-
- needsAdjustment = 1;
- -- peersRemaining;
- bandwidth -= peer -> outgoingBandwidth;
- }
- }
-
- for (peer = host -> peers;
- peer < & host -> peers [host -> peerCount];
- ++ peer)
- {- if (peer -> state != ENET_PEER_STATE_CONNECTED)
- continue;
-
- command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT;
- command.header.channelID = 0xFF;
- command.header.flags = 0;
- command.header.commandLength = sizeof (ENetProtocolBandwidthLimit);
- command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
-
- if (peer -> incomingBandwidthThrottleEpoch == timeCurrent)
- command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth);
- else
- command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit);
-
- enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
- }
- }
-
- host -> bandwidthThrottleEpoch = timeCurrent;
-
- for (peer = host -> peers;
- peer < & host -> peers [host -> peerCount];
- ++ peer)
- {- peer -> incomingDataTotal = 0;
- peer -> outgoingDataTotal = 0;
- }
-}
-
-/** @} */
--- /dev/null
+++ b/Engine/src/enet/include/callbacks.h
@@ -1,0 +1,27 @@
+/**
+ @file callbacks.h
+ @brief ENet callbacks
+*/
+#ifndef __ENET_CALLBACKS_H__
+#define __ENET_CALLBACKS_H__
+
+#include <stdlib.h>
+
+typedef struct _ENetCallbacks
+{+ void * (ENET_CALLBACK * malloc) (size_t size);
+ void (ENET_CALLBACK * free) (void * memory);
+ void (ENET_CALLBACK * no_memory) (void);
+} ENetCallbacks;
+
+/** @defgroup callbacks ENet internal callbacks
+ @{+ @ingroup private
+*/
+extern void * enet_malloc (size_t);
+extern void enet_free (void *);
+
+/** @} */
+
+#endif /* __ENET_CALLBACKS_H__ */
+
--- a/Engine/src/enet/include/enet.h
+++ b/Engine/src/enet/include/enet.h
@@ -12,62 +12,83 @@
#include <stdlib.h>
-#include "types.h"
-#include "protocol.h"
-#include "list.h"
-
-#ifdef WIN32
-#include "win32.h"
+#ifdef _WIN32
+#include "enet/win32.h"
#else
-#include "unix.h"
+#include "enet/unix.h"
#endif
-#ifdef ENET_API
-#undef ENET_API
-#endif
+#include "enet/types.h"
+#include "enet/protocol.h"
+#include "enet/list.h"
+#include "enet/callbacks.h"
-#if defined WIN32
-#if defined ENET_DLL
-#if defined ENET_BUILDING_LIB
-#define ENET_API __declspec( dllexport )
-#else
-#define ENET_API __declspec( dllimport )
-#endif /* ENET_BUILDING_LIB */
-#endif /* ENET_DLL */
-#endif /* WIN32 */
+#define ENET_VERSION_MAJOR 1
+#define ENET_VERSION_MINOR 3
+#define ENET_VERSION_PATCH 13
+#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
+#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
+#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
+#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
+#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-#ifndef ENET_API
-#define ENET_API extern
-#endif
+typedef enet_uint32 ENetVersion;
-typedef enum
+struct _ENetHost;
+struct _ENetEvent;
+struct _ENetPacket;
+
+typedef enum _ENetSocketType
{ENET_SOCKET_TYPE_STREAM = 1,
ENET_SOCKET_TYPE_DATAGRAM = 2
} ENetSocketType;
-typedef enum
+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;
-enum
+typedef enum _ENetSocketOption
{- ENET_HOST_ANY = 0
-};
+ ENET_SOCKOPT_NONBLOCK = 1,
+ ENET_SOCKOPT_BROADCAST = 2,
+ ENET_SOCKOPT_RCVBUF = 3,
+ ENET_SOCKOPT_SNDBUF = 4,
+ ENET_SOCKOPT_REUSEADDR = 5,
+ ENET_SOCKOPT_RCVTIMEO = 6,
+ ENET_SOCKOPT_SNDTIMEO = 7,
+ ENET_SOCKOPT_ERROR = 8,
+ ENET_SOCKOPT_NODELAY = 9
+} ENetSocketOption;
+typedef enum _ENetSocketShutdown
+{+ ENET_SOCKET_SHUTDOWN_READ = 0,
+ ENET_SOCKET_SHUTDOWN_WRITE = 1,
+ ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
+} ENetSocketShutdown;
+
+#define ENET_HOST_ANY 0
+#define ENET_HOST_BROADCAST 0xFFFFFFFFU
+#define ENET_PORT_ANY 0
+
/**
* Portable internet address structure.
*
* The host must be specified in network byte-order, and the port must be in host
* byte-order. The constant ENET_HOST_ANY may be used to specify the default
- * server host.
+ * server host. The constant ENET_HOST_BROADCAST may be used to specify the
+ * broadcast address (255.255.255.255). This makes sense for enet_host_connect,
+ * but not for enet_host_create. Once a server responds to a broadcast, the
+ * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
*/
typedef struct _ENetAddress
{- enet_uint32 host; /**< may use ENET_HOST_ANY to specify default server host */
+ enet_uint32 host;
enet_uint16 port;
} ENetAddress;
@@ -80,13 +101,27 @@
@sa ENetPacket
*/
-typedef enum
+typedef enum _ENetPacketFlag
{/** packet must be received by the target peer and resend attempts should be
* made until the packet is delivered */
- ENET_PACKET_FLAG_RELIABLE = (1 << 0)
+ ENET_PACKET_FLAG_RELIABLE = (1 << 0),
+ /** packet will not be sequenced with other packets
+ * not supported for reliable packets
+ */
+ ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
+ /** packet will not allocate data, and user must supply it instead */
+ ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
+ /** packet will be fragmented using unreliable (instead of reliable) sends
+ * if it exceeds the MTU */
+ ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
+
+ /** whether the packet has been sent from all queues it has been entered into */
+ ENET_PACKET_FLAG_SENT = (1<<8)
} ENetPacketFlag;
+typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
+
/**
* ENet packet structure.
*
@@ -96,16 +131,24 @@
* of the allocated data. The flags field is either 0 (specifying no flags),
* or a bitwise-or of any combination of the following flags:
*
- * ENET_PACKET_FLAG_RELIABLE - packet must be received by the ta
-
+ * ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
+ * and resend attempts should be made until the packet is delivered
+ *
+ * ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets
+ * (not supported for reliable packets)
+ *
+ * ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
+
@sa ENetPacketFlag
*/
typedef struct _ENetPacket
{- size_t referenceCount; /**< internal use only */
- enet_uint32 flags; /**< bitwise or of ENetPacketFlag constants */
- enet_uint8 * data; /**< allocated data for packet */
- size_t dataLength; /**< length of data */
+ size_t referenceCount; /**< internal use only */
+ enet_uint32 flags; /**< bitwise-or of ENetPacketFlag constants */
+ enet_uint8 * data; /**< allocated data for packet */
+ size_t dataLength; /**< length of data */
+ ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
+ void * userData; /**< application private data, may be freely modified */
} ENetPacket;
typedef struct _ENetAcknowledgement
@@ -118,13 +161,14 @@
typedef struct _ENetOutgoingCommand
{ENetListNode outgoingCommandList;
- enet_uint32 reliableSequenceNumber;
- enet_uint32 unreliableSequenceNumber;
+ enet_uint16 reliableSequenceNumber;
+ enet_uint16 unreliableSequenceNumber;
enet_uint32 sentTime;
enet_uint32 roundTripTimeout;
enet_uint32 roundTripTimeoutLimit;
enet_uint32 fragmentOffset;
enet_uint16 fragmentLength;
+ enet_uint16 sendAttempts;
ENetProtocol command;
ENetPacket * packet;
} ENetOutgoingCommand;
@@ -132,8 +176,8 @@
typedef struct _ENetIncomingCommand
{ ENetListNode incomingCommandList;
- enet_uint32 reliableSequenceNumber;
- enet_uint32 unreliableSequenceNumber;
+ enet_uint16 reliableSequenceNumber;
+ enet_uint16 unreliableSequenceNumber;
ENetProtocol command;
enet_uint32 fragmentCount;
enet_uint32 fragmentsRemaining;
@@ -141,15 +185,18 @@
ENetPacket * packet;
} ENetIncomingCommand;
-typedef enum
+typedef enum _ENetPeerState
{ENET_PEER_STATE_DISCONNECTED = 0,
ENET_PEER_STATE_CONNECTING = 1,
ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
- ENET_PEER_STATE_CONNECTED = 3,
- ENET_PEER_STATE_DISCONNECTING = 4,
- ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 5,
- ENET_PEER_STATE_ZOMBIE = 6
+ ENET_PEER_STATE_CONNECTION_PENDING = 3,
+ ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
+ ENET_PEER_STATE_CONNECTED = 5,
+ ENET_PEER_STATE_DISCONNECT_LATER = 6,
+ ENET_PEER_STATE_DISCONNECTING = 7,
+ ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
+ ENET_PEER_STATE_ZOMBIE = 9
} ENetPeerState;
#ifndef ENET_BUFFER_MAXIMUM
@@ -159,8 +206,11 @@
enum
{ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
+ ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
ENET_HOST_DEFAULT_MTU = 1400,
+ ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE = 32 * 1024 * 1024,
+ ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
@@ -173,15 +223,25 @@
ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
ENET_PEER_TIMEOUT_LIMIT = 32,
- ENET_PEER_PING_INTERVAL = 500
+ ENET_PEER_TIMEOUT_MINIMUM = 5000,
+ ENET_PEER_TIMEOUT_MAXIMUM = 30000,
+ ENET_PEER_PING_INTERVAL = 500,
+ ENET_PEER_UNSEQUENCED_WINDOWS = 64,
+ ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
+ ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
+ ENET_PEER_RELIABLE_WINDOWS = 16,
+ ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
+ ENET_PEER_FREE_RELIABLE_WINDOWS = 8
};
typedef struct _ENetChannel
{- enet_uint32 outgoingReliableSequenceNumber;
- enet_uint32 outgoingUnreliableSequenceNumber;
- enet_uint32 incomingReliableSequenceNumber;
- enet_uint32 incomingUnreliableSequenceNumber;
+ enet_uint16 outgoingReliableSequenceNumber;
+ enet_uint16 outgoingUnreliableSequenceNumber;
+ enet_uint16 usedReliableWindows;
+ enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
+ enet_uint16 incomingReliableSequenceNumber;
+ enet_uint16 incomingUnreliableSequenceNumber;
ENetList incomingReliableCommands;
ENetList incomingUnreliableCommands;
} ENetChannel;
@@ -193,10 +253,13 @@
*/
typedef struct _ENetPeer
{ + ENetListNode dispatchList;
struct _ENetHost * host;
enet_uint16 outgoingPeerID;
enet_uint16 incomingPeerID;
- enet_uint32 challenge;
+ enet_uint32 connectID;
+ enet_uint8 outgoingSessionID;
+ enet_uint8 incomingSessionID;
ENetAddress address; /**< Internet address of the peer */
void * data; /**< Application private data, may be freely modified */
ENetPeerState state;
@@ -211,6 +274,7 @@
enet_uint32 lastSendTime;
enet_uint32 lastReceiveTime;
enet_uint32 nextTimeout;
+ enet_uint32 earliestTimeout;
enet_uint32 packetLossEpoch;
enet_uint32 packetsSent;
enet_uint32 packetsLost;
@@ -223,6 +287,10 @@
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
enet_uint32 packetThrottleInterval;
+ enet_uint32 pingInterval;
+ enet_uint32 timeoutLimit;
+ enet_uint32 timeoutMinimum;
+ enet_uint32 timeoutMaximum;
enet_uint32 lastRoundTripTime;
enet_uint32 lowestRoundTripTime;
enet_uint32 lastRoundTripTimeVariance;
@@ -229,20 +297,47 @@
enet_uint32 highestRoundTripTimeVariance;
enet_uint32 roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
enet_uint32 roundTripTimeVariance;
- enet_uint16 mtu;
+ enet_uint32 mtu;
enet_uint32 windowSize;
enet_uint32 reliableDataInTransit;
- enet_uint32 outgoingReliableSequenceNumber;
+ enet_uint16 outgoingReliableSequenceNumber;
ENetList acknowledgements;
ENetList sentReliableCommands;
ENetList sentUnreliableCommands;
ENetList outgoingReliableCommands;
ENetList outgoingUnreliableCommands;
+ ENetList dispatchedCommands;
+ int needsDispatch;
+ enet_uint16 incomingUnsequencedGroup;
+ enet_uint16 outgoingUnsequencedGroup;
+ enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
+ enet_uint32 eventData;
+ size_t totalWaitingData;
} ENetPeer;
+/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
+ */
+typedef struct _ENetCompressor
+{+ /** Context data for the compressor. Must be non-NULL. */
+ void * context;
+ /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
+ size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
+ /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
+ size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
+ /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
+ void (ENET_CALLBACK * destroy) (void * context);
+} ENetCompressor;
+
+/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
+typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
+
+/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
+typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
+
/** An ENet host for communicating with peers.
*
- * No fields should be modified.
+ * No fields should be modified unless otherwise stated.
@sa enet_host_create()
@sa enet_host_destroy()
@@ -250,35 +345,56 @@
@sa enet_host_service()
@sa enet_host_flush()
@sa enet_host_broadcast()
+ @sa enet_host_compress()
+ @sa enet_host_compress_with_range_coder()
+ @sa enet_host_channel_limit()
@sa enet_host_bandwidth_limit()
@sa enet_host_bandwidth_throttle()
*/
typedef struct _ENetHost
{- ENetSocket socket;
- ENetAddress address; /**< Internet address of the host */
- enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */
- enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */
- enet_uint32 bandwidthThrottleEpoch;
- enet_uint32 mtu;
- int recalculateBandwidthLimits;
- ENetPeer * peers; /**< array of peers allocated for this host */
- size_t peerCount; /**< number of peers allocated for this host */
- ENetPeer * lastServicedPeer;
- size_t packetSize;
- ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
- size_t commandCount;
- ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
- size_t bufferCount;
- ENetAddress receivedAddress;
- enet_uint8 receivedData [ENET_PROTOCOL_MAXIMUM_MTU];
- size_t receivedDataLength;
+ ENetSocket socket;
+ ENetAddress address; /**< Internet address of the host */
+ enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */
+ enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */
+ enet_uint32 bandwidthThrottleEpoch;
+ enet_uint32 mtu;
+ enet_uint32 randomSeed;
+ int recalculateBandwidthLimits;
+ ENetPeer * peers; /**< array of peers allocated for this host */
+ size_t peerCount; /**< number of peers allocated for this host */
+ size_t channelLimit; /**< maximum number of channels allowed for connected peers */
+ enet_uint32 serviceTime;
+ ENetList dispatchQueue;
+ int continueSending;
+ size_t packetSize;
+ enet_uint16 headerFlags;
+ ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
+ size_t commandCount;
+ ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
+ size_t bufferCount;
+ ENetChecksumCallback checksum; /**< callback the user can set to enable packet checksums for this host */
+ ENetCompressor compressor;
+ enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
+ ENetAddress receivedAddress;
+ enet_uint8 * receivedData;
+ size_t receivedDataLength;
+ enet_uint32 totalSentData; /**< total data sent, user should reset to 0 as needed to prevent overflow */
+ enet_uint32 totalSentPackets; /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
+ enet_uint32 totalReceivedData; /**< total data received, user should reset to 0 as needed to prevent overflow */
+ enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
+ ENetInterceptCallback intercept; /**< callback the user can set to intercept received raw UDP packets */
+ size_t connectedPeers;
+ size_t bandwidthLimitedPeers;
+ size_t duplicatePeers; /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
+ size_t maximumPacketSize; /**< the maximum allowable packet size that may be sent or received on a peer */
+ size_t maximumWaitingData; /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
} ENetHost;
/**
* An ENet event type, as specified in @ref ENetEvent.
*/
-typedef enum
+typedef enum _ENetEventType
{/** no event occurred within the specified time limit */
ENET_EVENT_TYPE_NONE = 0,
@@ -292,7 +408,8 @@
* completion of a disconnect initiated by enet_pper_disconnect, if
* a peer has timed out, or if a connection request intialized by
* enet_host_connect has timed out. The peer field contains the peer
- * which disconnected.
+ * which disconnected. The data field contains user supplied data
+ * describing the disconnection, or 0, if none is available.
*/
ENET_EVENT_TYPE_DISCONNECT = 2,
@@ -314,8 +431,9 @@
{ENetEventType type; /**< type of the event */
ENetPeer * peer; /**< peer that generated a connect, disconnect or receive event */
- enet_uint8 channelID;
- ENetPacket * packet;
+ enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */
+ enet_uint32 data; /**< data associated with the event, if appropriate */
+ ENetPacket * packet; /**< packet associated with the event, if appropriate */
} ENetEvent;
/** @defgroup global ENet global functions
@@ -330,20 +448,25 @@
ENET_API int enet_initialize (void);
/**
+ Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
+
+ @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
+ @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
+ @returns 0 on success, < 0 on failure
+*/
+ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
+
+/**
Shuts down ENet globally. Should be called when a program that has
initialized ENet exits.
*/
ENET_API void enet_deinitialize (void);
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
/**
- Returns the time in milliseconds. Its initial value is unspecified
- unless otherwise set.
- */
-ENET_API enet_uint32 enet_time_get_raw (void);
+ Gives the linked version of the ENet library.
+ @returns the version number
+*/
+ENET_API ENetVersion enet_linked_version (void);
/** @} */
@@ -361,15 +484,21 @@
/** @defgroup socket ENet socket functions
@{- @ingroup private
*/
-extern ENetSocket enet_socket_create (ENetSocketType, const ENetAddress *);
-extern ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
-extern int enet_socket_connect (ENetSocket, const ENetAddress *);
-extern int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-extern int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-extern int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
-extern void enet_socket_destroy (ENetSocket);
+ENET_API ENetSocket enet_socket_create (ENetSocketType);
+ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
+ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
+ENET_API int enet_socket_listen (ENetSocket, int);
+ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
+ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
+ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
+ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
+ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_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);
/** @} */
@@ -384,9 +513,19 @@
@retval < 0 on failure
@returns the address of the given hostName in address on success
*/
-extern int enet_address_set_host (ENetAddress *address, const char *hostName );
+ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
-/** Attempts to do a reserve lookup of the host field in the address parameter.
+/** Gives the printable form of the IP address specified in the address parameter.
+ @param address address printed
+ @param hostName destination for name, must not be NULL
+ @param nameLength maximum length of hostName.
+ @returns the null-terminated name of the host in hostName on success
+ @retval 0 on success
+ @retval < 0 on failure
+*/
+ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
+
+/** Attempts to do a reverse lookup of the host field in the address parameter.
@param address address used for reverse lookup
@param hostName destination for name, must not be NULL
@param nameLength maximum length of hostName.
@@ -394,35 +533,56 @@
@retval 0 on success
@retval < 0 on failure
*/
-extern int enet_address_get_host (const ENetAddress *address, char *hostName, size_t nameLength );
+ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
/** @} */
-ENET_API ENetPacket * enet_packet_create (const void *dataContents, size_t dataLength, enet_uint32 flags);
-ENET_API void enet_packet_destroy (ENetPacket *packet );
-ENET_API int enet_packet_resize (ENetPacket *packet, size_t dataLength );
-
-ENET_API ENetHost * enet_host_create (const ENetAddress *address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth );
-ENET_API void enet_host_destroy (ENetHost *host );
-ENET_API ENetPeer * enet_host_connect (ENetHost *host, const ENetAddress *address, size_t channelCount );
+ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
+ENET_API void enet_packet_destroy (ENetPacket *);
+ENET_API int enet_packet_resize (ENetPacket *, size_t);
+ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
+
+ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
+ENET_API void enet_host_destroy (ENetHost *);
+ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
+ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
ENET_API void enet_host_flush (ENetHost *);
ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
+ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
+ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
+ENET_API void enet_host_channel_limit (ENetHost *, size_t);
ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
extern void enet_host_bandwidth_throttle (ENetHost *);
+extern enet_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);
+ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
ENET_API void enet_peer_ping (ENetPeer *);
+ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32);
+ENET_API void enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
ENET_API void enet_peer_reset (ENetPeer *);
-ENET_API void enet_peer_disconnect (ENetPeer *);
-ENET_API void enet_peer_disconnect_now (ENetPeer *);
+ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
+ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32);
+ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32);
ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
extern int enet_peer_throttle (ENetPeer *, enet_uint32);
extern void enet_peer_reset_queues (ENetPeer *);
+extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
-extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
-extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint32);
+extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
+extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
+extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
+extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
+extern void enet_peer_on_connect (ENetPeer *);
+extern void enet_peer_on_disconnect (ENetPeer *);
+
+ENET_API void * enet_range_coder_create (void);
+ENET_API void enet_range_coder_destroy (void *);
+ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
+ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
+
+extern size_t enet_protocol_command_size (enet_uint8);
#ifdef __cplusplus
}
--- a/Engine/src/enet/include/list.h
+++ b/Engine/src/enet/include/list.h
@@ -24,6 +24,7 @@
extern ENetListIterator enet_list_insert (ENetListIterator, void *);
extern void * enet_list_remove (ENetListIterator);
+extern ENetListIterator enet_list_move (ENetListIterator, void *, void *);
extern size_t enet_list_size (ENetList *);
--- a/Engine/src/enet/include/memory.h
+++ /dev/null
@@ -1,22 +1,0 @@
-/**
- @file memory.h
- @brief ENet memory management
-*/
-#ifndef __ENET_MEMORY_H__
-#define __ENET_MEMORY_H__
-
-#include <stdlib.h>
-
-/** @defgroup memory ENet internal memory management
- @{- @ingroup private
-*/
-extern void * enet_malloc (size_t);
-extern void * enet_realloc (void *, size_t);
-extern void * enet_calloc (size_t, size_t);
-extern void enet_free (void *);
-
-/** @} */
-
-#endif /* __ENET_MEMORY_H__ */
-
--- a/Engine/src/enet/include/protocol.h
+++ b/Engine/src/enet/include/protocol.h
@@ -5,7 +5,7 @@
#ifndef __ENET_PROTOCOL_H__
#define __ENET_PROTOCOL_H__
-#include "types.h"
+#include "enet/types.h"
enum
{@@ -13,12 +13,14 @@
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_CHANNEL_COUNT = 255,
+ ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF,
+ ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT = 1024 * 1024
};
-typedef enum
+typedef enum _ENetProtocolCommand
{ENET_PROTOCOL_COMMAND_NONE = 0,
ENET_PROTOCOL_COMMAND_ACKNOWLEDGE = 1,
@@ -29,46 +31,64 @@
ENET_PROTOCOL_COMMAND_SEND_RELIABLE = 6,
ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE = 7,
ENET_PROTOCOL_COMMAND_SEND_FRAGMENT = 8,
- ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 9,
- ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 10
+ ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 9,
+ ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 10,
+ ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
+ ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
+ ENET_PROTOCOL_COMMAND_COUNT = 13,
+
+ ENET_PROTOCOL_COMMAND_MASK = 0x0F
} ENetProtocolCommand;
-typedef enum
+typedef enum _ENetProtocolFlag
{- ENET_PROTOCOL_FLAG_ACKNOWLEDGE = (1 << 0)
+ ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
+ ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
+
+ ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14),
+ ENET_PROTOCOL_HEADER_FLAG_SENT_TIME = (1 << 15),
+ ENET_PROTOCOL_HEADER_FLAG_MASK = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
+
+ ENET_PROTOCOL_HEADER_SESSION_MASK = (3 << 12),
+ ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12
} ENetProtocolFlag;
-typedef struct
+#ifdef _MSC_VER
+#pragma pack(push, 1)
+#define ENET_PACKED
+#elif defined(__GNUC__) || defined(__clang__)
+#define ENET_PACKED __attribute__ ((packed))
+#else
+#define ENET_PACKED
+#endif
+
+typedef struct _ENetProtocolHeader
{enet_uint16 peerID;
- enet_uint8 flags;
- enet_uint8 commandCount;
- enet_uint32 sentTime;
- enet_uint32 challenge;
-} ENetProtocolHeader;
+ enet_uint16 sentTime;
+} ENET_PACKED ENetProtocolHeader;
-typedef struct
+typedef struct _ENetProtocolCommandHeader
{enet_uint8 command;
enet_uint8 channelID;
- enet_uint8 flags;
- enet_uint8 reserved;
- enet_uint32 commandLength;
- enet_uint32 reliableSequenceNumber;
-} ENetProtocolCommandHeader;
+ enet_uint16 reliableSequenceNumber;
+} ENET_PACKED ENetProtocolCommandHeader;
-typedef struct
+typedef struct _ENetProtocolAcknowledge
{ENetProtocolCommandHeader header;
- enet_uint32 receivedReliableSequenceNumber;
- enet_uint32 receivedSentTime;
-} ENetProtocolAcknowledge;
+ enet_uint16 receivedReliableSequenceNumber;
+ enet_uint16 receivedSentTime;
+} ENET_PACKED ENetProtocolAcknowledge;
-typedef struct
+typedef struct _ENetProtocolConnect
{ENetProtocolCommandHeader header;
enet_uint16 outgoingPeerID;
- enet_uint16 mtu;
+ enet_uint8 incomingSessionID;
+ enet_uint8 outgoingSessionID;
+ enet_uint32 mtu;
enet_uint32 windowSize;
enet_uint32 channelCount;
enet_uint32 incomingBandwidth;
@@ -76,13 +96,17 @@
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
-} ENetProtocolConnect;
+ enet_uint32 connectID;
+ enet_uint32 data;
+} ENET_PACKED ENetProtocolConnect;
-typedef struct
+typedef struct _ENetProtocolVerifyConnect
{ENetProtocolCommandHeader header;
enet_uint16 outgoingPeerID;
- enet_uint16 mtu;
+ enet_uint8 incomingSessionID;
+ enet_uint8 outgoingSessionID;
+ enet_uint32 mtu;
enet_uint32 windowSize;
enet_uint32 channelCount;
enet_uint32 incomingBandwidth;
@@ -90,55 +114,67 @@
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
-} ENetProtocolVerifyConnect;
+ enet_uint32 connectID;
+} ENET_PACKED ENetProtocolVerifyConnect;
-typedef struct
+typedef struct _ENetProtocolBandwidthLimit
{ENetProtocolCommandHeader header;
enet_uint32 incomingBandwidth;
enet_uint32 outgoingBandwidth;
-} ENetProtocolBandwidthLimit;
+} ENET_PACKED ENetProtocolBandwidthLimit;
-typedef struct
+typedef struct _ENetProtocolThrottleConfigure
{ENetProtocolCommandHeader header;
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
-} ENetProtocolThrottleConfigure;
+} ENET_PACKED ENetProtocolThrottleConfigure;
-typedef struct
+typedef struct _ENetProtocolDisconnect
{ENetProtocolCommandHeader header;
-} ENetProtocolDisconnect;
+ enet_uint32 data;
+} ENET_PACKED ENetProtocolDisconnect;
-typedef struct
+typedef struct _ENetProtocolPing
{ENetProtocolCommandHeader header;
-} ENetProtocolPing;
+} ENET_PACKED ENetProtocolPing;
-typedef struct
+typedef struct _ENetProtocolSendReliable
{ENetProtocolCommandHeader header;
-} ENetProtocolSendReliable;
+ enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendReliable;
-typedef struct
+typedef struct _ENetProtocolSendUnreliable
{ENetProtocolCommandHeader header;
- enet_uint32 unreliableSequenceNumber;
-} ENetProtocolSendUnreliable;
+ enet_uint16 unreliableSequenceNumber;
+ enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendUnreliable;
-typedef struct
+typedef struct _ENetProtocolSendUnsequenced
{ENetProtocolCommandHeader header;
- enet_uint32 startSequenceNumber;
+ enet_uint16 unsequencedGroup;
+ enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendUnsequenced;
+
+typedef struct _ENetProtocolSendFragment
+{+ ENetProtocolCommandHeader header;
+ enet_uint16 startSequenceNumber;
+ enet_uint16 dataLength;
enet_uint32 fragmentCount;
enet_uint32 fragmentNumber;
enet_uint32 totalLength;
enet_uint32 fragmentOffset;
-} ENetProtocolSendFragment;
+} ENET_PACKED ENetProtocolSendFragment;
-typedef union
+typedef union _ENetProtocol
{ENetProtocolCommandHeader header;
ENetProtocolAcknowledge acknowledge;
@@ -148,10 +184,15 @@
ENetProtocolPing ping;
ENetProtocolSendReliable sendReliable;
ENetProtocolSendUnreliable sendUnreliable;
+ ENetProtocolSendUnsequenced sendUnsequenced;
ENetProtocolSendFragment sendFragment;
ENetProtocolBandwidthLimit bandwidthLimit;
ENetProtocolThrottleConfigure throttleConfigure;
-} ENetProtocol;
+} ENET_PACKED ENetProtocol;
+
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif
#endif /* __ENET_PROTOCOL_H__ */
--- a/Engine/src/enet/include/types.h
+++ b/Engine/src/enet/include/types.h
@@ -1,4 +1,4 @@
-/**
+/**
@file types.h
@brief type definitions for ENet
*/
@@ -5,14 +5,8 @@
#ifndef __ENET_TYPES_H__
#define __ENET_TYPES_H__
-#ifdef _WIN32
- #include "../../windows/inttypes.h"
-#else
- #include <inttypes.h>
-#endif
-
-typedef uint8_t enet_uint8; /**< unsigned 8-bit type */
-typedef uint16_t enet_uint16; /**< unsigned 16-bit type */
+typedef unsigned char enet_uint8; /**< unsigned 8-bit type */
+typedef unsigned short enet_uint16; /**< unsigned 16-bit type */
typedef unsigned int enet_uint32; /**< unsigned 32-bit type */
#endif /* __ENET_TYPES_H__ */
--- a/Engine/src/enet/include/unix.h
+++ b/Engine/src/enet/include/unix.h
@@ -6,15 +6,19 @@
#define __ENET_UNIX_H__
#include <stdlib.h>
+#include <sys/time.h>
#include <sys/types.h>
+#include <sys/socket.h>
#include <netinet/in.h>
+#include <unistd.h>
+#ifdef MSG_MAXIOVLEN
+#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
+#endif
+
typedef int ENetSocket;
-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 */
@@ -28,5 +32,16 @@
size_t dataLength;
} ENetBuffer;
+#define ENET_CALLBACK
+
+#define ENET_API extern
+
+typedef fd_set ENetSocketSet;
+
+#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
+#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
+#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
+#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
+
#endif /* __ENET_UNIX_H__ */
--- a/Engine/src/enet/include/win32.h
+++ b/Engine/src/enet/include/win32.h
@@ -5,15 +5,21 @@
#ifndef __ENET_WIN32_H__
#define __ENET_WIN32_H__
+#ifdef _MSC_VER
+#ifdef ENET_BUILDING_LIB
+#pragma warning (disable: 4267) // size_t to int conversion
+#pragma warning (disable: 4244) // 64bit to 32bit int
+#pragma warning (disable: 4018) // signed/unsigned mismatch
+#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
+#endif
+#endif
+
#include <stdlib.h>
#include <winsock2.h>
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))
@@ -26,6 +32,25 @@
size_t dataLength;
void * data;
} ENetBuffer;
+
+#define ENET_CALLBACK __cdecl
+
+#ifdef ENET_DLL
+#ifdef ENET_BUILDING_LIB
+#define ENET_API __declspec( dllexport )
+#else
+#define ENET_API __declspec( dllimport )
+#endif /* ENET_BUILDING_LIB */
+#else /* !ENET_DLL */
+#define ENET_API extern
+#endif /* ENET_DLL */
+
+typedef fd_set ENetSocketSet;
+
+#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
+#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
+#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
+#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
#endif /* __ENET_WIN32_H__ */
--- a/Engine/src/enet/list.c
+++ /dev/null
@@ -1,57 +1,0 @@
-/**
- @file list.c
- @brief ENet linked list functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "list.h"
-
-/**
- @defgroup list ENet linked list utility functions
- @ingroup private
- @{-*/
-void
-enet_list_clear (ENetList * list)
-{- list -> sentinel.next = & list -> sentinel;
- list -> sentinel.previous = & list -> sentinel;
-}
-
-ENetListIterator
-enet_list_insert (ENetListIterator position, void * data)
-{- ENetListIterator result = (ENetListIterator) data;
-
- result -> previous = position -> previous;
- result -> next = position;
-
- result -> previous -> next = result;
- position -> previous = result;
-
- return result;
-}
-
-void *
-enet_list_remove (ENetListIterator position)
-{- position -> previous -> next = position -> next;
- position -> next -> previous = position -> previous;
-
- return position;
-}
-
-size_t
-enet_list_size (ENetList * list)
-{- size_t size = 0;
- ENetListIterator position;
-
- for (position = enet_list_begin (list);
- position != enet_list_end (list);
- position = enet_list_next (position))
- ++ size;
-
- return size;
-}
-
-/** @} */
--- a/Engine/src/enet/memory.c
+++ /dev/null
@@ -1,48 +1,0 @@
-/**
- @file memory.c
- @brief ENet memory management functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "types.h"
-#include "memory.h"
-
-void *
-enet_malloc (size_t size)
-{- void * memory = malloc (size);
-
- if (memory == NULL)
- abort ();
-
- return memory;
-}
-
-void *
-enet_realloc (void * memory, size_t size)
-{- memory = realloc (memory, size);
-
- if (size > 0 &&
- memory == NULL)
- abort ();
-
- return memory;
-}
-
-void *
-enet_calloc (size_t elements, size_t size)
-{- void * memory = calloc (elements, size);
-
- if (memory == NULL)
- abort ();
-
- return memory;
-}
-
-void
-enet_free (void * memory)
-{- free (memory);
-}
-
--- a/Engine/src/enet/packet.c
+++ /dev/null
@@ -1,73 +1,0 @@
-/**
- @file packet.c
- @brief ENet packet management functions
-*/
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "memory.h"
-#include "enet.h"
-
-/** @defgroup Packet ENet packet functions
- @{ -*/
-
-/** 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 dataLength size of the data allocated for this packet
- @param flags flags for this packet as described for the ENetPacket structure.
- @returns the packet on success, NULL on failure
-*/
-ENetPacket *
-enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
-{- ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
-
- packet -> data = (enet_uint8 *) enet_malloc (dataLength);
-
- if (data != NULL)
- memcpy (packet -> data, data, dataLength);
-
- packet -> referenceCount = 0;
- packet -> flags = flags;
- packet -> dataLength = dataLength;
-
- return packet;
-}
-
-/** Destroys the packet and deallocates its data.
- @param packet packet to be destroyed
-*/
-void
-enet_packet_destroy (ENetPacket * packet)
-{- enet_free (packet -> data);
- enet_free (packet);
-}
-
-/** Attempts to resize the data in the packet to length specified in the
- dataLength parameter
- @param packet packet to resize
- @param dataLength new size for the packet data
- @returns 0 on success, < 0 on failure
-*/
-int
-enet_packet_resize (ENetPacket * packet, size_t dataLength)
-{- enet_uint8 * newData;
-
- if (dataLength <= packet -> dataLength)
- {- packet -> dataLength = dataLength;
-
- return 0;
- }
-
- newData = (enet_uint8 *) enet_realloc (packet -> data, dataLength);
-
- packet -> data = newData;
- packet -> dataLength = dataLength;
-
- return 0;
-}
-
-/** @} */
--- a/Engine/src/enet/peer.c
+++ /dev/null
@@ -1,613 +1,0 @@
-/**
- @file peer.c
- @brief ENet peer management functions
-*/
-#define ENET_BUILDING_LIB 1
-#include "memory.h"
-#include "enet.h"
-
-/** @defgroup peer ENet peer functions
- @{-*/
-
-/** Configures throttle parameter for a peer.
-
- Unreliable packets are dropped by ENet in response to the varying conditions
- of the Internet connection to the peer. The throttle represents a probability
- that an unreliable packet should not be dropped and thus sent by ENet to the peer.
- The lowest mean round trip time from the sending of a reliable packet to the
- receipt of its acknowledgement is measured over an amount of time specified by
- the interval parameter in milliseconds. If a measured round trip time happens to
- be significantly less than the mean round trip time measured over the interval,
- then the throttle probability is increased to allow more traffic by an amount
- specified in the acceleration parameter, which is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
- constant. If a measured round trip time happens to be significantly greater than
- the mean round trip time measured over the interval, then the throttle probability
- is decreased to limit traffic by an amount specified in the deceleration parameter, which
- is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE constant. When the throttle has
- a value of ENET_PEER_PACKET_THROTTLE_SCALE, on unreliable packets are dropped by
- ENet, and so 100% of all unreliable packets will be sent. When the throttle has a
- value of 0, all unreliable packets are dropped by ENet, and so 0% of all unreliable
- packets will be sent. Intermediate values for the throttle represent intermediate
- probabilities between 0% and 100% of unreliable packets being sent. The bandwidth
- limits of the local and foreign hosts are taken into account to determine a
- sensible limit for the throttle probability above which it should not raise even in
- the best of conditions.
-
- @param peer peer to configure
- @param interval interval, in milliseconds, over which to measure lowest mean RTT; the default value is ENET_PEER_PACKET_THROTTLE_INTERVAL.
- @param acceleration rate at which to increase the throttle probability as mean RTT declines
- @param deceleration rate at which to decrease the throttle probability as mean RTT increases
-*/
-void
-enet_peer_throttle_configure (ENetPeer * peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration)
-{- ENetProtocol command;
-
- peer -> packetThrottleInterval = interval;
- peer -> packetThrottleAcceleration = acceleration;
- peer -> packetThrottleDeceleration = deceleration;
-
- command.header.command = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE;
- command.header.channelID = 0xFF;
- command.header.flags = 0;
- command.header.commandLength = sizeof (ENetProtocolThrottleConfigure);
-
- command.throttleConfigure.packetThrottleInterval = ENET_HOST_TO_NET_32 (interval);
- command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (acceleration);
- command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (deceleration);
-
- enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-}
-
-int
-enet_peer_throttle (ENetPeer * peer, enet_uint32 rtt)
-{- if (peer -> lastRoundTripTime <= peer -> lastRoundTripTimeVariance)
- {- peer -> packetThrottle = peer -> packetThrottleLimit;
- }
- else
- if (rtt < peer -> lastRoundTripTime)
- {- peer -> packetThrottle += peer -> packetThrottleAcceleration;
-
- if (peer -> packetThrottle > peer -> packetThrottleLimit)
- peer -> packetThrottle = peer -> packetThrottleLimit;
-
- return 1;
- }
- else
- if (rtt > peer -> lastRoundTripTime + 2 * peer -> lastRoundTripTimeVariance)
- {- if (peer -> packetThrottle > peer -> packetThrottleDeceleration)
- peer -> packetThrottle -= peer -> packetThrottleDeceleration;
- else
- peer -> packetThrottle = 0;
-
- return -1;
- }
-
- return 0;
-}
-
-/** Queues a packet to be sent.
- @param peer destination for the packet
- @param channelID channel on which to send
- @param packet packet to send
- @retval 0 on success
- @retval < 0 on failure
-*/
-int
-enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet)
-{- ENetChannel * channel = & peer -> channels [channelID];
- ENetProtocol command;
- size_t fragmentLength;
-
- if (peer -> state != ENET_PEER_STATE_CONNECTED)
- return -1;
-
- fragmentLength = peer -> mtu - sizeof (ENetProtocolHeader) - sizeof (ENetProtocolSendFragment);
-
- if (packet -> dataLength > fragmentLength)
- {- enet_uint32 fragmentCount = ENET_HOST_TO_NET_32 ((packet -> dataLength + fragmentLength - 1) / fragmentLength),
- startSequenceNumber = ENET_HOST_TO_NET_32 (channel -> outgoingReliableSequenceNumber + 1),
- fragmentNumber,
- fragmentOffset;
-
- packet -> flags |= ENET_PACKET_FLAG_RELIABLE;
-
- for (fragmentNumber = 0,
- fragmentOffset = 0;
- fragmentOffset < packet -> dataLength;
- ++ fragmentNumber,
- fragmentOffset += fragmentLength)
- {- command.header.command = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT;
- command.header.channelID = channelID;
- command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
- command.header.commandLength = sizeof (ENetProtocolSendFragment);
- command.sendFragment.startSequenceNumber = startSequenceNumber;
- command.sendFragment.fragmentCount = fragmentCount;
- command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32 (fragmentNumber);
- command.sendFragment.totalLength = ENET_HOST_TO_NET_32 (packet -> dataLength);
- command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32 (fragmentOffset);
-
- if (packet -> dataLength - fragmentOffset < fragmentLength)
- fragmentLength = packet -> dataLength - fragmentOffset;
-
- enet_peer_queue_outgoing_command (peer, & command, packet, fragmentOffset, fragmentLength);
- }
-
- return 0;
- }
-
- command.header.channelID = channelID;
-
- if (packet -> flags & ENET_PACKET_FLAG_RELIABLE)
- {- command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE;
- command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
- command.header.commandLength = sizeof (ENetProtocolSendReliable);
- }
- else
- {- command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
- command.header.flags = 0;
- command.header.commandLength = sizeof (ENetProtocolSendUnreliable);
- command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_32 (channel -> outgoingUnreliableSequenceNumber + 1);
- }
-
- enet_peer_queue_outgoing_command (peer, & command, packet, 0, packet -> dataLength);
-
- return 0;
-}
-
-/** Attempts to dequeue any incoming queued packet.
- @param peer peer to dequeue packets from
- @param channelID channel on which to receive
- @returns a pointer to the packet, or NULL if there are no available incoming queued packets
-*/
-ENetPacket *
-enet_peer_receive (ENetPeer * peer, enet_uint8 channelID)
-{- ENetChannel * channel = & peer -> channels [channelID];
- ENetIncomingCommand * incomingCommand = NULL;
- ENetPacket * packet;
-
- if (enet_list_empty (& channel -> incomingUnreliableCommands) == 0)
- {- incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingUnreliableCommands);
-
- if (incomingCommand -> reliableSequenceNumber > channel -> incomingReliableSequenceNumber)
- incomingCommand = NULL;
- else
- channel -> incomingUnreliableSequenceNumber = incomingCommand -> unreliableSequenceNumber;
- }
-
- if (incomingCommand == NULL &&
- enet_list_empty (& channel -> incomingReliableCommands) == 0)
- {- do
- {- incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingReliableCommands);
-
- if (incomingCommand -> fragmentsRemaining > 0 ||
- incomingCommand -> reliableSequenceNumber > channel -> incomingReliableSequenceNumber + 1)
- return NULL;
-
- if (incomingCommand -> reliableSequenceNumber <= channel -> incomingReliableSequenceNumber)
- {- -- incomingCommand -> packet -> referenceCount;
-
- if (incomingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (incomingCommand -> packet);
-
- if (incomingCommand -> fragments != NULL)
- enet_free (incomingCommand -> fragments);
-
- enet_list_remove (& incomingCommand -> incomingCommandList);
-
- enet_free (incomingCommand);
-
- incomingCommand = NULL;
- }
- } while (incomingCommand == NULL &&
- enet_list_empty (& channel -> incomingReliableCommands) == 0);
-
- if (incomingCommand == NULL)
- return NULL;
-
- channel -> incomingReliableSequenceNumber = incomingCommand -> reliableSequenceNumber;
-
- if (incomingCommand -> fragmentCount > 0)
- channel -> incomingReliableSequenceNumber += incomingCommand -> fragmentCount - 1;
- }
-
- if (incomingCommand == NULL)
- return NULL;
-
- enet_list_remove (& incomingCommand -> incomingCommandList);
-
- packet = incomingCommand -> packet;
-
- -- packet -> referenceCount;
-
- if (incomingCommand -> fragments != NULL)
- enet_free (incomingCommand -> fragments);
-
- enet_free (incomingCommand);
-
- return packet;
-}
-
-static void
-enet_peer_reset_outgoing_commands (ENetList * queue)
-{- ENetOutgoingCommand * outgoingCommand;
-
- while (enet_list_empty (queue) == 0)
- {- outgoingCommand = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (queue));
-
- if (outgoingCommand -> packet != NULL)
- {- -- outgoingCommand -> packet -> referenceCount;
-
- if (outgoingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (outgoingCommand -> packet);
- }
-
- enet_free (outgoingCommand);
- }
-}
-
-static void
-enet_peer_reset_incoming_commands (ENetList * queue)
-{- ENetIncomingCommand * incomingCommand;
-
- while (enet_list_empty (queue) == 0)
- {- incomingCommand = (ENetIncomingCommand *) enet_list_remove (enet_list_begin (queue));
-
- if (incomingCommand -> packet != NULL)
- {- -- incomingCommand -> packet -> referenceCount;
-
- if (incomingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (incomingCommand -> packet);
- }
-
- enet_free (incomingCommand);
- }
-}
-
-void
-enet_peer_reset_queues (ENetPeer * peer)
-{- ENetChannel * channel;
-
- while (enet_list_empty (& peer -> acknowledgements) == 0)
- enet_free (enet_list_remove (enet_list_begin (& peer -> acknowledgements)));
-
- enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands);
- enet_peer_reset_outgoing_commands (& peer -> sentUnreliableCommands);
- enet_peer_reset_outgoing_commands (& peer -> outgoingReliableCommands);
- enet_peer_reset_outgoing_commands (& peer -> outgoingUnreliableCommands);
-
- if (peer -> channels != NULL && peer -> channelCount > 0)
- {- for (channel = peer -> channels;
- channel < & peer -> channels [peer -> channelCount];
- ++ channel)
- {- enet_peer_reset_incoming_commands (& channel -> incomingReliableCommands);
- enet_peer_reset_incoming_commands (& channel -> incomingUnreliableCommands);
- }
-
- enet_free (peer -> channels);
- }
-
- peer -> channels = NULL;
- peer -> channelCount = 0;
-}
-
-/** Forcefully disconnects a peer.
- @param peer peer to forcefully disconnect
- @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
- on its connection to the local host.
-*/
-void
-enet_peer_reset (ENetPeer * peer)
-{- peer -> outgoingPeerID = 0xFFFF;
- peer -> challenge = 0;
-
- peer -> address.host = ENET_HOST_ANY;
- peer -> address.port = 0;
-
- peer -> state = ENET_PEER_STATE_DISCONNECTED;
-
- peer -> incomingBandwidth = 0;
- peer -> outgoingBandwidth = 0;
- peer -> incomingBandwidthThrottleEpoch = 0;
- peer -> outgoingBandwidthThrottleEpoch = 0;
- peer -> incomingDataTotal = 0;
- peer -> outgoingDataTotal = 0;
- peer -> lastSendTime = 0;
- peer -> lastReceiveTime = 0;
- peer -> nextTimeout = 0;
- peer -> packetLossEpoch = 0;
- peer -> packetsSent = 0;
- peer -> packetsLost = 0;
- peer -> packetLoss = 0;
- peer -> packetLossVariance = 0;
- peer -> packetThrottle = ENET_PEER_DEFAULT_PACKET_THROTTLE;
- peer -> packetThrottleLimit = ENET_PEER_PACKET_THROTTLE_SCALE;
- peer -> packetThrottleCounter = 0;
- peer -> packetThrottleEpoch = 0;
- peer -> packetThrottleAcceleration = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
- peer -> packetThrottleDeceleration = ENET_PEER_PACKET_THROTTLE_DECELERATION;
- peer -> packetThrottleInterval = ENET_PEER_PACKET_THROTTLE_INTERVAL;
- peer -> lastRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
- peer -> lowestRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
- peer -> lastRoundTripTimeVariance = 0;
- peer -> highestRoundTripTimeVariance = 0;
- peer -> roundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
- peer -> roundTripTimeVariance = 0;
- peer -> mtu = peer -> host -> mtu;
- peer -> reliableDataInTransit = 0;
- peer -> outgoingReliableSequenceNumber = 0;
- peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
- enet_peer_reset_queues (peer);
-}
-
-/** Sends a ping request to a peer.
- @param peer destination for the ping request
- @remarks ping requests factor into the mean round trip time as designated by the
- roundTripTime field in the ENetPeer structure. Enet automatically pings all connected
- peers at regular intervals, however, this function may be called to ensure more
- frequent ping requests.
-*/
-void
-enet_peer_ping (ENetPeer * peer)
-{- ENetProtocol command;
-
- if (peer -> state != ENET_PEER_STATE_CONNECTED)
- return;
-
- command.header.command = ENET_PROTOCOL_COMMAND_PING;
- command.header.channelID = 0xFF;
- command.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
- command.header.commandLength = sizeof (ENetProtocolPing);
-
- enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-}
-
-/** Force an immediate disconnection from a peer.
- @param peer peer to disconnect
- @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
- return from this function.
-*/
-void
-enet_peer_disconnect_now (ENetPeer * peer)
-{- ENetProtocol command;
-
- if (peer -> state != ENET_PEER_STATE_DISCONNECTED)
- return;
-
- if (peer -> state != ENET_PEER_STATE_ZOMBIE &&
- peer -> state != ENET_PEER_STATE_DISCONNECTING)
- {- enet_peer_reset_queues (peer);
-
- command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT;
- command.header.channelID = 0xFF;
- command.header.flags = 0;
- command.header.commandLength = sizeof (ENetProtocolDisconnect);
-
- enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-
- enet_host_flush (peer -> host);
- }
-
- enet_peer_reset (peer);
-}
-
-/** Request a disconnection from a peer.
- @param peer peer to request a disconnection
- @remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
- once the disconnection is complete.
-*/
-void
-enet_peer_disconnect (ENetPeer * peer)
-{- ENetProtocol command;
-
- if (peer -> state == ENET_PEER_STATE_DISCONNECTING ||
- peer -> state == ENET_PEER_STATE_DISCONNECTED ||
- peer -> state == ENET_PEER_STATE_ZOMBIE)
- return;
-
- enet_peer_reset_queues (peer);
-
- command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT;
- command.header.channelID = 0xFF;
- command.header.flags = 0;
- command.header.commandLength = sizeof (ENetProtocolDisconnect);
-
- if (peer -> state == ENET_PEER_STATE_CONNECTED)
- command.header.flags |= ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
-
- enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
-
- if (peer -> state == ENET_PEER_STATE_CONNECTED)
- peer -> state = ENET_PEER_STATE_DISCONNECTING;
- else
- {- enet_host_flush (peer -> host);
- enet_peer_reset (peer);
- }
-}
-
-ENetAcknowledgement *
-enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint32 sentTime)
-{- ENetAcknowledgement * acknowledgement;
-
- peer -> outgoingDataTotal += sizeof (ENetProtocolAcknowledge);
-
- acknowledgement = (ENetAcknowledgement *) enet_malloc (sizeof (ENetAcknowledgement));
-
- acknowledgement -> sentTime = sentTime;
- acknowledgement -> command = * command;
-
- enet_list_insert (enet_list_end (& peer -> acknowledgements), acknowledgement);
-
- return acknowledgement;
-}
-
-ENetOutgoingCommand *
-enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 offset, enet_uint16 length)
-{- ENetChannel * channel = & peer -> channels [command -> header.channelID];
- ENetOutgoingCommand * outgoingCommand;
-
- peer -> outgoingDataTotal += command -> header.commandLength + length;
-
- outgoingCommand = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand));
-
- if (command -> header.channelID == 0xFF)
- {- ++ peer -> outgoingReliableSequenceNumber;
-
- outgoingCommand -> reliableSequenceNumber = peer -> outgoingReliableSequenceNumber;
- outgoingCommand -> unreliableSequenceNumber = 0;
- }
- else
- if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE)
- {- ++ channel -> outgoingReliableSequenceNumber;
-
- outgoingCommand -> reliableSequenceNumber = channel -> outgoingReliableSequenceNumber;
- outgoingCommand -> unreliableSequenceNumber = 0;
- }
- else
- {- ++ channel -> outgoingUnreliableSequenceNumber;
-
- outgoingCommand -> reliableSequenceNumber = channel -> outgoingReliableSequenceNumber;
- outgoingCommand -> unreliableSequenceNumber = channel -> outgoingUnreliableSequenceNumber;
- }
-
- outgoingCommand -> sentTime = 0;
- outgoingCommand -> roundTripTimeout = 0;
- outgoingCommand -> roundTripTimeoutLimit = 0;
- outgoingCommand -> fragmentOffset = offset;
- outgoingCommand -> fragmentLength = length;
- outgoingCommand -> packet = packet;
- outgoingCommand -> command = * command;
- outgoingCommand -> command.header.reliableSequenceNumber = ENET_HOST_TO_NET_32 (outgoingCommand -> reliableSequenceNumber);
-
- if (packet != NULL)
- ++ packet -> referenceCount;
-
- if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE)
- enet_list_insert (enet_list_end (& peer -> outgoingReliableCommands), outgoingCommand);
- else
- enet_list_insert (enet_list_end (& peer -> outgoingUnreliableCommands), outgoingCommand);
-
- return outgoingCommand;
-}
-
-ENetIncomingCommand *
-enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 fragmentCount)
-{- ENetChannel * channel = & peer -> channels [command -> header.channelID];
- enet_uint32 unreliableSequenceNumber = 0;
- ENetIncomingCommand * incomingCommand;
- ENetListIterator currentCommand;
-
- if (command -> header.command == ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE)
- unreliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> sendUnreliable.unreliableSequenceNumber);
-
- if (unreliableSequenceNumber == 0)
- {- for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
- currentCommand != enet_list_end (& channel -> incomingReliableCommands);
- currentCommand = enet_list_previous (currentCommand))
- {- incomingCommand = (ENetIncomingCommand *) currentCommand;
-
- if (incomingCommand -> reliableSequenceNumber <= command -> header.reliableSequenceNumber)
- {- if (incomingCommand -> reliableSequenceNumber < command -> header.reliableSequenceNumber)
- break;
-
- goto freePacket;
- }
- }
- }
- else
- {- if (command -> header.reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
- goto freePacket;
-
- if (unreliableSequenceNumber <= channel -> incomingUnreliableSequenceNumber)
- goto freePacket;
-
- for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands));
- currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);
- currentCommand = enet_list_previous (currentCommand))
- {- incomingCommand = (ENetIncomingCommand *) currentCommand;
-
- if (incomingCommand -> unreliableSequenceNumber <= unreliableSequenceNumber)
- {- if (incomingCommand -> unreliableSequenceNumber < unreliableSequenceNumber)
- break;
-
- goto freePacket;
- }
- }
- }
-
- incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand));
-
- incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber;
- incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber;
- incomingCommand -> command = * command;
- incomingCommand -> fragmentCount = fragmentCount;
- incomingCommand -> fragmentsRemaining = fragmentCount;
- incomingCommand -> packet = packet;
-
- if (fragmentCount > 0)
- incomingCommand -> fragments = (enet_uint32 *) enet_calloc ((fragmentCount + 31) / 32, sizeof (enet_uint32));
- else
- incomingCommand -> fragments = NULL;
-
- if (packet != NULL)
- ++ packet -> referenceCount;
-
- enet_list_insert (enet_list_next (currentCommand), incomingCommand);
-
- return incomingCommand;
-
-freePacket:
- if (packet != NULL)
- {- if (packet -> referenceCount == 0)
- enet_packet_destroy (packet);
- }
-
- return NULL;
-}
-
-/** @} */
--- a/Engine/src/enet/protocol.c
+++ /dev/null
@@ -1,1259 +1,0 @@
-/**
- @file protocol.c
- @brief ENet protocol functions
-*/
-#include <stdio.h>
-#include <string.h>
-#define ENET_BUILDING_LIB 1
-#include "utility.h"
-#include "memory.h"
-#include "time.h"
-#include "enet.h"
-
-static enet_uint32 timeCurrent;
-
-static int
-enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
-{- ENetPeer * currentPeer = host -> lastServicedPeer;
- ENetChannel * channel;
-
- do
- {- ++ currentPeer;
-
- if (currentPeer >= & host -> peers [host -> peerCount])
- currentPeer = host -> peers;
-
- if (currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
- {- host -> recalculateBandwidthLimits = 1;
-
- event -> type = ENET_EVENT_TYPE_DISCONNECT;
- event -> peer = currentPeer;
-
- enet_peer_reset (currentPeer);
-
- host -> lastServicedPeer = currentPeer;
-
- return 1;
- }
-
- if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
- continue;
-
- for (channel = currentPeer -> channels;
- channel < & currentPeer -> channels [currentPeer -> channelCount];
- ++ channel)
- {- if (enet_list_empty (& channel -> incomingReliableCommands) &&
- enet_list_empty (& channel -> incomingUnreliableCommands))
- continue;
-
- event -> packet = enet_peer_receive (currentPeer, channel - currentPeer -> channels);
- if (event -> packet == NULL)
- continue;
-
- event -> type = ENET_EVENT_TYPE_RECEIVE;
- event -> peer = currentPeer;
- event -> channelID = (enet_uint8) (channel - currentPeer -> channels);
-
- host -> lastServicedPeer = currentPeer;
-
- return 1;
- }
- } while (currentPeer != host -> lastServicedPeer);
-
- return 0;
-}
-
-static void
-enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
-{- ENetOutgoingCommand * outgoingCommand;
-
- while (enet_list_empty (& peer -> sentUnreliableCommands) == 0)
- {- outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands);
-
- enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
- if (outgoingCommand -> packet != NULL)
- {- -- outgoingCommand -> packet -> referenceCount;
-
- if (outgoingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (outgoingCommand -> packet);
- }
-
- enet_free (outgoingCommand);
- }
-}
-
-static ENetProtocolCommand
-enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint32 reliableSequenceNumber, enet_uint8 channelID)
-{- ENetOutgoingCommand * outgoingCommand;
- ENetListIterator currentCommand;
- ENetProtocolCommand commandNumber;
-
- for (currentCommand = enet_list_begin (& peer -> sentReliableCommands);
- currentCommand != enet_list_end (& peer -> sentReliableCommands);
- currentCommand = enet_list_next (currentCommand))
- {- outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
- if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
- outgoingCommand -> command.header.channelID == channelID)
- break;
- }
-
- if (currentCommand == enet_list_end (& peer -> sentReliableCommands))
- return ENET_PROTOCOL_COMMAND_NONE;
-
- commandNumber = outgoingCommand -> command.header.command;
-
- enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
- if (outgoingCommand -> packet != NULL)
- {- peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
-
- -- outgoingCommand -> packet -> referenceCount;
-
- if (outgoingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (outgoingCommand -> packet);
- }
-
- enet_free (outgoingCommand);
-
- if (enet_list_empty (& peer -> sentReliableCommands))
- return commandNumber;
-
- outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentReliableCommands);
-
- peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
-
- return commandNumber;
-}
-
-static ENetPeer *
-enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header, const ENetProtocol * command)
-{- enet_uint16 mtu;
- enet_uint32 windowSize;
- ENetChannel * channel;
- size_t channelCount;
- ENetPeer * currentPeer;
- ENetProtocol verifyCommand;
-
- if (command -> header.commandLength < sizeof (ENetProtocolConnect))
- return NULL;
-
- channelCount = ENET_NET_TO_HOST_32 (command -> connect.channelCount);
-
- if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||
- channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
- return NULL;
-
- for (currentPeer = host -> peers;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
- break;
-
- if (currentPeer -> address.host == host -> receivedAddress.host &&
- currentPeer -> address.port == host -> receivedAddress.port &&
- currentPeer -> challenge == header -> challenge)
- {- enet_peer_reset (currentPeer);
- break;
- }
- }
-
- if (currentPeer >= & host -> peers [host -> peerCount])
- return NULL;
-
- currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
- currentPeer -> challenge = header -> challenge;
- 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 -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
- currentPeer -> channelCount = channelCount;
-
- for (channel = currentPeer -> channels;
- channel < & currentPeer -> channels [channelCount];
- ++ channel)
- {- channel -> outgoingReliableSequenceNumber = 0;
- channel -> outgoingUnreliableSequenceNumber = 0;
- channel -> incomingReliableSequenceNumber = 0;
- channel -> incomingUnreliableSequenceNumber = 0;
-
- enet_list_clear (& channel -> incomingReliableCommands);
- enet_list_clear (& channel -> incomingUnreliableCommands);
- }
-
- mtu = ENET_NET_TO_HOST_16 (command -> connect.mtu);
-
- if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
- mtu = ENET_PROTOCOL_MINIMUM_MTU;
- else
- if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
- mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-
- currentPeer -> mtu = mtu;
-
- if (host -> outgoingBandwidth == 0 &&
- currentPeer -> incomingBandwidth == 0)
- currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
- else
- currentPeer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, currentPeer -> 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;
- else
- if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
- currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
- if (host -> incomingBandwidth == 0)
- windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
- else
- windowSize = (host -> incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) *
- ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
- if (windowSize > ENET_NET_TO_HOST_32 (command -> connect.windowSize))
- windowSize = ENET_NET_TO_HOST_32 (command -> connect.windowSize);
-
- if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
- windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
- else
- if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
- windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
- verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT;
- verifyCommand.header.channelID = 0xFF;
- verifyCommand.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
- verifyCommand.header.commandLength = sizeof (ENetProtocolVerifyConnect);
- verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
- verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu);
- verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize);
- 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);
-
- enet_peer_queue_outgoing_command (currentPeer, & verifyCommand, NULL, 0, 0);
-
- return currentPeer;
-}
-
-static void
-enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- ENetPacket * packet;
-
- if (command -> header.commandLength <= sizeof (ENetProtocolSendReliable) ||
- command -> header.channelID >= peer -> channelCount ||
- peer -> state != ENET_PEER_STATE_CONNECTED)
- return;
-
- packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable),
- command -> header.commandLength - sizeof (ENetProtocolSendReliable),
- ENET_PACKET_FLAG_RELIABLE);
-
- enet_peer_queue_incoming_command (peer, command, packet, 0);
-}
-
-static void
-enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- ENetPacket * packet;
-
- if (command -> header.commandLength <= sizeof (ENetProtocolSendUnreliable) ||
- command -> header.channelID >= peer -> channelCount ||
- peer -> state != ENET_PEER_STATE_CONNECTED)
- return;
-
- packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable),
- command -> header.commandLength - sizeof (ENetProtocolSendUnreliable),
- 0);
-
- enet_peer_queue_incoming_command (peer, command, packet, 0);
-}
-
-static void
-enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- enet_uint32 fragmentNumber,
- fragmentCount,
- fragmentOffset,
- fragmentLength,
- startSequenceNumber,
- totalLength;
- ENetChannel * channel;
- ENetListIterator currentCommand;
- ENetIncomingCommand * startCommand;
-
- if (command -> header.commandLength <= sizeof (ENetProtocolSendFragment) ||
- command -> header.channelID >= peer -> channelCount ||
- peer -> state != ENET_PEER_STATE_CONNECTED)
- return;
-
- startSequenceNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.startSequenceNumber);
- fragmentNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentNumber);
- fragmentCount = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentCount);
- fragmentOffset = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentOffset);
- totalLength = ENET_NET_TO_HOST_32 (command -> sendFragment.totalLength);
- fragmentLength = command -> header.commandLength - sizeof (ENetProtocolSendFragment);
-
- if (fragmentOffset >= totalLength ||
- fragmentOffset + fragmentLength > totalLength ||
- fragmentNumber >= fragmentCount)
- return;
-
- channel = & peer -> channels [command -> header.channelID];
-
- if (startSequenceNumber <= channel -> incomingReliableSequenceNumber)
- return;
-
- for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
- currentCommand != enet_list_end (& channel -> incomingReliableCommands);
- currentCommand = enet_list_previous (currentCommand))
- {- startCommand = (ENetIncomingCommand *) currentCommand;
-
- if (startCommand -> command.header.command == ENET_PROTOCOL_COMMAND_SEND_FRAGMENT &&
- startCommand -> command.sendFragment.startSequenceNumber == startSequenceNumber)
- break;
- }
-
- if (currentCommand == enet_list_end (& channel -> incomingReliableCommands))
- {- ENetProtocol hostCommand = * command;
-
- hostCommand.sendFragment.startSequenceNumber = startSequenceNumber;
- hostCommand.sendFragment.fragmentNumber = fragmentNumber;
- hostCommand.sendFragment.fragmentCount = fragmentCount;
- hostCommand.sendFragment.fragmentOffset = fragmentOffset;
- hostCommand.sendFragment.totalLength = totalLength;
-
- startCommand = enet_peer_queue_incoming_command (peer,
- & hostCommand,
- enet_packet_create (NULL, totalLength, ENET_PACKET_FLAG_RELIABLE),
- fragmentCount);
- }
- else
- if (totalLength != startCommand -> packet -> dataLength ||
- fragmentCount != startCommand -> fragmentCount)
- return;
-
- if ((startCommand -> fragments [fragmentNumber / 32] & (1 << fragmentNumber)) == 0)
- -- startCommand -> fragmentsRemaining;
-
- startCommand -> fragments [fragmentNumber / 32] |= (1 << fragmentNumber);
-
- if (fragmentOffset + fragmentLength > startCommand -> packet -> dataLength)
- fragmentLength = startCommand -> packet -> dataLength - fragmentOffset;
-
- memcpy (startCommand -> packet -> data + fragmentOffset,
- (enet_uint8 *) command + sizeof (ENetProtocolSendFragment),
- fragmentLength);
-}
-
-static void
-enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- if (command -> header.commandLength < sizeof (ENetProtocolPing))
- return;
-}
-
-static void
-enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- if (command -> header.commandLength < sizeof (ENetProtocolBandwidthLimit))
- return;
-
- peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.incomingBandwidth);
- peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth);
-
- if (peer -> incomingBandwidth == 0 &&
- host -> outgoingBandwidth == 0)
- peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
- else
- peer -> windowSize = (ENET_MIN (peer -> incomingBandwidth, host -> outgoingBandwidth) /
- ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
- if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
- peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
- else
- if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
- peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-}
-
-static void
-enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- if (command -> header.commandLength < sizeof (ENetProtocolThrottleConfigure))
- return;
-
- peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleInterval);
- peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration);
- peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleDeceleration);
-}
-
-static void
-enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
-{- if (command -> header.commandLength < sizeof (ENetProtocolDisconnect))
- return;
-
- enet_peer_reset_queues (peer);
-
- if (peer -> state != ENET_PEER_STATE_CONNECTED)
- enet_peer_reset (peer);
- else
- if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE)
- peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT;
- else
- peer -> state = ENET_PEER_STATE_ZOMBIE;
-}
-
-static int
-enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
-{- enet_uint32 roundTripTime,
- receivedSentTime,
- receivedReliableSequenceNumber;
- ENetProtocolCommand commandNumber;
-
- if (command -> header.commandLength < sizeof (ENetProtocolAcknowledge))
- return 0;
-
- receivedSentTime = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedSentTime);
-
- if (ENET_TIME_LESS (timeCurrent, receivedSentTime))
- return 0;
-
- peer -> lastReceiveTime = timeCurrent;
-
- roundTripTime = ENET_TIME_DIFFERENCE (timeCurrent, receivedSentTime);
-
- enet_peer_throttle (peer, roundTripTime);
-
- peer -> roundTripTimeVariance -= peer -> roundTripTimeVariance / 4;
-
- if (roundTripTime >= peer -> roundTripTime)
- {- peer -> roundTripTime += (roundTripTime - peer -> roundTripTime) / 8;
- peer -> roundTripTimeVariance += (roundTripTime - peer -> roundTripTime) / 4;
- }
- else
- {- peer -> roundTripTime -= (peer -> roundTripTime - roundTripTime) / 8;
- peer -> roundTripTimeVariance += (peer -> roundTripTime - roundTripTime) / 4;
- }
-
- if (peer -> roundTripTime < peer -> lowestRoundTripTime)
- peer -> lowestRoundTripTime = peer -> roundTripTime;
-
- if (peer -> roundTripTimeVariance > peer -> highestRoundTripTimeVariance)
- peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
-
- if (peer -> packetThrottleEpoch == 0 ||
- ENET_TIME_DIFFERENCE(timeCurrent, peer -> packetThrottleEpoch) >= peer -> packetThrottleInterval)
- {- peer -> lastRoundTripTime = peer -> lowestRoundTripTime;
- peer -> lastRoundTripTimeVariance = peer -> highestRoundTripTimeVariance;
- peer -> lowestRoundTripTime = peer -> roundTripTime;
- peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
- peer -> packetThrottleEpoch = timeCurrent;
- }
-
- receivedReliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedReliableSequenceNumber);
-
- commandNumber = enet_protocol_remove_sent_reliable_command (peer, receivedReliableSequenceNumber, command -> header.channelID);
-
- switch (peer -> state)
- {- case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
- if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT)
- return 0;
-
- host -> recalculateBandwidthLimits = 1;
-
- peer -> state = ENET_PEER_STATE_CONNECTED;
-
- event -> type = ENET_EVENT_TYPE_CONNECT;
- event -> peer = peer;
-
- return 1;
-
- case ENET_PEER_STATE_DISCONNECTING:
- if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT)
- return 0;
-
- host -> recalculateBandwidthLimits = 1;
-
- event -> type = ENET_EVENT_TYPE_DISCONNECT;
- event -> peer = peer;
-
- enet_peer_reset (peer);
-
- return 1;
-
- default:
- break;
- }
-
- return 0;
-}
-
-static void
-enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
-{- enet_uint16 mtu;
- enet_uint32 windowSize;
-
- if (command -> header.commandLength < sizeof (ENetProtocolVerifyConnect) ||
- peer -> state != ENET_PEER_STATE_CONNECTING)
- return;
-
- if (ENET_NET_TO_HOST_32 (command -> verifyConnect.channelCount) != peer -> channelCount ||
- ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleInterval) != peer -> packetThrottleInterval ||
- ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleAcceleration) != peer -> packetThrottleAcceleration ||
- ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleDeceleration) != peer -> packetThrottleDeceleration)
- {- peer -> state = ENET_PEER_STATE_ZOMBIE;
-
- return;
- }
-
- peer -> state = ENET_PEER_STATE_CONNECTED;
-
- peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> verifyConnect.outgoingPeerID);
-
- mtu = ENET_NET_TO_HOST_16 (command -> verifyConnect.mtu);
-
- if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
- mtu = ENET_PROTOCOL_MINIMUM_MTU;
- else
- if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
- mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-
- if (mtu < peer -> mtu)
- peer -> mtu = mtu;
-
- windowSize = ENET_NET_TO_HOST_32 (command -> verifyConnect.windowSize);
-
- if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
- windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-
- if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
- windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-
- if (windowSize < peer -> windowSize)
- peer -> windowSize = windowSize;
-
- peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.incomingBandwidth);
- peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.outgoingBandwidth);
-
- host -> recalculateBandwidthLimits = 1;
-
- peer -> state = ENET_PEER_STATE_CONNECTED;
-
- event -> type = ENET_EVENT_TYPE_CONNECT;
- event -> peer = peer;
-}
-
-static int
-enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
-{- ENetProtocolHeader * header;
- ENetProtocol * command;
- ENetPeer * peer;
- enet_uint8 * currentData;
- size_t commandCount;
-
- if (host -> receivedDataLength < sizeof (ENetProtocolHeader))
- return 0;
-
- header = (ENetProtocolHeader *) host -> receivedData;
-
- header -> peerID = ENET_NET_TO_HOST_16 (header -> peerID);
- header -> sentTime = ENET_NET_TO_HOST_32 (header -> sentTime);
-
- if (header -> peerID == 0xFFFF)
- peer = NULL;
- else
- if (header -> peerID >= host -> peerCount)
- return 0;
- else
- {- peer = & host -> peers [header -> peerID];
-
- if (peer -> state == ENET_PEER_STATE_DISCONNECTED ||
- peer -> state == ENET_PEER_STATE_ZOMBIE ||
- host -> receivedAddress.host != peer -> address.host ||
- header -> challenge != peer -> challenge)
- return 0;
- else
- peer -> address.port = host -> receivedAddress.port;
- }
-
- if (peer != NULL)
- peer -> incomingDataTotal += host -> receivedDataLength;
-
- commandCount = header -> commandCount;
- currentData = host -> receivedData + sizeof (ENetProtocolHeader);
-
- while (commandCount > 0 &&
- currentData < & host -> receivedData [host -> receivedDataLength])
- {- command = (ENetProtocol *) currentData;
-
- if (currentData + sizeof (ENetProtocolCommandHeader) > & host -> receivedData [host -> receivedDataLength])
- return 0;
-
- command -> header.commandLength = ENET_NET_TO_HOST_32 (command -> header.commandLength);
-
- if (currentData + command -> header.commandLength > & host -> receivedData [host -> receivedDataLength])
- return 0;
-
- -- commandCount;
- currentData += command -> header.commandLength;
-
- if (peer == NULL)
- {- if (command -> header.command != ENET_PROTOCOL_COMMAND_CONNECT)
- return 0;
- }
-
- command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> header.reliableSequenceNumber);
-
- switch (command -> header.command)
- {- case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
- enet_protocol_handle_acknowledge (host, event, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_CONNECT:
- peer = enet_protocol_handle_connect (host, header, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
- enet_protocol_handle_verify_connect (host, event, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_DISCONNECT:
- enet_protocol_handle_disconnect (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_PING:
- enet_protocol_handle_ping (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
- enet_protocol_handle_send_reliable (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
- enet_protocol_handle_send_unreliable (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
- enet_protocol_handle_send_fragment (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
- enet_protocol_handle_bandwidth_limit (host, peer, command);
-
- break;
-
- case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
- enet_protocol_handle_throttle_configure (host, peer, command);
-
- break;
-
- default:
- break;
- }
-
- if (peer != NULL &&
- (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) != 0)
- {- switch (peer -> state)
- {- case ENET_PEER_STATE_DISCONNECTING:
- break;
-
- case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
- if (command -> header.command != ENET_PROTOCOL_COMMAND_DISCONNECT)
- break;
-
- default:
- enet_peer_queue_acknowledgement (peer, command, header -> sentTime);
-
- break;
- }
- }
- }
-
- if (event -> type != ENET_EVENT_TYPE_NONE)
- return 1;
-
- return 0;
-}
-
-static int
-enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
-{- for (;;)
- {- int receivedLength;
- ENetBuffer buffer;
-
- buffer.data = host -> receivedData;
- buffer.dataLength = sizeof (host -> receivedData);
-
- receivedLength = enet_socket_receive (host -> socket,
- & host -> receivedAddress,
- & buffer,
- 1);
-
- if (receivedLength < 0)
- return -1;
-
- if (receivedLength == 0)
- return 0;
-
- host -> receivedDataLength = receivedLength;
-
- switch (enet_protocol_handle_incoming_commands (host, event))
- {- case 1:
- return 1;
-
- case -1:
- return -1;
-
- default:
- break;
- }
- }
-
- return -1;
-}
-
-static void
-enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
-{- ENetProtocol * command = & host -> commands [host -> commandCount];
- ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
- ENetAcknowledgement * acknowledgement;
- ENetListIterator currentAcknowledgement;
-
- currentAcknowledgement = enet_list_begin (& peer -> acknowledgements);
-
- while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements))
- {- if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
- buffer >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
- peer -> mtu - host -> packetSize < sizeof (ENetProtocolAcknowledge))
- break;
-
- acknowledgement = (ENetAcknowledgement *) currentAcknowledgement;
-
- if (peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT &&
- acknowledgement -> command.header.command != ENET_PROTOCOL_COMMAND_DISCONNECT)
- continue;
-
- currentAcknowledgement = enet_list_next (currentAcknowledgement);
-
- buffer -> data = command;
- buffer -> dataLength = sizeof (ENetProtocolAcknowledge);
-
- host -> packetSize += buffer -> dataLength;
-
- command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
- command -> header.channelID = acknowledgement -> command.header.channelID;
- command -> header.flags = 0;
- command -> header.commandLength = ENET_HOST_TO_NET_32 (sizeof (ENetProtocolAcknowledge));
- command -> acknowledge.receivedReliableSequenceNumber = ENET_HOST_TO_NET_32 (acknowledgement -> command.header.reliableSequenceNumber);
- command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_32 (acknowledgement -> sentTime);
-
- if (acknowledgement -> command.header.command == ENET_PROTOCOL_COMMAND_DISCONNECT)
- peer -> state = ENET_PEER_STATE_ZOMBIE;
-
- enet_list_remove (& acknowledgement -> acknowledgementList);
- enet_free (acknowledgement);
-
- ++ command;
- ++ buffer;
- }
-
- host -> commandCount = command - host -> commands;
- host -> bufferCount = buffer - host -> buffers;
-}
-
-static void
-enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
-{- ENetProtocol * command = & host -> commands [host -> commandCount];
- ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
- ENetOutgoingCommand * outgoingCommand;
- ENetListIterator currentCommand;
-
- currentCommand = enet_list_begin (& peer -> outgoingUnreliableCommands);
-
- while (currentCommand != enet_list_end (& peer -> outgoingUnreliableCommands))
- {- outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
- if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
- buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
- peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength ||
- (outgoingCommand -> packet != NULL &&
- peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength +
- outgoingCommand -> packet -> dataLength))
- break;
-
- currentCommand = enet_list_next (currentCommand);
-
- if (outgoingCommand -> packet != NULL)
- {- peer -> packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
- peer -> packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-
- if (peer -> packetThrottleCounter > peer -> packetThrottle)
- {- -- outgoingCommand -> packet -> referenceCount;
-
- if (outgoingCommand -> packet -> referenceCount == 0)
- enet_packet_destroy (outgoingCommand -> packet);
-
- enet_list_remove (& outgoingCommand -> outgoingCommandList);
- enet_free (outgoingCommand);
-
- continue;
- }
- }
-
- buffer -> data = command;
- buffer -> dataLength = outgoingCommand -> command.header.commandLength;
-
- host -> packetSize += buffer -> dataLength;
-
- * command = outgoingCommand -> command;
-
- enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
- if (outgoingCommand -> packet != NULL)
- {- ++ buffer;
-
- buffer -> data = outgoingCommand -> packet -> data;
- buffer -> dataLength = outgoingCommand -> packet -> dataLength;
-
- command -> header.commandLength += buffer -> dataLength;
-
- host -> packetSize += buffer -> dataLength;
-
- enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
- }
- else
- enet_free (outgoingCommand);
-
- command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength);
-
- ++ command;
- ++ buffer;
- }
-
- host -> commandCount = command - host -> commands;
- host -> bufferCount = buffer - host -> buffers;
-}
-
-static int
-enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * event)
-{- ENetOutgoingCommand * outgoingCommand;
- ENetListIterator currentCommand;
-
- currentCommand = enet_list_begin (& peer -> sentReliableCommands);
-
- while (currentCommand != enet_list_end (& peer -> sentReliableCommands))
- {- outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
- currentCommand = enet_list_next (currentCommand);
-
- if (ENET_TIME_DIFFERENCE (timeCurrent, outgoingCommand -> sentTime) < outgoingCommand -> roundTripTimeout)
- continue;
-
- if (outgoingCommand -> roundTripTimeout >= outgoingCommand -> roundTripTimeoutLimit)
- {- event -> type = ENET_EVENT_TYPE_DISCONNECT;
- event -> peer = peer;
-
- enet_peer_reset (peer);
-
- return 1;
- }
-
- if (outgoingCommand -> packet != NULL)
- peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
-
- ++ peer -> packetsLost;
-
- outgoingCommand -> roundTripTimeout *= 2;
-
- enet_list_insert (enet_list_begin (& peer -> outgoingReliableCommands),
- enet_list_remove (& outgoingCommand -> outgoingCommandList));
-
- if (currentCommand == enet_list_begin (& peer -> sentReliableCommands) &&
- enet_list_empty (& peer -> sentReliableCommands) == 0)
- {- outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
- peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
- }
- }
-
- return 0;
-}
-
-static void
-enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
-{- ENetProtocol * command = & host -> commands [host -> commandCount];
- ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
- ENetOutgoingCommand * outgoingCommand;
- ENetListIterator currentCommand;
-
- currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
-
- while (currentCommand != enet_list_end (& peer -> outgoingReliableCommands))
- {- outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-
- if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
- buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
- peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength)
- break;
-
- currentCommand = enet_list_next (currentCommand);
-
- if (outgoingCommand -> packet != NULL)
- {- if ((enet_uint16) (peer -> mtu - host -> packetSize) <
- (enet_uint16) (outgoingCommand -> command.header.commandLength + outgoingCommand -> fragmentLength)
- ||
- peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > peer -> windowSize)
- break;
- }
-
- if (outgoingCommand -> roundTripTimeout == 0)
- {- outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
- outgoingCommand -> roundTripTimeoutLimit = ENET_PEER_TIMEOUT_LIMIT * outgoingCommand -> roundTripTimeout;
- }
-
- if (enet_list_empty (& peer -> sentReliableCommands))
- peer -> nextTimeout = timeCurrent + outgoingCommand -> roundTripTimeout;
-
- enet_list_insert (enet_list_end (& peer -> sentReliableCommands),
- enet_list_remove (& outgoingCommand -> outgoingCommandList));
-
- outgoingCommand -> sentTime = timeCurrent;
-
- buffer -> data = command;
- buffer -> dataLength = outgoingCommand -> command.header.commandLength;
-
- host -> packetSize += buffer -> dataLength;
-
- * command = outgoingCommand -> command;
-
- if (outgoingCommand -> packet != NULL)
- {- ++ buffer;
-
- buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset;
- buffer -> dataLength = outgoingCommand -> fragmentLength;
-
- command -> header.commandLength += outgoingCommand -> fragmentLength;
-
- host -> packetSize += outgoingCommand -> fragmentLength;
-
- peer -> reliableDataInTransit += outgoingCommand -> fragmentLength;
- }
-
- command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength);
-
- ++ peer -> packetsSent;
-
- ++ command;
- ++ buffer;
- }
-
- host -> commandCount = command - host -> commands;
- host -> bufferCount = buffer - host -> buffers;
-}
-
-static int
-enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int checkForTimeouts)
-{- size_t packetsSent = 1;
- ENetProtocolHeader header;
- ENetPeer * currentPeer;
- int sentLength;
-
- while (packetsSent > 0)
- for (currentPeer = host -> peers,
- packetsSent = 0;
- currentPeer < & host -> peers [host -> peerCount];
- ++ currentPeer)
- {- if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED ||
- currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
- continue;
-
- host -> commandCount = 0;
- host -> bufferCount = 1;
- host -> packetSize = sizeof (ENetProtocolHeader);
-
- if (enet_list_empty (& currentPeer -> acknowledgements) == 0)
- enet_protocol_send_acknowledgements (host, currentPeer);
-
- if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol))
- {- if (checkForTimeouts != 0 &&
- enet_list_empty (& currentPeer -> sentReliableCommands) == 0 &&
- ENET_TIME_GREATER_EQUAL (timeCurrent, currentPeer -> nextTimeout) &&
- enet_protocol_check_timeouts (host, currentPeer, event) == 1)
- return 1;
- }
- if (enet_list_empty (& currentPeer -> outgoingReliableCommands) == 0)
- enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
- else
- if (enet_list_empty (& currentPeer -> sentReliableCommands) &&
- ENET_TIME_DIFFERENCE (timeCurrent, currentPeer -> lastReceiveTime) >= ENET_PEER_PING_INTERVAL &&
- currentPeer -> mtu - host -> packetSize >= sizeof (ENetProtocolPing))
- { - enet_peer_ping (currentPeer);
- enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
- }
-
- if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol) &&
- enet_list_empty (& currentPeer -> outgoingUnreliableCommands) == 0)
- enet_protocol_send_unreliable_outgoing_commands (host, currentPeer);
-
- if (host -> commandCount == 0)
- continue;
-
- if (currentPeer -> packetLossEpoch == 0)
- currentPeer -> packetLossEpoch = timeCurrent;
- else
- if (ENET_TIME_DIFFERENCE (timeCurrent, currentPeer -> packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL &&
- currentPeer -> packetsSent > 0)
- {- enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;
-
-#ifdef ENET_DEBUG
-#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, enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands));-#else
- fprintf (stderr, "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, enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands));
-#endif
-#endif
-
- currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;
-
- if (packetLoss >= currentPeer -> packetLoss)
- {- currentPeer -> packetLoss += (packetLoss - currentPeer -> packetLoss) / 8;
- currentPeer -> packetLossVariance += (packetLoss - currentPeer -> packetLoss) / 4;
- }
- else
- {- currentPeer -> packetLoss -= (currentPeer -> packetLoss - packetLoss) / 8;
- currentPeer -> packetLossVariance += (currentPeer -> packetLoss - packetLoss) / 4;
- }
-
- currentPeer -> packetLossEpoch = timeCurrent;
- currentPeer -> packetsSent = 0;
- currentPeer -> packetsLost = 0;
- }
-
- header.peerID = ENET_HOST_TO_NET_16 (currentPeer -> outgoingPeerID);
- header.flags = 0;
- header.commandCount = host -> commandCount;
- header.sentTime = ENET_HOST_TO_NET_32 (timeCurrent);
- header.challenge = currentPeer -> challenge;
-
- host -> buffers -> data = & header;
- host -> buffers -> dataLength = sizeof (ENetProtocolHeader);
-
- currentPeer -> lastSendTime = timeCurrent;
-
- ++ packetsSent;
-
- sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount);
-
- enet_protocol_remove_sent_unreliable_commands (currentPeer);
-
- if (sentLength < 0)
- return -1;
- }
-
- return 0;
-}
-
-/** Sends any queued packets on the host specified to its designated peers.
-
- @param host host to flush
- @remarks this function need only be used in circumstances where one wishes to send queued packets earlier than in a call to enet_host_service().
- @ingroup host
-*/
-void
-enet_host_flush (ENetHost * host)
-{- timeCurrent = enet_time_get ();
-
- enet_protocol_send_outgoing_commands (host, NULL, 0);
-}
-
-/** Waits for events on the host specified and shuttles packets between
- the host and its peers.
-
- @param host host to service
- @param event an event structure where event details will be placed if one occurs
- @param timeout number of milliseconds that ENet should wait for events
- @retval > 1 if an event occurred within the specified time limit
- @retval 0 if no event occurred
- @retval < 1 on failure
- @remarks enet_host_service should be called fairly regularly for adequate performance
- @ingroup host
-*/
-int
-enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
-{- enet_uint32 waitCondition;
-
- event -> type = ENET_EVENT_TYPE_NONE;
- event -> peer = NULL;
- event -> packet = NULL;
-
- switch (enet_protocol_dispatch_incoming_commands (host, event))
- {- case 1:
- return 1;
-
- case -1:
- perror ("Error dispatching incoming packets");-
- return -1;
-
- default:
- break;
- }
-
- timeCurrent = enet_time_get ();
-
- timeout += timeCurrent;
-
- do
- {- if (ENET_TIME_DIFFERENCE (timeCurrent, host -> bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
- enet_host_bandwidth_throttle (host);
-
- switch (enet_protocol_send_outgoing_commands (host, event, 1))
- {- case 1:
- return 1;
-
- case -1:
- perror ("Error sending outgoing packets");-
- return -1;
-
- default:
- break;
- }
-
- switch (enet_protocol_receive_incoming_commands (host, event))
- {- case 1:
- return 1;
-
- case -1:
- perror ("Error receiving incoming packets");-
- return -1;
-
- default:
- break;
- }
-
- switch (enet_protocol_send_outgoing_commands (host, event, 1))
- {- case 1:
- return 1;
-
- case -1:
- perror ("Error sending outgoing packets");-
- return -1;
-
- default:
- break;
- }
-
- switch (enet_protocol_dispatch_incoming_commands (host, event))
- {- case 1:
- return 1;
-
- case -1:
- perror ("Error dispatching incoming packets");-
- return -1;
-
- default:
- break;
- }
-
- timeCurrent = enet_time_get ();
-
- if (ENET_TIME_GREATER_EQUAL (timeCurrent, timeout))
- return 0;
-
- waitCondition = ENET_SOCKET_WAIT_RECEIVE;
-
- if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, timeCurrent)) != 0)
- return -1;
-
- timeCurrent = enet_time_get ();
- } while (waitCondition == ENET_SOCKET_WAIT_RECEIVE);
-
- return 0;
-}
-
--- a/Engine/src/enet/tutorial.txt
+++ /dev/null
@@ -1,325 +1,0 @@
-* Using ENet
-
- Before using ENet, you must call enet_initialize() to initialize the
-library. Upon program exit, you should call enet_deinitialize() so that
-the library may clean up any used resources.
-
-i.e.
-
-int
-main (int argc, uint8_t ** argv)
-{- if (enet_initialize () != 0)
- {- fprintf (stderror, "An error occurred while initializing ENet.\n");
- return EXIT_FAILURE;
- }
- atexit (enet_deinitialize);
- ...
- ...
- ...
-}
-
-* Creating an ENet server
-
- Servers in ENet are constructed with enet_host_create(). You must specify
-an address on which to receive data and new connections, as well as the maximum
-allowable numbers of connected peers. You may optionally specify the incoming
-and outgoing bandwidth of the server in bytes per second so that ENet may try
-to statically manage bandwidth resources among connected peers in addition to
-its dynamic throttling algorithm; specifying 0 for these two options will cause
-ENet to rely entirely upon its dynamic throttling algorithm to manage
-bandwidth.
-
- When done with a host, the host may be destroyed with enet_host_destroy().
-All connected peers to the host will be reset, and the resources used by
-the host will be freed.
-
-i.e.
-
- ENetAddress address;
- ENetHost * server;
-
- /* Bind the server to the default localhost.
- * A specific host address can be specified by
- * enet_address_set_host (& address, "x.x.x.x");
- */
- address.host = ENET_HOST_ANY;
- /* Bind the server to port 1234. */
- address.port = 1234;
-
- server = enet_host_create (& address /* the address to bind the server host to */,
- 32 /* allow up to 32 clients and/or outgoing connections */,
- 0 /* assume any amount of incoming bandwidth */,
- 0 /* assume any amount of outgoing bandwidth */);
- if (server == NULL)
- {- fprintf (stderr,
- "An error occurred while trying to create an ENet server host.\n");
- exit (EXIT_FAILURE);
- }
- ...
- ...
- ...
- enet_host_destroy(server);
-
-* Creating an ENet client
-
- Clients in ENet are similarly constructed with enet_host_create() when no
-address is specified to bind the host to. Bandwidth may be specified for the
-client host as in the above example. The peer count controls the maximum number
-of connections to other server hosts that may be simultaneously open.
-
-i.e.
-
- ENetHost * client;
-
- clienet = enet_host_create (NULL /* create a client host */,
- 1 /* only allow 1 outgoing connection */,
- 57600 / 8 /* 56K modem with 56 Kbps downstream bandwidth */,
- 14400 / 8 /* 56K modem with 14 Kbps upstream bandwidth */);
-
- if (client == NULL)
- {- fprintf (stderr,
- "An error occurred while trying to create an ENet client host.\n");
- exit (EXIT_FAILURE);
- }
- ...
- ...
- ...
- enet_host_destroy(client);
-
-* Managing an ENet host
-
- ENet uses a polled event model to notify the programmer of significant
-events. ENet hosts are polled for events with enet_host_service(), where an
-optional timeout value in milliseconds may be specified to control how long
-ENet will poll; if a timeout of 0 is specified, enet_host_service() will
-return immediately if there are no events to dispatch. enet_host_service()
-will return 1 if an event was dispatched within the specified timeout.
-
- Currently there are only four types of significant events in ENet:
-
-An event of type ENET_EVENT_TYPE_NONE is returned if no event occurred
-within the specified time limit. enet_host_service() will return 0
-with this event.
-
-An event of type ENET_EVENT_TYPE_CONNECT is returned when either a new client
-host has connected to the server host or when an attempt to establish a
-connection with a foreign host has succeeded. Only the "peer" field of the
-event structure is valid for this event and contains the newly connected peer.
-
-An event of type ENET_EVENT_TYPE_RECEIVE is returned when a packet is received
-from a connected peer. The "peer" field contains the peer the packet was
-received from, "channelID" is the channel on which the packet was sent, and
-"packet" is the packet that was sent. The packet contained in the "packet"
-field must be destroyed with enet_packet_destroy() when you are done
-inspecting its contents.
-
-An event of type ENET_EVENT_TYPE_DISCONNECT is returned when a connected peer
-has either explicitly disconnected or timed out. Only the "peer" field of the
-event structure is valid for this event and contains the peer that
-disconnected. Only the "data" field of the peer is still valid on a
-disconnect event and must be explicitly reset.
-
-i.e.
-
- ENetEvent event;
-
- /* Wait up to 1000 milliseconds for an event. */
- while (enet_host_service (client, & event, 1000) > 0)
- {- switch (event.type)
- {- case ENET_EVENT_TYPE_CONNECT:
- printf ("A new client connected from %x:%u.\n", - event.peer -> address.host,
- event.peer -> address.port);
-
- /* Store any relevant client information here. */
- event.peer -> data = "Client information";
-
- break;
-
- case ENET_EVENT_TYPE_RECEIVE:
- printf ("A packet of length %u containing %s was received from %s on channel %u.\n",- event.packet -> dataLength,
- event.packet -> data,
- event.peer -> data,
- event.channelID);
-
- /* Clean up the packet now that we're done using it. */
- enet_packet_destroy (event.packet);
-
- break;
-
- case ENET_EVENT_TYPE_DISCONNECT:
- printf ("%s disconected.\n", event.peer -> data);-
- /* Reset the peer's client information. */
-
- event.peer -> data = NULL;
- }
- }
- ...
- ...
- ...
-
-* Sending a packet to an ENet peer
-
- Packets in ENet are created with enet_packet_create(), where the size of
-the packet must be specified. Optionally, initial data may be specified to
-copy into the packet.
-
- Certain flags may also be supplied to enet_packet_create() to control
-various packet features:
-
-ENET_PACKET_FLAG_RELIABLE specifies that the packet must use reliable delivery.
-A reliable packet is guarenteed to be delivered, and a number of retry attempts
-will be made until an acknowledgement is received from the foreign host the
-packet is sent to. If a certain number of retry attempts is reached without
-any acknowledgement, ENet will assume the peer has disconnected and forcefully
-reset the connection. If this flag is not specified, the packet is assumed
-an unreliable packet, and no retry attempts will be made nor acknowledgements
-generated.
-
- A packet may be resized (extended or truncated) with enet_packet_resize().
-
- A packet is sent to a foreign host with enet_peer_send(). enet_peer_send()
-accepts a channel id over which to send the packet to a given peer. Once the
-packet is handed over to ENet with enet_peer_send(), ENet will handle its
-deallocation and enet_packet_destroy() should not be used upon it.
-
- One may also use enet_host_broadcast() to send a packet to all connected
-peers on a given host over a specified channel id, as with enet_peer_send().
-
- Queued packets will be sent on a call to enet_host_service().
-Alternatively, enet_host_flush() will send out queued packets without
-dispatching any events.
-
-i.e.
-
- /* Create a reliable packet of size 7 containing "packet\0" */
- ENetPacket * packet = enet_packet_create ("packet", - strlen ("packet") + 1, - ENET_PACKET_FLAG_RELIABLE);
-
- /* Extend the packet so and append the string "foo", so it now
- * contains "packetfoo\0"
- *
- enet_packet_resize (packet, strlen ("packetfoo") + 1);- strcpy (& packet -> data [strlen ("packet")], "foo");-
- /* Send the packet to the peer over channel id 3.
- * One could also broadcast the packet by
- * enet_host_broadcast (host, 3, packet);
- */
- enet_peer_send (peer, 3, packet);
- ...
- ...
- ...
- /* One could just use enet_host_service() instead. */
- enet_host_flush (host);
-
-* Disconnecting an ENet peer
-
- Peers may be gently disconnected with enet_peer_disconnect(). A disconnect
-request will be sent to the foreign host, and ENet will wait for an
-acknowledgement from the foreign host before finally disconnecting. An
-event of type ENET_EVENT_TYPE_DISCONNECT will be generated once the
-disconnection succeeds. Normally timeouts apply to the disconnect
-acknowledgement, and so if no acknowledgement is received after a length
-of time the peer will be forcefully disconnected.
-
- enet_peer_reset() will forcefully disconnect a peer. The foreign host
-will get no notification of a disconnect and will time out on the foreign
-host. No event is generated.
-
-i.e.
- ENetEvent event;
-
- enet_peer_disconnect (& client -> peers [0]);
-
- /* Allow up to 3 seconds for the disconnect to succeed
- * and drop any packets received packets.
- */
- while (enet_host_service (client, & event, 3000) > 0)
- {- switch (event.type)
- {- case ENET_EVENT_TYPE_RECEIVE:
- enet_packet_destroy (event.packet);
- break;
-
- case ENET_EVENT_TYPE_DISCONNECT:
- puts ("Disconnection succeeded.");- return;
- ...
- ...
- ...
- }
- }
-
- /* We've arrived here, so the disconnect attempt didn't succeed yet.
- * Force the connection down.
- */
- enet_peer_reset (& client -> peers [0]);
- ...
- ...
- ...
-
-* Connecting to an ENet host
-
- A connection to a foregin host is initiated with enet_host_connect().
-It accepts the address of a foreign host to connect to, and the number of
-channels that should be allocated for communication. If N channels are
-allocated for use, their channel ids will be numbered 0 through N-1.
-A peer representing the connection attempt is returned, or NULL if there
-were no available peers over which to initiate the connection. When the
-connection attempt succeeds, an event of type ENET_EVENT_TYPE_CONNECT will
-be generated. If the connection attempt times out or otherwise fails, an
-event of type ENET_EVENT_TYPE_DISCONNECT will be generated.
-
-i.e.
- ENetAddress address;
- ENetEvent event;
- ENetPeer *peer;
-
- /* Connect to some.server.net:1234. */
- enet_address_set_host (& address, "some.server.net");
- address.port = 1234;
-
- /* Initiate the connection, allocating the two channels 0 and 1. */
- peer = enet_host_connect (client, & address, 2);
-
- if (peer == NULL)
- {- fprintf (stderr,
- "No available peers for initiating an ENet connection.\n");
- exit (EXIT_FAILURE);
- }
-
- /* Wait up to 5 seconds for the connection attempt to succeed.
- if (enet_host_service (client, & event, 5000) > 0 &&
- event.type == ENET_EVENT_TYPE_CONNECT)
- {- puts ("Connection to some.server.net:1234 succeeded.");- ...
- ...
- ...
- }
- else
- {- /* Either the 5 seconds are up or a disconnect event was
- * received. Reset the peer in the event the 5 seconds
- * had run out without any significant event.
- */
- enet_peer_reset (peer);
-
- puts ("Connection to some.server.net:1234 failed.");- }
- ...
- ...
- ...
-
--- a/Engine/src/enet/unix.c
+++ /dev/null
@@ -1,371 +1,0 @@
-/**
- @file unix.c
- @brief ENet Unix system specific functions
-*/
-#ifndef WIN32
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <time.h>
-
-#define ENET_BUILDING_LIB 1
-#if defined (__APPLE__)
- #include "include/enet.h"
-#else
- #include "enet/enet.h"
-#endif
-
-#ifdef HAS_FCNTL
-#include <fcntl.h>
-#endif
-
-#ifdef HAS_POLL
-#include <sys/poll.h>
-#endif
-
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
-#endif
-
-static enet_uint32 timeBase = 0;
-
-int
-enet_initialize (void)
-{- return 0;
-}
-
-void
-enet_deinitialize (void)
-{-}
-
-enet_uint32
-enet_time_get (void)
-{- struct timeval timeVal;
-
- gettimeofday (& timeVal, NULL);
-
- return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
-}
-
-void
-enet_time_set (enet_uint32 newTimeBase)
-{- struct timeval timeVal;
-
- gettimeofday (& timeVal, NULL);
-
- timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{- struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYNAME_R
- struct hostent hostData;
- uint8_t buffer [2048];
- int errnum;
-
-#ifdef linux
- gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
- hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
- hostEntry = gethostbyname (name);
-#endif
-
- if (hostEntry == NULL ||
- hostEntry -> h_addrtype != AF_INET)
- return -1;
-
- address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
- return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{- struct in_addr in;
- struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYADDR_R
- struct hostent hostData;
- uint8_t buffer [2048];
- int errnum;
-
- in.s_addr = address -> host;
-
-#ifdef linux
- gethostbyaddr_r ((uint8_t *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
- hostEntry = gethostbyaddr_r ((uint8_t *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
- in.s_addr = address -> host;
-
- hostEntry = gethostbyaddr ((uint8_t *) & in, sizeof (struct in_addr), AF_INET);
-#endif
-
- if (hostEntry == NULL)
- return -1;
-
- strncpy (name, hostEntry -> h_name, nameLength);
-
- return 0;
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type, const ENetAddress * address)
-{- ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
- int receiveBufferSize = ENET_HOST_RECEIVE_BUFFER_SIZE;
-#ifndef HAS_FCNTL
- int nonBlocking = 1;
-#endif
- struct sockaddr_in sin;
-
- if (newSocket == ENET_SOCKET_NULL)
- return ENET_SOCKET_NULL;
-
- if (type == ENET_SOCKET_TYPE_DATAGRAM)
- {-#ifdef HAS_FCNTL
- fcntl (newSocket, F_SETFL, O_NONBLOCK | fcntl (newSocket, F_GETFL));
-#else
- ioctl (newSocket, FIONBIO, & nonBlocking);
-#endif
-
- setsockopt (newSocket, SOL_SOCKET, SO_RCVBUF, (uint8_t *) & receiveBufferSize, sizeof (int));
- }
-
- if (address == NULL)
- return newSocket;
-
- memset (& sin, 0, sizeof (struct sockaddr_in));
-
- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
-
- if (bind (newSocket,
- (struct sockaddr *) & sin,
- sizeof (struct sockaddr_in)) == -1 ||
- (type == ENET_SOCKET_TYPE_STREAM &&
- listen (newSocket, SOMAXCONN) == -1))
- {- close (newSocket);
-
- return ENET_SOCKET_NULL;
- }
-
- return newSocket;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{- struct sockaddr_in sin;
-
- memset (& sin, 0, sizeof (struct sockaddr_in));
-
- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
-
- return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{- int result;
- struct sockaddr_in sin;
- socklen_t sinLength = sizeof (struct sockaddr_in);
-
- result = accept (socket,
- address != NULL ? (struct sockaddr *) & sin : NULL,
- address != NULL ? & sinLength : NULL);
-
- if (result == -1)
- return ENET_SOCKET_NULL;
-
- if (address != NULL)
- {- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
- }
-
- return result;
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{- close (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
- const ENetAddress * address,
- const ENetBuffer * buffers,
- size_t bufferCount)
-{- struct msghdr msgHdr;
- struct sockaddr_in sin;
- int sentLength;
-
- memset (& msgHdr, 0, sizeof (struct msghdr));
-
- if (address != NULL)
- {- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
-
- msgHdr.msg_name = & sin;
- msgHdr.msg_namelen = sizeof (struct sockaddr_in);
- }
-
- msgHdr.msg_iov = (struct iovec *) buffers;
- msgHdr.msg_iovlen = bufferCount;
-
- sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
-
- if (sentLength == -1)
- {- if (errno == EWOULDBLOCK)
- return 0;
-
- return -1;
- }
-
- return sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
- ENetAddress * address,
- ENetBuffer * buffers,
- size_t bufferCount)
-{- struct msghdr msgHdr;
- struct sockaddr_in sin;
- int recvLength;
-
- memset (& msgHdr, 0, sizeof (struct msghdr));
-
- if (address != NULL)
- {- msgHdr.msg_name = & sin;
- msgHdr.msg_namelen = sizeof (struct sockaddr_in);
- }
-
- msgHdr.msg_iov = (struct iovec *) buffers;
- msgHdr.msg_iovlen = bufferCount;
-
- recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
-
- if (recvLength == -1)
- {- if (errno == EWOULDBLOCK)
- return 0;
-
- return -1;
- }
-
-#ifdef HAS_MSGHDR_FLAGS
- if (msgHdr.msg_flags & MSG_TRUNC)
- return -1;
-#endif
-
- if (address != NULL)
- {- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
- }
-
- return recvLength;
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
-{-#ifdef HAS_POLL
- struct pollfd pollSocket;
- int pollCount;
-
- pollSocket.fd = socket;
- pollSocket.events = 0;
-
- if (* condition & ENET_SOCKET_WAIT_SEND)
- pollSocket.events |= POLLOUT;
-
- if (* condition & ENET_SOCKET_WAIT_RECEIVE)
- pollSocket.events |= POLLIN;
-
- pollCount = poll (& pollSocket, 1, timeout);
-
- if (pollCount < 0)
- return -1;
-
- * condition = ENET_SOCKET_WAIT_NONE;
-
- if (pollCount == 0)
- return 0;
-
- if (pollSocket.revents & POLLOUT)
- * condition |= ENET_SOCKET_WAIT_SEND;
-
- if (pollSocket.revents & POLLIN)
- * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
- return 0;
-#else
- fd_set readSet, writeSet;
- struct timeval timeVal;
- int selectCount;
-
- timeVal.tv_sec = timeout / 1000;
- timeVal.tv_usec = (timeout % 1000) * 1000;
-
- FD_ZERO (& readSet);
- FD_ZERO (& writeSet);
-
- if (* condition & ENET_SOCKET_WAIT_SEND)
- FD_SET (socket, & writeSet);
-
- if (* condition & ENET_SOCKET_WAIT_RECEIVE)
- FD_SET (socket, & readSet);
-
- selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
- if (selectCount < 0)
- return -1;
-
- * condition = ENET_SOCKET_WAIT_NONE;
-
- if (selectCount == 0)
- return 0;
-
- if (FD_ISSET (socket, & writeSet))
- * condition |= ENET_SOCKET_WAIT_SEND;
-
- if (FD_ISSET (socket, & readSet))
- * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
- return 0;
-#endif
-}
-
-#endif
-
--- a/Engine/src/enet/win32.c
+++ /dev/null
@@ -1,309 +1,0 @@
-/**
- @file win32.c
- @brief ENet Win32 system specific functions
-*/
-#ifdef WIN32
-
-#include <time.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/timeb.h>
-#include <string.h>
-
-
-#define ENET_BUILDING_LIB 1
-#include "enet.h"
-
-static enet_uint32 timeBase = 0;
-
-int
-enet_initialize (void)
-{- WORD versionRequested = MAKEWORD (1, 1);
- WSADATA wsaData;
-
- if (WSAStartup (versionRequested, & wsaData))
- return -1;
-
- if (LOBYTE (wsaData.wVersion) != 1||
- HIBYTE (wsaData.wVersion) != 1)
- {- WSACleanup ();
-
- return -1;
- }
-
- return 0;
-}
-
-void
-enet_deinitialize (void)
-{- WSACleanup ();
-}
-
-enet_uint32
-enet_time_get_raw (void)
-{- SYSTEMTIME lp;
- GetSystemTime(&lp);
-/*
- time_t mytime;
- time(&mytime);
-*/
- return (enet_uint32)( (lp.wSecond << 16)|(lp.wMilliseconds<<0) );
-}
-
-enet_uint32
-enet_time_get (void)
-{- return (enet_uint32) GetTickCount () - timeBase;
-}
-
-void
-enet_time_set (enet_uint32 newTimeBase)
-{- timeBase = (enet_uint32) GetTickCount () - newTimeBase;
-}
-
-int
-enet_address_set_host (ENetAddress * address, const char * name)
-{- struct hostent * hostEntry;
-
- hostEntry = gethostbyname (name);
- if (hostEntry == NULL ||
- hostEntry -> h_addrtype != AF_INET)
- return -1;
-
- address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
- return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, uint8_t * name, size_t nameLength)
-{- struct in_addr in;
- struct hostent * hostEntry;
-
- in.s_addr = address -> host;
-
- hostEntry = gethostbyaddr ((uint8_t *) & in, sizeof (struct in_addr), AF_INET);
- if (hostEntry == NULL)
- return -1;
-
- strncpy (name, hostEntry -> h_name, nameLength);
-
- return 0;
-}
-
-ENetSocket
-enet_socket_create (ENetSocketType type, const ENetAddress * address)
-{- ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
- int nonBlocking = 1,
- receiveBufferSize = ENET_HOST_RECEIVE_BUFFER_SIZE;
- struct sockaddr_in sin;
-
- if (newSocket == ENET_SOCKET_NULL)
- return ENET_SOCKET_NULL;
-
- if (type == ENET_SOCKET_TYPE_DATAGRAM)
- {- ioctlsocket (newSocket, FIONBIO, & nonBlocking);
-
- setsockopt (newSocket, SOL_SOCKET, SO_RCVBUF, (uint8_t *) & receiveBufferSize, sizeof (int));
- }
-
- memset (& sin, 0, sizeof (struct sockaddr_in));
-
- sin.sin_family = AF_INET;
-
- if (address != NULL)
- {- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
- }
- else
- {- sin.sin_port = 0;
- sin.sin_addr.s_addr = INADDR_ANY;
- }
-
- if (bind (newSocket,
- (struct sockaddr *) & sin,
- sizeof (struct sockaddr_in)) == SOCKET_ERROR ||
- (type == ENET_SOCKET_TYPE_STREAM &&
- address != NULL &&
- listen (newSocket, SOMAXCONN) == SOCKET_ERROR))
- {- closesocket (newSocket);
-
- return ENET_SOCKET_NULL;
- }
-
- return newSocket;
-}
-
-int
-enet_socket_connect (ENetSocket socket, const ENetAddress * address)
-{- struct sockaddr_in sin;
-
- memset (& sin, 0, sizeof (struct sockaddr_in));
-
- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
-
- return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
-}
-
-ENetSocket
-enet_socket_accept (ENetSocket socket, ENetAddress * address)
-{- int result;
- struct sockaddr_in sin;
- int sinLength = sizeof (struct sockaddr_in);
-
- result = accept (socket,
- address != NULL ? (struct sockaddr *) & sin : NULL,
- address != NULL ? & sinLength : NULL);
-
- if (result == -1)
- return ENET_SOCKET_NULL;
-
- if (address != NULL)
- {- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
- }
-
- return result;
-}
-
-void
-enet_socket_destroy (ENetSocket socket)
-{- closesocket (socket);
-}
-
-int
-enet_socket_send (ENetSocket socket,
- const ENetAddress * address,
- const ENetBuffer * buffers,
- size_t bufferCount)
-{- struct sockaddr_in sin;
- DWORD sentLength;
-
- if (address != NULL)
- {- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
- }
-
- if (WSASendTo (socket,
- (LPWSABUF) buffers,
- (DWORD) bufferCount,
- & sentLength,
- 0,
- address != NULL ? (struct sockaddr *) & sin : 0,
- address != NULL ? sizeof (struct sockaddr_in) : 0,
- NULL,
- NULL) == SOCKET_ERROR)
- {- if (WSAGetLastError () == WSAEWOULDBLOCK)
- return 0;
-
- return -1;
- }
-
- return (int) sentLength;
-}
-
-int
-enet_socket_receive (ENetSocket socket,
- ENetAddress * address,
- ENetBuffer * buffers,
- size_t bufferCount)
-{- DWORD sinLength = sizeof (struct sockaddr_in),
- flags = 0,
- recvLength;
- struct sockaddr_in sin;
-
- if (WSARecvFrom (socket,
- (LPWSABUF) buffers,
- (DWORD) bufferCount,
- & recvLength,
- & flags,
- address != NULL ? (struct sockaddr *) & sin : NULL,
- address != NULL ? & sinLength : NULL,
- NULL,
- NULL) == SOCKET_ERROR)
- {- switch (WSAGetLastError ())
- {- case WSAEWOULDBLOCK:
- case WSAECONNRESET:
- return 0;
- }
-
- return -1;
- }
-
- if (flags & MSG_PARTIAL)
- return -1;
-
- if (address != NULL)
- {- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
- }
-
- return (int) recvLength;
-}
-
-int
-enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
-{- fd_set readSet, writeSet;
- struct timeval timeVal;
- int selectCount;
-
- timeVal.tv_sec = timeout / 1000;
- timeVal.tv_usec = (timeout % 1000) * 1000;
-
- FD_ZERO (& readSet);
- FD_ZERO (& writeSet);
-
- if (* condition & ENET_SOCKET_WAIT_SEND)
- FD_SET (socket, & writeSet);
-
- if (* condition & ENET_SOCKET_WAIT_RECEIVE)
- FD_SET (socket, & readSet);
-
- selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
-
- if (selectCount < 0)
- return -1;
-
- * condition = ENET_SOCKET_WAIT_NONE;
-
- if (selectCount == 0)
- return 0;
-
- if (FD_ISSET (socket, & writeSet))
- * condition |= ENET_SOCKET_WAIT_SEND;
-
- if (FD_ISSET (socket, & readSet))
- * condition |= ENET_SOCKET_WAIT_RECEIVE;
-
- return 0;
-}
-
-#endif
-