enet
enet.h
Go to the documentation of this file.
1 
5 #ifndef __ENET_ENET_H__
6 #define __ENET_ENET_H__
7 
8 #ifdef __cplusplus
9 extern "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 5
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 
32 typedef enet_uint32 ENetVersion;
33 
34 struct _ENetHost;
35 struct _ENetEvent;
36 struct _ENetPacket;
37 
38 typedef enum _ENetSocketType
39 {
40  ENET_SOCKET_TYPE_STREAM = 1,
41  ENET_SOCKET_TYPE_DATAGRAM = 2
42 } ENetSocketType;
43 
44 typedef enum _ENetSocketWait
45 {
46  ENET_SOCKET_WAIT_NONE = 0,
47  ENET_SOCKET_WAIT_SEND = (1 << 0),
48  ENET_SOCKET_WAIT_RECEIVE = (1 << 1)
49 } ENetSocketWait;
50 
51 typedef enum _ENetSocketOption
52 {
53  ENET_SOCKOPT_NONBLOCK = 1,
54  ENET_SOCKOPT_BROADCAST = 2,
55  ENET_SOCKOPT_RCVBUF = 3,
56  ENET_SOCKOPT_SNDBUF = 4,
57  ENET_SOCKOPT_REUSEADDR = 5,
58  ENET_SOCKOPT_RCVTIMEO = 6,
59  ENET_SOCKOPT_SNDTIMEO = 7
60 } ENetSocketOption;
61 
62 typedef enum _ENetSocketShutdown
63 {
64  ENET_SOCKET_SHUTDOWN_READ = 0,
65  ENET_SOCKET_SHUTDOWN_WRITE = 1,
66  ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
67 } ENetSocketShutdown;
68 
69 enum
70 {
72  ENET_HOST_BROADCAST = 0xFFFFFFFF,
75 };
76 
87 typedef struct _ENetAddress
88 {
89  enet_uint32 host;
90  enet_uint16 port;
91 } ENetAddress;
92 
102 typedef enum _ENetPacketFlag
103 {
117 
118 typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
119 
139 typedef struct _ENetPacket
140 {
141  size_t referenceCount;
144  size_t dataLength;
145  ENetPacketFreeCallback freeCallback;
146 } ENetPacket;
147 
148 typedef struct _ENetAcknowledgement
149 {
150  ENetListNode acknowledgementList;
151  enet_uint32 sentTime;
152  ENetProtocol command;
154 
155 typedef struct _ENetOutgoingCommand
156 {
157  ENetListNode outgoingCommandList;
158  enet_uint16 reliableSequenceNumber;
159  enet_uint16 unreliableSequenceNumber;
160  enet_uint32 sentTime;
161  enet_uint32 roundTripTimeout;
162  enet_uint32 roundTripTimeoutLimit;
163  enet_uint32 fragmentOffset;
164  enet_uint16 fragmentLength;
165  enet_uint16 sendAttempts;
166  ENetProtocol command;
167  ENetPacket * packet;
169 
170 typedef struct _ENetIncomingCommand
171 {
172  ENetListNode incomingCommandList;
173  enet_uint16 reliableSequenceNumber;
174  enet_uint16 unreliableSequenceNumber;
175  ENetProtocol command;
176  enet_uint32 fragmentCount;
177  enet_uint32 fragmentsRemaining;
178  enet_uint32 * fragments;
179  ENetPacket * packet;
181 
182 typedef enum _ENetPeerState
183 {
184  ENET_PEER_STATE_DISCONNECTED = 0,
185  ENET_PEER_STATE_CONNECTING = 1,
186  ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
187  ENET_PEER_STATE_CONNECTION_PENDING = 3,
188  ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
189  ENET_PEER_STATE_CONNECTED = 5,
190  ENET_PEER_STATE_DISCONNECT_LATER = 6,
191  ENET_PEER_STATE_DISCONNECTING = 7,
192  ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
193  ENET_PEER_STATE_ZOMBIE = 9
194 } ENetPeerState;
195 
196 #ifndef ENET_BUFFER_MAXIMUM
197 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
198 #endif
199 
200 enum
201 {
202  ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
203  ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
204  ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
205  ENET_HOST_DEFAULT_MTU = 1400,
206 
207  ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
208  ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
209  ENET_PEER_PACKET_THROTTLE_SCALE = 32,
210  ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
211  ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
212  ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
213  ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
214  ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
215  ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
216  ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
217  ENET_PEER_TIMEOUT_LIMIT = 32,
218  ENET_PEER_TIMEOUT_MINIMUM = 5000,
219  ENET_PEER_TIMEOUT_MAXIMUM = 30000,
220  ENET_PEER_PING_INTERVAL = 500,
221  ENET_PEER_UNSEQUENCED_WINDOWS = 64,
222  ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
223  ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
224  ENET_PEER_RELIABLE_WINDOWS = 16,
225  ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
226  ENET_PEER_FREE_RELIABLE_WINDOWS = 8
227 };
228 
229 typedef struct _ENetChannel
230 {
231  enet_uint16 outgoingReliableSequenceNumber;
232  enet_uint16 outgoingUnreliableSequenceNumber;
233  enet_uint16 usedReliableWindows;
234  enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
235  enet_uint16 incomingReliableSequenceNumber;
236  enet_uint16 incomingUnreliableSequenceNumber;
237  ENetList incomingReliableCommands;
238  ENetList incomingUnreliableCommands;
239 } ENetChannel;
240 
246 typedef struct _ENetPeer
247 {
248  ENetListNode dispatchList;
249  struct _ENetHost * host;
250  enet_uint16 outgoingPeerID;
251  enet_uint16 incomingPeerID;
252  enet_uint32 connectID;
253  enet_uint8 outgoingSessionID;
254  enet_uint8 incomingSessionID;
256  void * data;
257  ENetPeerState state;
258  ENetChannel * channels;
259  size_t channelCount;
262  enet_uint32 incomingBandwidthThrottleEpoch;
263  enet_uint32 outgoingBandwidthThrottleEpoch;
264  enet_uint32 incomingDataTotal;
265  enet_uint32 outgoingDataTotal;
266  enet_uint32 lastSendTime;
267  enet_uint32 lastReceiveTime;
268  enet_uint32 nextTimeout;
269  enet_uint32 earliestTimeout;
270  enet_uint32 packetLossEpoch;
271  enet_uint32 packetsSent;
272  enet_uint32 packetsLost;
274  enet_uint32 packetLossVariance;
275  enet_uint32 packetThrottle;
276  enet_uint32 packetThrottleLimit;
277  enet_uint32 packetThrottleCounter;
278  enet_uint32 packetThrottleEpoch;
279  enet_uint32 packetThrottleAcceleration;
280  enet_uint32 packetThrottleDeceleration;
281  enet_uint32 packetThrottleInterval;
282  enet_uint32 pingInterval;
283  enet_uint32 timeoutLimit;
284  enet_uint32 timeoutMinimum;
285  enet_uint32 timeoutMaximum;
286  enet_uint32 lastRoundTripTime;
287  enet_uint32 lowestRoundTripTime;
288  enet_uint32 lastRoundTripTimeVariance;
289  enet_uint32 highestRoundTripTimeVariance;
291  enet_uint32 roundTripTimeVariance;
292  enet_uint32 mtu;
293  enet_uint32 windowSize;
294  enet_uint32 reliableDataInTransit;
295  enet_uint16 outgoingReliableSequenceNumber;
296  ENetList acknowledgements;
297  ENetList sentReliableCommands;
298  ENetList sentUnreliableCommands;
299  ENetList outgoingReliableCommands;
300  ENetList outgoingUnreliableCommands;
301  ENetList dispatchedCommands;
302  int needsDispatch;
303  enet_uint16 incomingUnsequencedGroup;
304  enet_uint16 outgoingUnsequencedGroup;
305  enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
306  enet_uint32 eventData;
307 } ENetPeer;
308 
311 typedef struct _ENetCompressor
312 {
314  void * context;
316  size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
318  size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
320  void (ENET_CALLBACK * destroy) (void * context);
322 
324 typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
325 
327 typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
328 
345 typedef struct _ENetHost
346 {
347  ENetSocket socket;
351  enet_uint32 bandwidthThrottleEpoch;
352  enet_uint32 mtu;
353  enet_uint32 randomSeed;
354  int recalculateBandwidthLimits;
356  size_t peerCount;
357  size_t channelLimit;
358  enet_uint32 serviceTime;
359  ENetList dispatchQueue;
360  int continueSending;
361  size_t packetSize;
362  enet_uint16 headerFlags;
363  ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
364  size_t commandCount;
365  ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
366  size_t bufferCount;
367  ENetChecksumCallback checksum;
368  ENetCompressor compressor;
369  enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
370  ENetAddress receivedAddress;
371  enet_uint8 * receivedData;
372  size_t receivedDataLength;
377  ENetInterceptCallback intercept;
378 } ENetHost;
379 
383 typedef enum _ENetEventType
384 {
387 
392 
401 
409 } ENetEventType;
410 
416 typedef struct _ENetEvent
417 {
423 } ENetEvent;
424 
434 ENET_API int enet_initialize (void);
435 
443 ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
444 
449 ENET_API void enet_deinitialize (void);
450 
459 ENET_API enet_uint32 enet_time_get (void);
463 ENET_API void enet_time_set (enet_uint32);
464 
468 ENET_API ENetSocket enet_socket_create (ENetSocketType);
469 ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
470 ENET_API int enet_socket_listen (ENetSocket, int);
471 ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
472 ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
473 ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
474 ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
475 ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
476 ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
477 ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
478 ENET_API void enet_socket_destroy (ENetSocket);
479 ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
480 
494 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
495 
504 ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
505 
514 ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
515 
518 ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
519 ENET_API void enet_packet_destroy (ENetPacket *);
520 ENET_API int enet_packet_resize (ENetPacket *, size_t);
521 ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
522 
523 ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
524 ENET_API void enet_host_destroy (ENetHost *);
525 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
526 ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
527 ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
528 ENET_API void enet_host_flush (ENetHost *);
529 ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
530 ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
531 ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
532 ENET_API void enet_host_channel_limit (ENetHost *, size_t);
534 extern void enet_host_bandwidth_throttle (ENetHost *);
535 
536 ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
537 ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
538 ENET_API void enet_peer_ping (ENetPeer *);
539 ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32);
541 ENET_API void enet_peer_reset (ENetPeer *);
542 ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
546 extern int enet_peer_throttle (ENetPeer *, enet_uint32);
547 extern void enet_peer_reset_queues (ENetPeer *);
548 extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
549 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
550 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
551 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
552 extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
553 extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
554 
555 ENET_API void * enet_range_coder_create (void);
556 ENET_API void enet_range_coder_destroy (void *);
557 ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
558 ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
559 
560 extern size_t enet_protocol_command_size (enet_uint8);
561 
562 #ifdef __cplusplus
563 }
564 #endif
565 
566 #endif /* __ENET_ENET_H__ */
567