/src/middleware/enet/enet.h
C++ Header | 540 lines | 326 code | 53 blank | 161 comment | 0 complexity | 5b44c9115e8f567df1ee0256f880243f MD5 | raw file
1/** 2 @file enet.h 3 @brief ENet public header file 4*/ 5#ifndef __ENET_ENET_H__ 6#define __ENET_ENET_H__ 7 8#ifdef __cplusplus 9extern "C" 10{ 11#endif 12 13#include <stdlib.h> 14 15#ifdef WIN32 16#include "enet/win32.h" 17#else 18#include "enet/unix.h" 19#endif 20 21#include "enet/types.h" 22#include "enet/protocol.h" 23#include "enet/list.h" 24#include "enet/callbacks.h" 25 26#define ENET_VERSION_MAJOR 1 27#define ENET_VERSION_MINOR 3 28#define ENET_VERSION_PATCH 1 29#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch)) 30#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH) 31 32typedef enet_uint32 ENetVersion; 33 34typedef enum _ENetSocketType 35{ 36 ENET_SOCKET_TYPE_STREAM = 1, 37 ENET_SOCKET_TYPE_DATAGRAM = 2 38} ENetSocketType; 39 40typedef enum _ENetSocketWait 41{ 42 ENET_SOCKET_WAIT_NONE = 0, 43 ENET_SOCKET_WAIT_SEND = (1 << 0), 44 ENET_SOCKET_WAIT_RECEIVE = (1 << 1) 45} ENetSocketWait; 46 47typedef enum _ENetSocketOption 48{ 49 ENET_SOCKOPT_NONBLOCK = 1, 50 ENET_SOCKOPT_BROADCAST = 2, 51 ENET_SOCKOPT_RCVBUF = 3, 52 ENET_SOCKOPT_SNDBUF = 4, 53 ENET_SOCKOPT_REUSEADDR = 5 54} ENetSocketOption; 55 56enum 57{ 58 ENET_HOST_ANY = 0, /**< specifies the default server host */ 59 ENET_HOST_BROADCAST = 0xFFFFFFFF, /**< specifies a subnet-wide broadcast */ 60 61 ENET_PORT_ANY = 0 /**< specifies that a port should be automatically chosen */ 62}; 63 64/** 65 * Portable internet address structure. 66 * 67 * The host must be specified in network byte-order, and the port must be in host 68 * byte-order. The constant ENET_HOST_ANY may be used to specify the default 69 * server host. The constant ENET_HOST_BROADCAST may be used to specify the 70 * broadcast address (255.255.255.255). This makes sense for enet_host_connect, 71 * but not for enet_host_create. Once a server responds to a broadcast, the 72 * address is updated from ENET_HOST_BROADCAST to the server's actual IP address. 73 */ 74typedef struct _ENetAddress 75{ 76 enet_uint32 host; 77 enet_uint16 port; 78} ENetAddress; 79 80/** 81 * Packet flag bit constants. 82 * 83 * The host must be specified in network byte-order, and the port must be in 84 * host byte-order. The constant ENET_HOST_ANY may be used to specify the 85 * default server host. 86 87 @sa ENetPacket 88*/ 89typedef enum _ENetPacketFlag 90{ 91 /** packet must be received by the target peer and resend attempts should be 92 * made until the packet is delivered */ 93 ENET_PACKET_FLAG_RELIABLE = (1 << 0), 94 /** packet will not be sequenced with other packets 95 * not supported for reliable packets 96 */ 97 ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1), 98 /** packet will not allocate data, and user must supply it instead */ 99 ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2) 100} ENetPacketFlag; 101 102struct _ENetPacket; 103typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *); 104 105/** 106 * ENet packet structure. 107 * 108 * An ENet data packet that may be sent to or received from a peer. The shown 109 * fields should only be read and never modified. The data field contains the 110 * allocated data for the packet. The dataLength fields specifies the length 111 * of the allocated data. The flags field is either 0 (specifying no flags), 112 * or a bitwise-or of any combination of the following flags: 113 * 114 * ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer 115 * and resend attempts should be made until the packet is delivered 116 * 117 * ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 118 * (not supported for reliable packets) 119 * 120 * ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead 121 122 @sa ENetPacketFlag 123 */ 124typedef struct _ENetPacket 125{ 126 size_t referenceCount; /**< internal use only */ 127 enet_uint32 flags; /**< bitwise-or of ENetPacketFlag constants */ 128 enet_uint8 * data; /**< allocated data for packet */ 129 size_t dataLength; /**< length of data */ 130 ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */ 131} ENetPacket; 132 133typedef struct _ENetAcknowledgement 134{ 135 ENetListNode acknowledgementList; 136 enet_uint32 sentTime; 137 ENetProtocol command; 138} ENetAcknowledgement; 139 140typedef struct _ENetOutgoingCommand 141{ 142 ENetListNode outgoingCommandList; 143 enet_uint16 reliableSequenceNumber; 144 enet_uint16 unreliableSequenceNumber; 145 enet_uint32 sentTime; 146 enet_uint32 roundTripTimeout; 147 enet_uint32 roundTripTimeoutLimit; 148 enet_uint32 fragmentOffset; 149 enet_uint16 fragmentLength; 150 enet_uint16 sendAttempts; 151 ENetProtocol command; 152 ENetPacket * packet; 153} ENetOutgoingCommand; 154 155typedef struct _ENetIncomingCommand 156{ 157 ENetListNode incomingCommandList; 158 enet_uint16 reliableSequenceNumber; 159 enet_uint16 unreliableSequenceNumber; 160 ENetProtocol command; 161 enet_uint32 fragmentCount; 162 enet_uint32 fragmentsRemaining; 163 enet_uint32 * fragments; 164 ENetPacket * packet; 165} ENetIncomingCommand; 166 167typedef enum _ENetPeerState 168{ 169 ENET_PEER_STATE_DISCONNECTED = 0, 170 ENET_PEER_STATE_CONNECTING = 1, 171 ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2, 172 ENET_PEER_STATE_CONNECTION_PENDING = 3, 173 ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4, 174 ENET_PEER_STATE_CONNECTED = 5, 175 ENET_PEER_STATE_DISCONNECT_LATER = 6, 176 ENET_PEER_STATE_DISCONNECTING = 7, 177 ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8, 178 ENET_PEER_STATE_ZOMBIE = 9 179} ENetPeerState; 180 181#ifndef ENET_BUFFER_MAXIMUM 182#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS) 183#endif 184 185enum 186{ 187 ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024, 188 ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024, 189 ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000, 190 ENET_HOST_DEFAULT_MTU = 1400, 191 192 ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500, 193 ENET_PEER_DEFAULT_PACKET_THROTTLE = 32, 194 ENET_PEER_PACKET_THROTTLE_SCALE = 32, 195 ENET_PEER_PACKET_THROTTLE_COUNTER = 7, 196 ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2, 197 ENET_PEER_PACKET_THROTTLE_DECELERATION = 2, 198 ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000, 199 ENET_PEER_PACKET_LOSS_SCALE = (1 << 16), 200 ENET_PEER_PACKET_LOSS_INTERVAL = 10000, 201 ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024, 202 ENET_PEER_TIMEOUT_LIMIT = 32, 203 ENET_PEER_TIMEOUT_MINIMUM = 5000, 204 ENET_PEER_TIMEOUT_MAXIMUM = 30000, 205 ENET_PEER_PING_INTERVAL = 500, 206 ENET_PEER_UNSEQUENCED_WINDOWS = 64, 207 ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024, 208 ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32, 209 ENET_PEER_RELIABLE_WINDOWS = 16, 210 ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000, 211 ENET_PEER_FREE_RELIABLE_WINDOWS = 8 212}; 213 214typedef struct _ENetChannel 215{ 216 enet_uint16 outgoingReliableSequenceNumber; 217 enet_uint16 outgoingUnreliableSequenceNumber; 218 enet_uint16 usedReliableWindows; 219 enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS]; 220 enet_uint16 incomingReliableSequenceNumber; 221 ENetList incomingReliableCommands; 222 ENetList incomingUnreliableCommands; 223} ENetChannel; 224 225/** 226 * An ENet peer which data packets may be sent or received from. 227 * 228 * No fields should be modified unless otherwise specified. 229 */ 230typedef struct _ENetPeer 231{ 232 ENetListNode dispatchList; 233 struct _ENetHost * host; 234 enet_uint16 outgoingPeerID; 235 enet_uint16 incomingPeerID; 236 enet_uint32 connectID; 237 enet_uint8 outgoingSessionID; 238 enet_uint8 incomingSessionID; 239 ENetAddress address; /**< Internet address of the peer */ 240 void * data; /**< Application private data, may be freely modified */ 241 ENetPeerState state; 242 ENetChannel * channels; 243 size_t channelCount; /**< Number of channels allocated for communication with peer */ 244 enet_uint32 incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */ 245 enet_uint32 outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */ 246 enet_uint32 incomingBandwidthThrottleEpoch; 247 enet_uint32 outgoingBandwidthThrottleEpoch; 248 enet_uint32 incomingDataTotal; 249 enet_uint32 outgoingDataTotal; 250 enet_uint32 lastSendTime; 251 enet_uint32 lastReceiveTime; 252 enet_uint32 nextTimeout; 253 enet_uint32 earliestTimeout; 254 enet_uint32 packetLossEpoch; 255 enet_uint32 packetsSent; 256 enet_uint32 packetsLost; 257 enet_uint32 packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */ 258 enet_uint32 packetLossVariance; 259 enet_uint32 packetThrottle; 260 enet_uint32 packetThrottleLimit; 261 enet_uint32 packetThrottleCounter; 262 enet_uint32 packetThrottleEpoch; 263 enet_uint32 packetThrottleAcceleration; 264 enet_uint32 packetThrottleDeceleration; 265 enet_uint32 packetThrottleInterval; 266 enet_uint32 lastRoundTripTime; 267 enet_uint32 lowestRoundTripTime; 268 enet_uint32 lastRoundTripTimeVariance; 269 enet_uint32 highestRoundTripTimeVariance; 270 enet_uint32 roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */ 271 enet_uint32 roundTripTimeVariance; 272 enet_uint32 mtu; 273 enet_uint32 windowSize; 274 enet_uint32 reliableDataInTransit; 275 enet_uint16 outgoingReliableSequenceNumber; 276 ENetList acknowledgements; 277 ENetList sentReliableCommands; 278 ENetList sentUnreliableCommands; 279 ENetList outgoingReliableCommands; 280 ENetList outgoingUnreliableCommands; 281 ENetList dispatchedCommands; 282 int needsDispatch; 283 enet_uint16 incomingUnsequencedGroup; 284 enet_uint16 outgoingUnsequencedGroup; 285 enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 286 enet_uint32 eventData; 287} ENetPeer; 288 289/** An ENet packet compressor for compressing UDP packets before socket sends or receives. 290 */ 291typedef struct _ENetCompressor 292{ 293 /** Context data for the compressor. Must be non-NULL. */ 294 void * context; 295 /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */ 296 size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit); 297 /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */ 298 size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit); 299 /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */ 300 void (ENET_CALLBACK * destroy) (void * context); 301} ENetCompressor; 302 303/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */ 304typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount); 305 306/** An ENet host for communicating with peers. 307 * 308 * No fields should be modified unless otherwise stated. 309 310 @sa enet_host_create() 311 @sa enet_host_destroy() 312 @sa enet_host_connect() 313 @sa enet_host_service() 314 @sa enet_host_flush() 315 @sa enet_host_broadcast() 316 @sa enet_host_compress() 317 @sa enet_host_compress_with_range_coder() 318 @sa enet_host_channel_limit() 319 @sa enet_host_bandwidth_limit() 320 @sa enet_host_bandwidth_throttle() 321 */ 322typedef struct _ENetHost 323{ 324 ENetSocket socket; 325 ENetAddress address; /**< Internet address of the host */ 326 enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */ 327 enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */ 328 enet_uint32 bandwidthThrottleEpoch; 329 enet_uint32 mtu; 330 enet_uint32 randomSeed; 331 int recalculateBandwidthLimits; 332 ENetPeer * peers; /**< array of peers allocated for this host */ 333 size_t peerCount; /**< number of peers allocated for this host */ 334 size_t channelLimit; /**< maximum number of channels allowed for connected peers */ 335 enet_uint32 serviceTime; 336 ENetList dispatchQueue; 337 int continueSending; 338 size_t packetSize; 339 enet_uint16 headerFlags; 340 ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS]; 341 size_t commandCount; 342 ENetBuffer buffers [ENET_BUFFER_MAXIMUM]; 343 size_t bufferCount; 344 ENetChecksumCallback checksum; /**< callback the user can set to enable packet checksums for this host */ 345 ENetCompressor compressor; 346 enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU]; 347 ENetAddress receivedAddress; 348 enet_uint8 * receivedData; 349 size_t receivedDataLength; 350 enet_uint32 totalSentData; /**< total data sent, user should reset to 0 as needed to prevent overflow */ 351 enet_uint32 totalSentPackets; /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */ 352 enet_uint32 totalReceivedData; /**< total data received, user should reset to 0 as needed to prevent overflow */ 353 enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */ 354} ENetHost; 355 356/** 357 * An ENet event type, as specified in @ref ENetEvent. 358 */ 359typedef enum _ENetEventType 360{ 361 /** no event occurred within the specified time limit */ 362 ENET_EVENT_TYPE_NONE = 0, 363 364 /** a connection request initiated by enet_host_connect has completed. 365 * The peer field contains the peer which successfully connected. 366 */ 367 ENET_EVENT_TYPE_CONNECT = 1, 368 369 /** a peer has disconnected. This event is generated on a successful 370 * completion of a disconnect initiated by enet_pper_disconnect, if 371 * a peer has timed out, or if a connection request intialized by 372 * enet_host_connect has timed out. The peer field contains the peer 373 * which disconnected. The data field contains user supplied data 374 * describing the disconnection, or 0, if none is available. 375 */ 376 ENET_EVENT_TYPE_DISCONNECT = 2, 377 378 /** a packet has been received from a peer. The peer field specifies the 379 * peer which sent the packet. The channelID field specifies the channel 380 * number upon which the packet was received. The packet field contains 381 * the packet that was received; this packet must be destroyed with 382 * enet_packet_destroy after use. 383 */ 384 ENET_EVENT_TYPE_RECEIVE = 3 385} ENetEventType; 386 387/** 388 * An ENet event as returned by enet_host_service(). 389 390 @sa enet_host_service 391 */ 392typedef struct _ENetEvent 393{ 394 ENetEventType type; /**< type of the event */ 395 ENetPeer * peer; /**< peer that generated a connect, disconnect or receive event */ 396 enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */ 397 enet_uint32 data; /**< data associated with the event, if appropriate */ 398 ENetPacket * packet; /**< packet associated with the event, if appropriate */ 399} ENetEvent; 400 401/** @defgroup global ENet global functions 402 @{ 403*/ 404 405/** 406 Initializes ENet globally. Must be called prior to using any functions in 407 ENet. 408 @returns 0 on success, < 0 on failure 409*/ 410ENET_API int enet_initialize (void); 411 412/** 413 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. 414 415 @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use 416 @param inits user-overriden callbacks where any NULL callbacks will use ENet's defaults 417 @returns 0 on success, < 0 on failure 418*/ 419ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits); 420 421/** 422 Shuts down ENet globally. Should be called when a program that has 423 initialized ENet exits. 424*/ 425ENET_API void enet_deinitialize (void); 426 427/** @} */ 428 429/** @defgroup private ENet private implementation functions */ 430 431/** 432 Returns the wall-time in milliseconds. Its initial value is unspecified 433 unless otherwise set. 434 */ 435ENET_API enet_uint32 enet_time_get (void); 436/** 437 Sets the current wall-time in milliseconds. 438 */ 439ENET_API void enet_time_set (enet_uint32); 440 441/** @defgroup socket ENet socket functions 442 @{ 443*/ 444ENET_API ENetSocket enet_socket_create (ENetSocketType); 445ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *); 446ENET_API int enet_socket_listen (ENetSocket, int); 447ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *); 448ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *); 449ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t); 450ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t); 451ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32); 452ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int); 453ENET_API void enet_socket_destroy (ENetSocket); 454ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32); 455 456/** @} */ 457 458/** @defgroup Address ENet address functions 459 @{ 460*/ 461/** Attempts to resolve the host named by the parameter hostName and sets 462 the host field in the address parameter if successful. 463 @param address destination to store resolved address 464 @param hostName host name to lookup 465 @retval 0 on success 466 @retval < 0 on failure 467 @returns the address of the given hostName in address on success 468*/ 469ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName); 470 471/** Gives the printable form of the ip address specified in the address parameter. 472 @param address address printed 473 @param hostName destination for name, must not be NULL 474 @param nameLength maximum length of hostName. 475 @returns the null-terminated name of the host in hostName on success 476 @retval 0 on success 477 @retval < 0 on failure 478*/ 479ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength); 480 481/** Attempts to do a reverse lookup of the host field in the address parameter. 482 @param address address used for reverse lookup 483 @param hostName destination for name, must not be NULL 484 @param nameLength maximum length of hostName. 485 @returns the null-terminated name of the host in hostName on success 486 @retval 0 on success 487 @retval < 0 on failure 488*/ 489ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength); 490 491/** @} */ 492 493ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32); 494ENET_API void enet_packet_destroy (ENetPacket *); 495ENET_API int enet_packet_resize (ENetPacket *, size_t); 496extern enet_uint32 enet_crc32 (const ENetBuffer *, size_t); 497 498ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32); 499ENET_API void enet_host_destroy (ENetHost *); 500ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32); 501ENET_API int enet_host_check_events (ENetHost *, ENetEvent *); 502ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32); 503ENET_API void enet_host_flush (ENetHost *); 504ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *); 505ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *); 506ENET_API int enet_host_compress_with_range_coder (ENetHost * host); 507ENET_API void enet_host_channel_limit (ENetHost *, size_t); 508ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32); 509extern void enet_host_bandwidth_throttle (ENetHost *); 510 511ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *); 512ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID); 513ENET_API void enet_peer_ping (ENetPeer *); 514ENET_API void enet_peer_reset (ENetPeer *); 515ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32); 516ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32); 517ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32); 518ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32); 519extern int enet_peer_throttle (ENetPeer *, enet_uint32); 520extern void enet_peer_reset_queues (ENetPeer *); 521extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *); 522extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16); 523extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32); 524extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16); 525extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *); 526extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *); 527 528ENET_API void * enet_range_coder_create (void); 529ENET_API void enet_range_coder_destroy (void *); 530ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t); 531ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t); 532 533extern size_t enet_protocol_command_size (enet_uint8); 534 535#ifdef __cplusplus 536} 537#endif 538 539#endif /* __ENET_ENET_H__ */ 540