00001
00005 #ifndef __ENET_ENET_H__
00006 #define __ENET_ENET_H__
00007
00008 #ifdef __cplusplus
00009 extern "C"
00010 {
00011 #endif
00012
00013 #include <stdlib.h>
00014
00015 #ifdef WIN32
00016 #include "enet/win32.h"
00017 #else
00018 #include "enet/unix.h"
00019 #endif
00020
00021 #include "enet/types.h"
00022 #include "enet/protocol.h"
00023 #include "enet/list.h"
00024 #include "enet/callbacks.h"
00025
00026 #define ENET_VERSION_MAJOR 1
00027 #define ENET_VERSION_MINOR 3
00028 #define ENET_VERSION_PATCH 0
00029 #define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
00030 #define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
00031
00032 typedef enet_uint32 ENetVersion;
00033
00034 typedef enum _ENetSocketType
00035 {
00036 ENET_SOCKET_TYPE_STREAM = 1,
00037 ENET_SOCKET_TYPE_DATAGRAM = 2
00038 } ENetSocketType;
00039
00040 typedef enum _ENetSocketWait
00041 {
00042 ENET_SOCKET_WAIT_NONE = 0,
00043 ENET_SOCKET_WAIT_SEND = (1 << 0),
00044 ENET_SOCKET_WAIT_RECEIVE = (1 << 1)
00045 } ENetSocketWait;
00046
00047 typedef enum _ENetSocketOption
00048 {
00049 ENET_SOCKOPT_NONBLOCK = 1,
00050 ENET_SOCKOPT_BROADCAST = 2,
00051 ENET_SOCKOPT_RCVBUF = 3,
00052 ENET_SOCKOPT_SNDBUF = 4,
00053 ENET_SOCKOPT_REUSEADDR = 5
00054 } ENetSocketOption;
00055
00056 enum
00057 {
00058 ENET_HOST_ANY = 0,
00059 ENET_HOST_BROADCAST = 0xFFFFFFFF,
00061 ENET_PORT_ANY = 0
00062 };
00063
00074 typedef struct _ENetAddress
00075 {
00076 enet_uint32 host;
00077 enet_uint16 port;
00078 } ENetAddress;
00079
00089 typedef enum _ENetPacketFlag
00090 {
00093 ENET_PACKET_FLAG_RELIABLE = (1 << 0),
00097 ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
00099 ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2)
00100 } ENetPacketFlag;
00101
00102 struct _ENetPacket;
00103 typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
00104
00124 typedef struct _ENetPacket
00125 {
00126 size_t referenceCount;
00127 enet_uint32 flags;
00128 enet_uint8 * data;
00129 size_t dataLength;
00130 ENetPacketFreeCallback freeCallback;
00131 } ENetPacket;
00132
00133 typedef struct _ENetAcknowledgement
00134 {
00135 ENetListNode acknowledgementList;
00136 enet_uint32 sentTime;
00137 ENetProtocol command;
00138 } ENetAcknowledgement;
00139
00140 typedef struct _ENetOutgoingCommand
00141 {
00142 ENetListNode outgoingCommandList;
00143 enet_uint16 reliableSequenceNumber;
00144 enet_uint16 unreliableSequenceNumber;
00145 enet_uint32 sentTime;
00146 enet_uint32 roundTripTimeout;
00147 enet_uint32 roundTripTimeoutLimit;
00148 enet_uint32 fragmentOffset;
00149 enet_uint16 fragmentLength;
00150 enet_uint16 sendAttempts;
00151 ENetProtocol command;
00152 ENetPacket * packet;
00153 } ENetOutgoingCommand;
00154
00155 typedef struct _ENetIncomingCommand
00156 {
00157 ENetListNode incomingCommandList;
00158 enet_uint16 reliableSequenceNumber;
00159 enet_uint16 unreliableSequenceNumber;
00160 ENetProtocol command;
00161 enet_uint32 fragmentCount;
00162 enet_uint32 fragmentsRemaining;
00163 enet_uint32 * fragments;
00164 ENetPacket * packet;
00165 } ENetIncomingCommand;
00166
00167 typedef enum _ENetPeerState
00168 {
00169 ENET_PEER_STATE_DISCONNECTED = 0,
00170 ENET_PEER_STATE_CONNECTING = 1,
00171 ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
00172 ENET_PEER_STATE_CONNECTION_PENDING = 3,
00173 ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
00174 ENET_PEER_STATE_CONNECTED = 5,
00175 ENET_PEER_STATE_DISCONNECT_LATER = 6,
00176 ENET_PEER_STATE_DISCONNECTING = 7,
00177 ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
00178 ENET_PEER_STATE_ZOMBIE = 9
00179 } ENetPeerState;
00180
00181 #ifndef ENET_BUFFER_MAXIMUM
00182 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
00183 #endif
00184
00185 enum
00186 {
00187 ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
00188 ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
00189 ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
00190 ENET_HOST_DEFAULT_MTU = 1400,
00191
00192 ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
00193 ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
00194 ENET_PEER_PACKET_THROTTLE_SCALE = 32,
00195 ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
00196 ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
00197 ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
00198 ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
00199 ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
00200 ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
00201 ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
00202 ENET_PEER_TIMEOUT_LIMIT = 32,
00203 ENET_PEER_TIMEOUT_MINIMUM = 5000,
00204 ENET_PEER_TIMEOUT_MAXIMUM = 30000,
00205 ENET_PEER_PING_INTERVAL = 500,
00206 ENET_PEER_UNSEQUENCED_WINDOWS = 64,
00207 ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
00208 ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
00209 ENET_PEER_RELIABLE_WINDOWS = 16,
00210 ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
00211 ENET_PEER_FREE_RELIABLE_WINDOWS = 8
00212 };
00213
00214 typedef struct _ENetChannel
00215 {
00216 enet_uint16 outgoingReliableSequenceNumber;
00217 enet_uint16 outgoingUnreliableSequenceNumber;
00218 enet_uint16 usedReliableWindows;
00219 enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
00220 enet_uint16 incomingReliableSequenceNumber;
00221 ENetList incomingReliableCommands;
00222 ENetList incomingUnreliableCommands;
00223 } ENetChannel;
00224
00230 typedef struct _ENetPeer
00231 {
00232 ENetListNode dispatchList;
00233 struct _ENetHost * host;
00234 enet_uint16 outgoingPeerID;
00235 enet_uint16 incomingPeerID;
00236 enet_uint32 connectID;
00237 enet_uint8 outgoingSessionID;
00238 enet_uint8 incomingSessionID;
00239 ENetAddress address;
00240 void * data;
00241 ENetPeerState state;
00242 ENetChannel * channels;
00243 size_t channelCount;
00244 enet_uint32 incomingBandwidth;
00245 enet_uint32 outgoingBandwidth;
00246 enet_uint32 incomingBandwidthThrottleEpoch;
00247 enet_uint32 outgoingBandwidthThrottleEpoch;
00248 enet_uint32 incomingDataTotal;
00249 enet_uint32 outgoingDataTotal;
00250 enet_uint32 lastSendTime;
00251 enet_uint32 lastReceiveTime;
00252 enet_uint32 nextTimeout;
00253 enet_uint32 earliestTimeout;
00254 enet_uint32 packetLossEpoch;
00255 enet_uint32 packetsSent;
00256 enet_uint32 packetsLost;
00257 enet_uint32 packetLoss;
00258 enet_uint32 packetLossVariance;
00259 enet_uint32 packetThrottle;
00260 enet_uint32 packetThrottleLimit;
00261 enet_uint32 packetThrottleCounter;
00262 enet_uint32 packetThrottleEpoch;
00263 enet_uint32 packetThrottleAcceleration;
00264 enet_uint32 packetThrottleDeceleration;
00265 enet_uint32 packetThrottleInterval;
00266 enet_uint32 lastRoundTripTime;
00267 enet_uint32 lowestRoundTripTime;
00268 enet_uint32 lastRoundTripTimeVariance;
00269 enet_uint32 highestRoundTripTimeVariance;
00270 enet_uint32 roundTripTime;
00271 enet_uint32 roundTripTimeVariance;
00272 enet_uint32 mtu;
00273 enet_uint32 windowSize;
00274 enet_uint32 reliableDataInTransit;
00275 enet_uint16 outgoingReliableSequenceNumber;
00276 ENetList acknowledgements;
00277 ENetList sentReliableCommands;
00278 ENetList sentUnreliableCommands;
00279 ENetList outgoingReliableCommands;
00280 ENetList outgoingUnreliableCommands;
00281 ENetList dispatchedCommands;
00282 int needsDispatch;
00283 enet_uint16 incomingUnsequencedGroup;
00284 enet_uint16 outgoingUnsequencedGroup;
00285 enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
00286 enet_uint32 eventData;
00287 } ENetPeer;
00288
00291 typedef struct _ENetCompressor
00292 {
00294 void * context;
00296 size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
00298 size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
00300 void (ENET_CALLBACK * destroy) (void * context);
00301 } ENetCompressor;
00302
00304 typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
00305
00322 typedef struct _ENetHost
00323 {
00324 ENetSocket socket;
00325 ENetAddress address;
00326 enet_uint32 incomingBandwidth;
00327 enet_uint32 outgoingBandwidth;
00328 enet_uint32 bandwidthThrottleEpoch;
00329 enet_uint32 mtu;
00330 enet_uint32 randomSeed;
00331 int recalculateBandwidthLimits;
00332 ENetPeer * peers;
00333 size_t peerCount;
00334 size_t channelLimit;
00335 enet_uint32 serviceTime;
00336 ENetList dispatchQueue;
00337 int continueSending;
00338 size_t packetSize;
00339 enet_uint16 headerFlags;
00340 ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
00341 size_t commandCount;
00342 ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
00343 size_t bufferCount;
00344 ENetChecksumCallback checksum;
00345 ENetCompressor compressor;
00346 enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
00347 ENetAddress receivedAddress;
00348 enet_uint8 * receivedData;
00349 size_t receivedDataLength;
00350 enet_uint32 totalSentData;
00351 enet_uint32 totalSentPackets;
00352 enet_uint32 totalReceivedData;
00353 enet_uint32 totalReceivedPackets;
00354 } ENetHost;
00355
00359 typedef enum _ENetEventType
00360 {
00362 ENET_EVENT_TYPE_NONE = 0,
00363
00367 ENET_EVENT_TYPE_CONNECT = 1,
00368
00376 ENET_EVENT_TYPE_DISCONNECT = 2,
00377
00384 ENET_EVENT_TYPE_RECEIVE = 3
00385 } ENetEventType;
00386
00392 typedef struct _ENetEvent
00393 {
00394 ENetEventType type;
00395 ENetPeer * peer;
00396 enet_uint8 channelID;
00397 enet_uint32 data;
00398 ENetPacket * packet;
00399 } ENetEvent;
00400
00410 ENET_API int enet_initialize (void);
00411
00419 ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
00420
00425 ENET_API void enet_deinitialize (void);
00426
00435 ENET_API enet_uint32 enet_time_get (void);
00439 ENET_API void enet_time_set (enet_uint32);
00440
00444 ENET_API ENetSocket enet_socket_create (ENetSocketType);
00445 ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
00446 ENET_API int enet_socket_listen (ENetSocket, int);
00447 ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
00448 ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
00449 ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
00450 ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
00451 ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
00452 ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
00453 ENET_API void enet_socket_destroy (ENetSocket);
00454 ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
00455
00469 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
00470
00479 ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
00480
00489 ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
00490
00493 ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
00494 ENET_API void enet_packet_destroy (ENetPacket *);
00495 ENET_API int enet_packet_resize (ENetPacket *, size_t);
00496 extern enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
00497
00498 ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
00499 ENET_API void enet_host_destroy (ENetHost *);
00500 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
00501 ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
00502 ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
00503 ENET_API void enet_host_flush (ENetHost *);
00504 ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
00505 ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
00506 ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
00507 ENET_API void enet_host_channel_limit (ENetHost *, size_t);
00508 ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
00509 extern void enet_host_bandwidth_throttle (ENetHost *);
00510
00511 ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
00512 ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
00513 ENET_API void enet_peer_ping (ENetPeer *);
00514 ENET_API void enet_peer_reset (ENetPeer *);
00515 ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
00516 ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32);
00517 ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32);
00518 ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
00519 extern int enet_peer_throttle (ENetPeer *, enet_uint32);
00520 extern void enet_peer_reset_queues (ENetPeer *);
00521 extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
00522 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
00523 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
00524 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
00525 extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
00526 extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
00527
00528 ENET_API void * enet_range_coder_create (void);
00529 ENET_API void enet_range_coder_destroy (void *);
00530 ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
00531 ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
00532
00533 extern size_t enet_protocol_command_size (enet_uint8);
00534
00535 #ifdef __cplusplus
00536 }
00537 #endif
00538
00539 #endif
00540