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 9
29 #define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
30 #define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
31 #define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
32 #define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
33 #define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
34 
35 typedef enet_uint32 ENetVersion;
36 
37 struct _ENetHost;
38 struct _ENetEvent;
39 struct _ENetPacket;
40 
41 typedef enum _ENetSocketType
42 {
43  ENET_SOCKET_TYPE_STREAM = 1,
44  ENET_SOCKET_TYPE_DATAGRAM = 2
45 } ENetSocketType;
46 
47 typedef enum _ENetSocketWait
48 {
49  ENET_SOCKET_WAIT_NONE = 0,
50  ENET_SOCKET_WAIT_SEND = (1 << 0),
51  ENET_SOCKET_WAIT_RECEIVE = (1 << 1),
52  ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
53 } ENetSocketWait;
54 
55 typedef enum _ENetSocketOption
56 {
57  ENET_SOCKOPT_NONBLOCK = 1,
58  ENET_SOCKOPT_BROADCAST = 2,
59  ENET_SOCKOPT_RCVBUF = 3,
60  ENET_SOCKOPT_SNDBUF = 4,
61  ENET_SOCKOPT_REUSEADDR = 5,
62  ENET_SOCKOPT_RCVTIMEO = 6,
63  ENET_SOCKOPT_SNDTIMEO = 7,
64  ENET_SOCKOPT_ERROR = 8
65 } ENetSocketOption;
66 
67 typedef enum _ENetSocketShutdown
68 {
69  ENET_SOCKET_SHUTDOWN_READ = 0,
70  ENET_SOCKET_SHUTDOWN_WRITE = 1,
71  ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
72 } ENetSocketShutdown;
73 
74 #define ENET_HOST_ANY 0
75 #define ENET_HOST_BROADCAST 0xFFFFFFFFU
76 #define ENET_PORT_ANY 0
77 
88 typedef struct _ENetAddress
89 {
90  enet_uint32 host;
91  enet_uint16 port;
92 } ENetAddress;
93 
103 typedef enum _ENetPacketFlag
104 {
117 
121 
122 typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
123 
143 typedef struct _ENetPacket
144 {
145  size_t referenceCount;
148  size_t dataLength;
149  ENetPacketFreeCallback freeCallback;
150  void * userData;
151 } ENetPacket;
152 
153 typedef struct _ENetAcknowledgement
154 {
155  ENetListNode acknowledgementList;
156  enet_uint32 sentTime;
157  ENetProtocol command;
159 
160 typedef struct _ENetOutgoingCommand
161 {
162  ENetListNode outgoingCommandList;
163  enet_uint16 reliableSequenceNumber;
164  enet_uint16 unreliableSequenceNumber;
165  enet_uint32 sentTime;
166  enet_uint32 roundTripTimeout;
167  enet_uint32 roundTripTimeoutLimit;
168  enet_uint32 fragmentOffset;
169  enet_uint16 fragmentLength;
170  enet_uint16 sendAttempts;
171  ENetProtocol command;
172  ENetPacket * packet;
174 
175 typedef struct _ENetIncomingCommand
176 {
177  ENetListNode incomingCommandList;
178  enet_uint16 reliableSequenceNumber;
179  enet_uint16 unreliableSequenceNumber;
180  ENetProtocol command;
181  enet_uint32 fragmentCount;
182  enet_uint32 fragmentsRemaining;
183  enet_uint32 * fragments;
184  ENetPacket * packet;
186 
187 typedef enum _ENetPeerState
188 {
189  ENET_PEER_STATE_DISCONNECTED = 0,
190  ENET_PEER_STATE_CONNECTING = 1,
191  ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
192  ENET_PEER_STATE_CONNECTION_PENDING = 3,
193  ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
194  ENET_PEER_STATE_CONNECTED = 5,
195  ENET_PEER_STATE_DISCONNECT_LATER = 6,
196  ENET_PEER_STATE_DISCONNECTING = 7,
197  ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
198  ENET_PEER_STATE_ZOMBIE = 9
199 } ENetPeerState;
200 
201 #ifndef ENET_BUFFER_MAXIMUM
202 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
203 #endif
204 
205 enum
206 {
207  ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
208  ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
209  ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
210  ENET_HOST_DEFAULT_MTU = 1400,
211 
212  ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
213  ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
214  ENET_PEER_PACKET_THROTTLE_SCALE = 32,
215  ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
216  ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
217  ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
218  ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
219  ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
220  ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
221  ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
222  ENET_PEER_TIMEOUT_LIMIT = 32,
223  ENET_PEER_TIMEOUT_MINIMUM = 5000,
224  ENET_PEER_TIMEOUT_MAXIMUM = 30000,
225  ENET_PEER_PING_INTERVAL = 500,
226  ENET_PEER_UNSEQUENCED_WINDOWS = 64,
227  ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
228  ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
229  ENET_PEER_RELIABLE_WINDOWS = 16,
230  ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
231  ENET_PEER_FREE_RELIABLE_WINDOWS = 8
232 };
233 
234 typedef struct _ENetChannel
235 {
236  enet_uint16 outgoingReliableSequenceNumber;
237  enet_uint16 outgoingUnreliableSequenceNumber;
238  enet_uint16 usedReliableWindows;
239  enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
240  enet_uint16 incomingReliableSequenceNumber;
241  enet_uint16 incomingUnreliableSequenceNumber;
242  ENetList incomingReliableCommands;
243  ENetList incomingUnreliableCommands;
244 } ENetChannel;
245 
251 typedef struct _ENetPeer
252 {
253  ENetListNode dispatchList;
254  struct _ENetHost * host;
255  enet_uint16 outgoingPeerID;
256  enet_uint16 incomingPeerID;
257  enet_uint32 connectID;
258  enet_uint8 outgoingSessionID;
259  enet_uint8 incomingSessionID;
261  void * data;
262  ENetPeerState state;
263  ENetChannel * channels;
264  size_t channelCount;
267  enet_uint32 incomingBandwidthThrottleEpoch;
268  enet_uint32 outgoingBandwidthThrottleEpoch;
269  enet_uint32 incomingDataTotal;
270  enet_uint32 outgoingDataTotal;
271  enet_uint32 lastSendTime;
272  enet_uint32 lastReceiveTime;
273  enet_uint32 nextTimeout;
274  enet_uint32 earliestTimeout;
275  enet_uint32 packetLossEpoch;
276  enet_uint32 packetsSent;
277  enet_uint32 packetsLost;
279  enet_uint32 packetLossVariance;
280  enet_uint32 packetThrottle;
281  enet_uint32 packetThrottleLimit;
282  enet_uint32 packetThrottleCounter;
283  enet_uint32 packetThrottleEpoch;
284  enet_uint32 packetThrottleAcceleration;
285  enet_uint32 packetThrottleDeceleration;
286  enet_uint32 packetThrottleInterval;
287  enet_uint32 pingInterval;
288  enet_uint32 timeoutLimit;
289  enet_uint32 timeoutMinimum;
290  enet_uint32 timeoutMaximum;
291  enet_uint32 lastRoundTripTime;
292  enet_uint32 lowestRoundTripTime;
293  enet_uint32 lastRoundTripTimeVariance;
294  enet_uint32 highestRoundTripTimeVariance;
296  enet_uint32 roundTripTimeVariance;
297  enet_uint32 mtu;
298  enet_uint32 windowSize;
299  enet_uint32 reliableDataInTransit;
300  enet_uint16 outgoingReliableSequenceNumber;
301  ENetList acknowledgements;
302  ENetList sentReliableCommands;
303  ENetList sentUnreliableCommands;
304  ENetList outgoingReliableCommands;
305  ENetList outgoingUnreliableCommands;
306  ENetList dispatchedCommands;
307  int needsDispatch;
308  enet_uint16 incomingUnsequencedGroup;
309  enet_uint16 outgoingUnsequencedGroup;
310  enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
311  enet_uint32 eventData;
312 } ENetPeer;
313 
316 typedef struct _ENetCompressor
317 {
319  void * context;
321  size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
323  size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
325  void (ENET_CALLBACK * destroy) (void * context);
327 
329 typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
330 
332 typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
333 
350 typedef struct _ENetHost
351 {
352  ENetSocket socket;
356  enet_uint32 bandwidthThrottleEpoch;
357  enet_uint32 mtu;
358  enet_uint32 randomSeed;
359  int recalculateBandwidthLimits;
361  size_t peerCount;
362  size_t channelLimit;
363  enet_uint32 serviceTime;
364  ENetList dispatchQueue;
365  int continueSending;
366  size_t packetSize;
367  enet_uint16 headerFlags;
368  ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
369  size_t commandCount;
370  ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
371  size_t bufferCount;
372  ENetChecksumCallback checksum;
373  ENetCompressor compressor;
374  enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
375  ENetAddress receivedAddress;
376  enet_uint8 * receivedData;
377  size_t receivedDataLength;
382  ENetInterceptCallback intercept;
383  size_t connectedPeers;
384  size_t bandwidthLimitedPeers;
385  size_t duplicatePeers;
386 } ENetHost;
387 
391 typedef enum _ENetEventType
392 {
395 
400 
409 
417 } ENetEventType;
418 
424 typedef struct _ENetEvent
425 {
431 } ENetEvent;
432 
442 ENET_API int enet_initialize (void);
443 
451 ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
452 
457 ENET_API void enet_deinitialize (void);
458 
463 ENET_API ENetVersion enet_linked_version (void);
464 
473 ENET_API enet_uint32 enet_time_get (void);
477 ENET_API void enet_time_set (enet_uint32);
478 
482 ENET_API ENetSocket enet_socket_create (ENetSocketType);
483 ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
484 ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
485 ENET_API int enet_socket_listen (ENetSocket, int);
486 ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
487 ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
488 ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
489 ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
490 ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
491 ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
492 ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
493 ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
494 ENET_API void enet_socket_destroy (ENetSocket);
495 ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
496 
510 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
511 
520 ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
521 
530 ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
531 
534 ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
535 ENET_API void enet_packet_destroy (ENetPacket *);
536 ENET_API int enet_packet_resize (ENetPacket *, size_t);
537 ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
538 
539 ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
540 ENET_API void enet_host_destroy (ENetHost *);
541 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
542 ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
543 ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
544 ENET_API void enet_host_flush (ENetHost *);
545 ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
546 ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
547 ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
548 ENET_API void enet_host_channel_limit (ENetHost *, size_t);
550 extern void enet_host_bandwidth_throttle (ENetHost *);
551 extern enet_uint32 enet_host_random_seed (void);
552 
553 ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
554 ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
555 ENET_API void enet_peer_ping (ENetPeer *);
556 ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32);
558 ENET_API void enet_peer_reset (ENetPeer *);
559 ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
563 extern int enet_peer_throttle (ENetPeer *, enet_uint32);
564 extern void enet_peer_reset_queues (ENetPeer *);
565 extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
566 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
567 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
568 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
569 extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
570 extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
571 extern void enet_peer_on_connect (ENetPeer *);
572 extern void enet_peer_on_disconnect (ENetPeer *);
573 
574 ENET_API void * enet_range_coder_create (void);
575 ENET_API void enet_range_coder_destroy (void *);
576 ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
577 ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
578 
579 extern size_t enet_protocol_command_size (enet_uint8);
580 
581 #ifdef __cplusplus
582 }
583 #endif
584 
585 #endif /* __ENET_ENET_H__ */
586