enet: enet.h Source File

enet

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

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 12
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 ENET_SOCKOPT_NODELAY = 9
66 } ENetSocketOption;
67
68 typedef enum _ENetSocketShutdown
69 {
70 ENET_SOCKET_SHUTDOWN_READ = 0,
71 ENET_SOCKET_SHUTDOWN_WRITE = 1,
72 ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
73 } ENetSocketShutdown;
74
75 #define ENET_HOST_ANY 0
76 #define ENET_HOST_BROADCAST 0xFFFFFFFFU
77 #define ENET_PORT_ANY 0
78
89 typedef struct _ENetAddress
90 {
91 enet_uint32 host;
92 enet_uint16 port;
93 } ENetAddress;
94
104 typedef enum _ENetPacketFlag
105 {
108 ENET_PACKET_FLAG_RELIABLE = (1 << 0),
112 ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
114 ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
117 ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
118
120 ENET_PACKET_FLAG_SENT = (1<<8)
121 } ENetPacketFlag;
122
123 typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
124
144 typedef struct _ENetPacket
145 {
146 size_t referenceCount;
147 enet_uint32 flags;
148 enet_uint8 * data;
149 size_t dataLength;
150 ENetPacketFreeCallback freeCallback;
151 void * userData;
152 } ENetPacket;
153
154 typedef struct _ENetAcknowledgement
155 {
156 ENetListNode acknowledgementList;
157 enet_uint32 sentTime;
158 ENetProtocol command;
159 } ENetAcknowledgement;
160
161 typedef struct _ENetOutgoingCommand
162 {
163 ENetListNode outgoingCommandList;
164 enet_uint16 reliableSequenceNumber;
165 enet_uint16 unreliableSequenceNumber;
166 enet_uint32 sentTime;
167 enet_uint32 roundTripTimeout;
168 enet_uint32 roundTripTimeoutLimit;
169 enet_uint32 fragmentOffset;
170 enet_uint16 fragmentLength;
171 enet_uint16 sendAttempts;
172 ENetProtocol command;
173 ENetPacket * packet;
174 } ENetOutgoingCommand;
175
176 typedef struct _ENetIncomingCommand
177 {
178 ENetListNode incomingCommandList;
179 enet_uint16 reliableSequenceNumber;
180 enet_uint16 unreliableSequenceNumber;
181 ENetProtocol command;
182 enet_uint32 fragmentCount;
183 enet_uint32 fragmentsRemaining;
184 enet_uint32 * fragments;
185 ENetPacket * packet;
186 } ENetIncomingCommand;
187
188 typedef enum _ENetPeerState
189 {
190 ENET_PEER_STATE_DISCONNECTED = 0,
191 ENET_PEER_STATE_CONNECTING = 1,
192 ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
193 ENET_PEER_STATE_CONNECTION_PENDING = 3,
194 ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
195 ENET_PEER_STATE_CONNECTED = 5,
196 ENET_PEER_STATE_DISCONNECT_LATER = 6,
197 ENET_PEER_STATE_DISCONNECTING = 7,
198 ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
199 ENET_PEER_STATE_ZOMBIE = 9
200 } ENetPeerState;
201
202 #ifndef ENET_BUFFER_MAXIMUM
203 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
204 #endif
205
206 enum
207 {
208 ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
209 ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
210 ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
211 ENET_HOST_DEFAULT_MTU = 1400,
212 ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE = 32 * 1024 * 1024,
213 ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
214
215 ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
216 ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
217 ENET_PEER_PACKET_THROTTLE_SCALE = 32,
218 ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
219 ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
220 ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
221 ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
222 ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
223 ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
224 ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
225 ENET_PEER_TIMEOUT_LIMIT = 32,
226 ENET_PEER_TIMEOUT_MINIMUM = 5000,
227 ENET_PEER_TIMEOUT_MAXIMUM = 30000,
228 ENET_PEER_PING_INTERVAL = 500,
229 ENET_PEER_UNSEQUENCED_WINDOWS = 64,
230 ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
231 ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
232 ENET_PEER_RELIABLE_WINDOWS = 16,
233 ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
234 ENET_PEER_FREE_RELIABLE_WINDOWS = 8
235 };
236
237 typedef struct _ENetChannel
238 {
239 enet_uint16 outgoingReliableSequenceNumber;
240 enet_uint16 outgoingUnreliableSequenceNumber;
241 enet_uint16 usedReliableWindows;
242 enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
243 enet_uint16 incomingReliableSequenceNumber;
244 enet_uint16 incomingUnreliableSequenceNumber;
245 ENetList incomingReliableCommands;
246 ENetList incomingUnreliableCommands;
247 } ENetChannel;
248
254 typedef struct _ENetPeer
255 {
256 ENetListNode dispatchList;
257 struct _ENetHost * host;
258 enet_uint16 outgoingPeerID;
259 enet_uint16 incomingPeerID;
260 enet_uint32 connectID;
261 enet_uint8 outgoingSessionID;
262 enet_uint8 incomingSessionID;
263 ENetAddress address;
264 void * data;
265 ENetPeerState state;
266 ENetChannel * channels;
267 size_t channelCount;
268 enet_uint32 incomingBandwidth;
269 enet_uint32 outgoingBandwidth;
270 enet_uint32 incomingBandwidthThrottleEpoch;
271 enet_uint32 outgoingBandwidthThrottleEpoch;
272 enet_uint32 incomingDataTotal;
273 enet_uint32 outgoingDataTotal;
274 enet_uint32 lastSendTime;
275 enet_uint32 lastReceiveTime;
276 enet_uint32 nextTimeout;
277 enet_uint32 earliestTimeout;
278 enet_uint32 packetLossEpoch;
279 enet_uint32 packetsSent;
280 enet_uint32 packetsLost;
281 enet_uint32 packetLoss;
282 enet_uint32 packetLossVariance;
283 enet_uint32 packetThrottle;
284 enet_uint32 packetThrottleLimit;
285 enet_uint32 packetThrottleCounter;
286 enet_uint32 packetThrottleEpoch;
287 enet_uint32 packetThrottleAcceleration;
288 enet_uint32 packetThrottleDeceleration;
289 enet_uint32 packetThrottleInterval;
290 enet_uint32 pingInterval;
291 enet_uint32 timeoutLimit;
292 enet_uint32 timeoutMinimum;
293 enet_uint32 timeoutMaximum;
294 enet_uint32 lastRoundTripTime;
295 enet_uint32 lowestRoundTripTime;
296 enet_uint32 lastRoundTripTimeVariance;
297 enet_uint32 highestRoundTripTimeVariance;
298 enet_uint32 roundTripTime;
299 enet_uint32 roundTripTimeVariance;
300 enet_uint32 mtu;
301 enet_uint32 windowSize;
302 enet_uint32 reliableDataInTransit;
303 enet_uint16 outgoingReliableSequenceNumber;
304 ENetList acknowledgements;
305 ENetList sentReliableCommands;
306 ENetList sentUnreliableCommands;
307 ENetList outgoingReliableCommands;
308 ENetList outgoingUnreliableCommands;
309 ENetList dispatchedCommands;
310 int needsDispatch;
311 enet_uint16 incomingUnsequencedGroup;
312 enet_uint16 outgoingUnsequencedGroup;
313 enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
314 enet_uint32 eventData;
315 size_t totalWaitingData;
316 } ENetPeer;
317
320 typedef struct _ENetCompressor
321 {
323 void * context;
325 size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
327 size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
329 void (ENET_CALLBACK * destroy) (void * context);
330 } ENetCompressor;
331
333 typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
334
336 typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
337
354 typedef struct _ENetHost
355 {
356 ENetSocket socket;
357 ENetAddress address;
358 enet_uint32 incomingBandwidth;
359 enet_uint32 outgoingBandwidth;
360 enet_uint32 bandwidthThrottleEpoch;
361 enet_uint32 mtu;
362 enet_uint32 randomSeed;
363 int recalculateBandwidthLimits;
364 ENetPeer * peers;
365 size_t peerCount;
366 size_t channelLimit;
367 enet_uint32 serviceTime;
368 ENetList dispatchQueue;
369 int continueSending;
370 size_t packetSize;
371 enet_uint16 headerFlags;
372 ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
373 size_t commandCount;
374 ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
375 size_t bufferCount;
376 ENetChecksumCallback checksum;
377 ENetCompressor compressor;
378 enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
379 ENetAddress receivedAddress;
380 enet_uint8 * receivedData;
381 size_t receivedDataLength;
382 enet_uint32 totalSentData;
383 enet_uint32 totalSentPackets;
384 enet_uint32 totalReceivedData;
385 enet_uint32 totalReceivedPackets;
386 ENetInterceptCallback intercept;
387 size_t connectedPeers;
388 size_t bandwidthLimitedPeers;
389 size_t duplicatePeers;
390 size_t maximumPacketSize;
391 size_t maximumWaitingData;
392 } ENetHost;
393
397 typedef enum _ENetEventType
398 {
400 ENET_EVENT_TYPE_NONE = 0,
401
405 ENET_EVENT_TYPE_CONNECT = 1,
406
414 ENET_EVENT_TYPE_DISCONNECT = 2,
415
422 ENET_EVENT_TYPE_RECEIVE = 3
423 } ENetEventType;
424
430 typedef struct _ENetEvent
431 {
432 ENetEventType type;
433 ENetPeer * peer;
434 enet_uint8 channelID;
435 enet_uint32 data;
436 ENetPacket * packet;
437 } ENetEvent;
438
448 ENET_API int enet_initialize (void);
449
457 ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
458
463 ENET_API void enet_deinitialize (void);
464
469 ENET_API ENetVersion enet_linked_version (void);
470
479 ENET_API enet_uint32 enet_time_get (void);
483 ENET_API void enet_time_set (enet_uint32);
484
488 ENET_API ENetSocket enet_socket_create (ENetSocketType);
489 ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
490 ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
491 ENET_API int enet_socket_listen (ENetSocket, int);
492 ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
493 ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
494 ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
495 ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
496 ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
497 ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
498 ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
499 ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
500 ENET_API void enet_socket_destroy (ENetSocket);
501 ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
502
516 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
517
526 ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
527
536 ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
537
540 ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
541 ENET_API void enet_packet_destroy (ENetPacket *);
542 ENET_API int enet_packet_resize (ENetPacket *, size_t);
543 ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
544
545 ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
546 ENET_API void enet_host_destroy (ENetHost *);
547 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
548 ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
549 ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
550 ENET_API void enet_host_flush (ENetHost *);
551 ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
552 ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
553 ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
554 ENET_API void enet_host_channel_limit (ENetHost *, size_t);
555 ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
556 extern void enet_host_bandwidth_throttle (ENetHost *);
557 extern enet_uint32 enet_host_random_seed (void);
558
559 ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
560 ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
561 ENET_API void enet_peer_ping (ENetPeer *);
562 ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32);
563 ENET_API void enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
564 ENET_API void enet_peer_reset (ENetPeer *);
565 ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
566 ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32);
567 ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32);
568 ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
569 extern int enet_peer_throttle (ENetPeer *, enet_uint32);
570 extern void enet_peer_reset_queues (ENetPeer *);
571 extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
572 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
573 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
574 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
575 extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
576 extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
577 extern void enet_peer_on_connect (ENetPeer *);
578 extern void enet_peer_on_disconnect (ENetPeer *);
579
580 ENET_API void * enet_range_coder_create (void);
581 ENET_API void enet_range_coder_destroy (void *);
582 ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
583 ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
584
585 extern size_t enet_protocol_command_size (enet_uint8);
586
587 #ifdef __cplusplus
588 }
589 #endif
590
591 #endif /* __ENET_ENET_H__ */
592
enet_host_flush
ENET_API void enet_host_flush(ENetHost *)
Sends any queued packets on the host specified to its designated peers.
Definition: protocol.c:1740
_ENetHost::peers
ENetPeer * peers
array of peers allocated for this host
Definition: enet.h:364
_ENetHost::totalSentData
enet_uint32 totalSentData
total data sent, user should reset to 0 as needed to prevent overflow
Definition: enet.h:382
ENET_PACKET_FLAG_SENT
whether the packet has been sent from all queues it has been entered into
Definition: enet.h:120
_ENetPeer::address
ENetAddress address
Internet address of the peer.
Definition: enet.h:263
types.h
type definitions for ENet
_ENetCompressor
An ENet packet compressor for compressing UDP packets before socket sends or receives.
Definition: enet.h:320
enet_peer_ping_interval
ENET_API void enet_peer_ping_interval(ENetPeer *, enet_uint32)
Sets the interval at which pings will be sent to a peer.
Definition: peer.c:458
enet_linked_version
ENET_API ENetVersion enet_linked_version(void)
Gives the linked version of the ENet library.
Definition: callbacks.c:32
enet_peer_timeout
ENET_API void enet_peer_timeout(ENetPeer *, enet_uint32, enet_uint32, enet_uint32)
Sets the timeout parameters for a peer.
Definition: peer.c:481
enet_time_get
ENET_API enet_uint32 enet_time_get(void)
Returns the wall-time in milliseconds.
Definition: unix.c:79
enet_host_check_events
ENET_API int enet_host_check_events(ENetHost *, ENetEvent *)
Checks for any queued events on the host and dispatches one if available.
Definition: protocol.c:1757
_ENetHost::totalSentPackets
enet_uint32 totalSentPackets
total UDP packets sent, user should reset to 0 as needed to prevent overflow
Definition: enet.h:383
enet_host_compress_with_range_coder
ENET_API int enet_host_compress_with_range_coder(ENetHost *host)
Sets the packet compressor the host should use to the default range coder.
Definition: compress.c:638
ENET_PACKET_FLAG_RELIABLE
packet must be received by the target peer and resend attempts should be made until the packet is del...
Definition: enet.h:108
_ENetPeer::data
void * data
Application private data, may be freely modified.
Definition: enet.h:264
_ENetAddress
Portable internet address structure.
Definition: enet.h:89
_ENetList
Definition: list.h:18
enet_packet_destroy
ENET_API void enet_packet_destroy(ENetPacket *)
Destroys the packet and deallocates its data.
Definition: packet.c:57
enet_peer_disconnect_later
ENET_API void enet_peer_disconnect_later(ENetPeer *, enet_uint32)
Request a disconnection from a peer, but only after all queued outgoing packets are sent...
Definition: peer.c:570
enet_uint32
unsigned int enet_uint32
unsigned 32-bit type
Definition: types.h:10
enet_packet_resize
ENET_API int enet_packet_resize(ENetPacket *, size_t)
Attempts to resize the data in the packet to length specified in the dataLength parameter.
Definition: packet.c:77
enet_host_connect
ENET_API ENetPeer * enet_host_connect(ENetHost *, const ENetAddress *, size_t, enet_uint32)
Initiates a connection to a foreign host.
Definition: host.c:174
_ENetHost::address
ENetAddress address
Internet address of the host.
Definition: enet.h:357
ENET_PACKET_FLAG_UNSEQUENCED
packet will not be sequenced with other packets not supported for reliable packets ...
Definition: enet.h:112
_ENetHost::checksum
ENetChecksumCallback checksum
callback the user can set to enable packet checksums for this host
Definition: enet.h:376
ENET_EVENT_TYPE_RECEIVE
a packet has been received from a peer.
Definition: enet.h:422
enet_peer_ping
ENET_API void enet_peer_ping(ENetPeer *)
Sends a ping request to a peer.
Definition: peer.c:435
enet_host_destroy
ENET_API void enet_host_destroy(ENetHost *)
Destroys the host and all resources associated with it.
Definition: host.c:141
_ENetHost::totalReceivedData
enet_uint32 totalReceivedData
total data received, user should reset to 0 as needed to prevent overflow
Definition: enet.h:384
ENetPacket
struct _ENetPacket ENetPacket
ENet packet structure.
_ENetPeer::channelCount
size_t channelCount
Number of channels allocated for communication with peer.
Definition: enet.h:267
enet_address_get_host
ENET_API int enet_address_get_host(const ENetAddress *address, char *hostName, size_t nameLength)
Attempts to do a reverse lookup of the host field in the address parameter.
Definition: unix.c:154
_ENetHost::channelLimit
size_t channelLimit
maximum number of channels allowed for connected peers
Definition: enet.h:366
_ENetPacket::referenceCount
size_t referenceCount
internal use only
Definition: enet.h:146
_ENetPacket::flags
enet_uint32 flags
bitwise-or of ENetPacketFlag constants
Definition: enet.h:147
protocol.h
ENet protocol.
_ENetPacket::data
enet_uint8 * data
allocated data for packet
Definition: enet.h:148
_ENetHost::duplicatePeers
size_t duplicatePeers
optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID ...
Definition: enet.h:389
enet_packet_create
ENET_API ENetPacket * enet_packet_create(const void *, size_t, enet_uint32)
Creates a packet that may be sent to a peer.
Definition: packet.c:20
enet_host_service
ENET_API int enet_host_service(ENetHost *, ENetEvent *, enet_uint32)
Waits for events on the host specified and shuttles packets between the host and its peers...
Definition: protocol.c:1782
_ENetPeer::outgoingBandwidth
enet_uint32 outgoingBandwidth
Upstream bandwidth of the client in bytes/second.
Definition: enet.h:269
_ENetListNode
Definition: list.h:10
_ENetEvent::peer
ENetPeer * peer
peer that generated a connect, disconnect or receive event
Definition: enet.h:433
_ENetPacket::freeCallback
ENetPacketFreeCallback freeCallback
function to be called when the packet is no longer in use
Definition: enet.h:150
_ENetCallbacks
Definition: callbacks.h:10
enet_peer_receive
ENET_API ENetPacket * enet_peer_receive(ENetPeer *, enet_uint8 *channelID)
Attempts to dequeue any incoming queued packet.
Definition: peer.c:222
ENET_PACKET_FLAG_NO_ALLOCATE
packet will not allocate data, and user must supply it instead
Definition: enet.h:114
_ENetAcknowledgement
Definition: enet.h:154
_ENetEvent
An ENet event as returned by enet_host_service().
Definition: enet.h:430
enet_host_broadcast
ENET_API void enet_host_broadcast(ENetHost *, enet_uint8, ENetPacket *)
Queues a packet to be sent to all peers associated with the host.
Definition: host.c:261
ENetEventType
enum _ENetEventType ENetEventType
An ENet event type, as specified in ENetEvent.
enet_peer_disconnect
ENET_API void enet_peer_disconnect(ENetPeer *, enet_uint32)
Request a disconnection from a peer.
Definition: peer.c:527
enet_address_get_host_ip
ENET_API int enet_address_get_host_ip(const ENetAddress *address, char *hostName, size_t nameLength)
Gives the printable form of the IP address specified in the address parameter.
Definition: unix.c:134
_ENetHost::outgoingBandwidth
enet_uint32 outgoingBandwidth
upstream bandwidth of the host
Definition: enet.h:359
_ENetIncomingCommand
Definition: enet.h:176
_ENetChannel
Definition: enet.h:237
enet_initialize_with_callbacks
ENET_API int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits)
Initializes ENet globally and supplies user-overridden callbacks.
Definition: callbacks.c:11
list.h
ENet list management.
ENetCompressor
struct _ENetCompressor ENetCompressor
An ENet packet compressor for compressing UDP packets before socket sends or receives.
enet_address_set_host
ENET_API int enet_address_set_host(ENetAddress *address, const char *hostName)
Attempts to resolve the host named by the parameter hostName and sets the host field in the address p...
Definition: unix.c:99
ENetPeer
struct _ENetPeer ENetPeer
An ENet peer which data packets may be sent or received from.
_ENetProtocol
Definition: protocol.h:177
_ENetCompressor::void
void(ENET_CALLBACK *destroy)(void *context)
Destroys the context when compression is disabled or the host is destroyed.
ENetPacketFlag
enum _ENetPacketFlag ENetPacketFlag
Packet flag bit constants.
enet_uint16
unsigned short enet_uint16
unsigned 16-bit type
Definition: types.h:9
_ENetOutgoingCommand
Definition: enet.h:161
enet_host_bandwidth_limit
ENET_API void enet_host_bandwidth_limit(ENetHost *, enet_uint32, enet_uint32)
Adjusts the bandwidth limits of a host.
Definition: host.c:320
enet_uint8
unsigned char enet_uint8
unsigned 8-bit type
Definition: types.h:8
enet_host_create
ENET_API ENetHost * enet_host_create(const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32)
Creates a host for communicating to peers.
Definition: host.c:29
enet_deinitialize
ENET_API void enet_deinitialize(void)
Shuts down ENet globally.
Definition: unix.c:68
_ENetPeer
An ENet peer which data packets may be sent or received from.
Definition: enet.h:254
ENetAddress
struct _ENetAddress ENetAddress
Portable internet address structure.
_ENetHost::incomingBandwidth
enet_uint32 incomingBandwidth
downstream bandwidth of the host
Definition: enet.h:358
ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT
packet will be fragmented using unreliable (instead of reliable) sends if it exceeds the MTU ...
Definition: enet.h:117
ENetHost
struct _ENetHost ENetHost
An ENet host for communicating with peers.
enet_host_channel_limit
ENET_API void enet_host_channel_limit(ENetHost *, size_t)
Limits the maximum allowed channels of future incoming connections.
Definition: host.c:300
_ENetHost::maximumPacketSize
size_t maximumPacketSize
the maximum allowable packet size that may be sent or received on a peer
Definition: enet.h:390
_ENetPeer::incomingBandwidth
enet_uint32 incomingBandwidth
Downstream bandwidth of the client in bytes/second.
Definition: enet.h:268
_ENetHost
An ENet host for communicating with peers.
Definition: enet.h:354
_ENetEvent::data
enet_uint32 data
data associated with the event, if appropriate
Definition: enet.h:435
_ENetPacket::userData
void * userData
application private data, may be freely modified
Definition: enet.h:151
ENetEvent
struct _ENetEvent ENetEvent
An ENet event as returned by enet_host_service().
enet_time_set
ENET_API void enet_time_set(enet_uint32)
Sets the current wall-time in milliseconds.
Definition: unix.c:89
ENetBuffer
Definition: unix.h:29
enet_host_compress
ENET_API void enet_host_compress(ENetHost *, const ENetCompressor *)
Sets the packet compressor the host should use to compress and decompress packets.
Definition: host.c:284
_ENetPacket
ENet packet structure.
Definition: enet.h:144
unix.h
ENet Unix header.
_ENetCompressor::size_t
size_t(ENET_CALLBACK *compress)(void *context
Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes.
enet_peer_send
ENET_API int enet_peer_send(ENetPeer *, enet_uint8, ENetPacket *)
Queues a packet to be sent.
Definition: peer.c:100
_ENetPacket::dataLength
size_t dataLength
length of data
Definition: enet.h:149
enet_peer_throttle_configure
ENET_API void enet_peer_throttle_configure(ENetPeer *, enet_uint32, enet_uint32, enet_uint32)
Configures throttle parameter for a peer.
Definition: peer.c:43
enet_peer_disconnect_now
ENET_API void enet_peer_disconnect_now(ENetPeer *, enet_uint32)
Force an immediate disconnection from a peer.
Definition: peer.c:496
_ENetEvent::channelID
enet_uint8 channelID
channel on the peer that generated the event, if appropriate
Definition: enet.h:434
int
typedef int(ENET_CALLBACK *ENetInterceptCallback)(struct _ENetHost *host
Callback for intercepting received raw UDP packets.
_ENetHost::totalReceivedPackets
enet_uint32 totalReceivedPackets
total UDP packets received, user should reset to 0 as needed to prevent overflow
Definition: enet.h:385
ENET_EVENT_TYPE_DISCONNECT
a peer has disconnected.
Definition: enet.h:414
enet_uint32
typedef enet_uint32(ENET_CALLBACK *ENetChecksumCallback)(const ENetBuffer *buffers
Callback that computes the checksum of the data held in buffers[0:bufferCount-1]. ...
_ENetCompressor::context
void * context
Context data for the compressor.
Definition: enet.h:323
ENET_EVENT_TYPE_CONNECT
a connection request initiated by enet_host_connect has completed.
Definition: enet.h:405
enet_initialize
ENET_API int enet_initialize(void)
Initializes ENet globally.
Definition: unix.c:62
enet_peer_reset
ENET_API void enet_peer_reset(ENetPeer *)
Forcefully disconnects a peer.
Definition: peer.c:372
_ENetEvent::packet
ENetPacket * packet
packet associated with the event, if appropriate
Definition: enet.h:436
ENET_EVENT_TYPE_NONE
no event occurred within the specified time limit
Definition: enet.h:400
_ENetEventType
_ENetEventType
An ENet event type, as specified in ENetEvent.
Definition: enet.h:397
_ENetPacketFlag
_ENetPacketFlag
Packet flag bit constants.
Definition: enet.h:104
callbacks.h
ENet callbacks.
_ENetPeer::roundTripTime
enet_uint32 roundTripTime
mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its ackn...
Definition: enet.h:298
win32.h
ENet Win32 header.
_ENetHost::maximumWaitingData
size_t maximumWaitingData
the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered ...
Definition: enet.h:391
_ENetHost::intercept
ENetInterceptCallback intercept
callback the user can set to intercept received raw UDP packets
Definition: enet.h:386
_ENetEvent::type
ENetEventType type
type of the event
Definition: enet.h:432
_ENetPeer::packetLoss
enet_uint32 packetLoss
mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SC...
Definition: enet.h:281
_ENetHost::peerCount
size_t peerCount
number of peers allocated for this host
Definition: enet.h:365