summaryrefslogtreecommitdiff
path: root/apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h')
-rw-r--r--apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h592
1 files changed, 0 insertions, 592 deletions
diff --git a/apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h b/apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h
deleted file mode 100644
index ac1ca8636a..0000000000
--- a/apps/plugins/sdl/progs/duke3d/Engine/src/enet/include/enet.h
+++ /dev/null
@@ -1,592 +0,0 @@
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 "win32.h"
17#else
18#include "unix.h"
19#endif
20
21#include "types.h"
22#include "protocol.h"
23#include "list.h"
24#include "callbacks.h"
25
26#define ENET_VERSION_MAJOR 1
27#define ENET_VERSION_MINOR 3
28#define ENET_VERSION_PATCH 13
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
35typedef enet_uint32 ENetVersion;
36
37struct _ENetHost;
38struct _ENetEvent;
39struct _ENetPacket;
40
41typedef enum _ENetSocketType
42{
43 ENET_SOCKET_TYPE_STREAM = 1,
44 ENET_SOCKET_TYPE_DATAGRAM = 2
45} ENetSocketType;
46
47typedef 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
55typedef 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
68typedef 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
79/**
80 * Portable internet address structure.
81 *
82 * The host must be specified in network byte-order, and the port must be in host
83 * byte-order. The constant ENET_HOST_ANY may be used to specify the default
84 * server host. The constant ENET_HOST_BROADCAST may be used to specify the
85 * broadcast address (255.255.255.255). This makes sense for enet_host_connect,
86 * but not for enet_host_create. Once a server responds to a broadcast, the
87 * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
88 */
89typedef struct _ENetAddress
90{
91 enet_uint32 host;
92 enet_uint16 port;
93} ENetAddress;
94
95/**
96 * Packet flag bit constants.
97 *
98 * The host must be specified in network byte-order, and the port must be in
99 * host byte-order. The constant ENET_HOST_ANY may be used to specify the
100 * default server host.
101
102 @sa ENetPacket
103*/
104typedef enum _ENetPacketFlag
105{
106 /** packet must be received by the target peer and resend attempts should be
107 * made until the packet is delivered */
108 ENET_PACKET_FLAG_RELIABLE = (1 << 0),
109 /** packet will not be sequenced with other packets
110 * not supported for reliable packets
111 */
112 ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
113 /** packet will not allocate data, and user must supply it instead */
114 ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
115 /** packet will be fragmented using unreliable (instead of reliable) sends
116 * if it exceeds the MTU */
117 ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
118
119 /** whether the packet has been sent from all queues it has been entered into */
120 ENET_PACKET_FLAG_SENT = (1<<8)
121} ENetPacketFlag;
122
123typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
124
125/**
126 * ENet packet structure.
127 *
128 * An ENet data packet that may be sent to or received from a peer. The shown
129 * fields should only be read and never modified. The data field contains the
130 * allocated data for the packet. The dataLength fields specifies the length
131 * of the allocated data. The flags field is either 0 (specifying no flags),
132 * or a bitwise-or of any combination of the following flags:
133 *
134 * ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
135 * and resend attempts should be made until the packet is delivered
136 *
137 * ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets
138 * (not supported for reliable packets)
139 *
140 * ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
141
142 @sa ENetPacketFlag
143 */
144typedef struct _ENetPacket
145{
146 size_t referenceCount; /**< internal use only */
147 enet_uint32 flags; /**< bitwise-or of ENetPacketFlag constants */
148 enet_uint8 * data; /**< allocated data for packet */
149 size_t dataLength; /**< length of data */
150 ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
151 void * userData; /**< application private data, may be freely modified */
152} ENetPacket;
153
154typedef struct _ENetAcknowledgement
155{
156 ENetListNode acknowledgementList;
157 enet_uint32 sentTime;
158 ENetProtocol command;
159} ENetAcknowledgement;
160
161typedef 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
176typedef 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
188typedef 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
206enum
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
237typedef 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
249/**
250 * An ENet peer which data packets may be sent or received from.
251 *
252 * No fields should be modified unless otherwise specified.
253 */
254typedef 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; /**< Internet address of the peer */
264 void * data; /**< Application private data, may be freely modified */
265 ENetPeerState state;
266 ENetChannel * channels;
267 size_t channelCount; /**< Number of channels allocated for communication with peer */
268 enet_uint32 incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
269 enet_uint32 outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
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; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
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; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
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
318/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
319 */
320typedef struct _ENetCompressor
321{
322 /** Context data for the compressor. Must be non-NULL. */
323 void * context;
324 /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
325 size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
326 /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
327 size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
328 /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
329 void (ENET_CALLBACK * destroy) (void * context);
330} ENetCompressor;
331
332/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
333typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
334
335/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
336typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
337
338/** An ENet host for communicating with peers.
339 *
340 * No fields should be modified unless otherwise stated.
341
342 @sa enet_host_create()
343 @sa enet_host_destroy()
344 @sa enet_host_connect()
345 @sa enet_host_service()
346 @sa enet_host_flush()
347 @sa enet_host_broadcast()
348 @sa enet_host_compress()
349 @sa enet_host_compress_with_range_coder()
350 @sa enet_host_channel_limit()
351 @sa enet_host_bandwidth_limit()
352 @sa enet_host_bandwidth_throttle()
353 */
354typedef struct _ENetHost
355{
356 ENetSocket socket;
357 ENetAddress address; /**< Internet address of the host */
358 enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */
359 enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */
360 enet_uint32 bandwidthThrottleEpoch;
361 enet_uint32 mtu;
362 enet_uint32 randomSeed;
363 int recalculateBandwidthLimits;
364 ENetPeer * peers; /**< array of peers allocated for this host */
365 size_t peerCount; /**< number of peers allocated for this host */
366 size_t channelLimit; /**< maximum number of channels allowed for connected peers */
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; /**< callback the user can set to enable packet checksums for this host */
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; /**< total data sent, user should reset to 0 as needed to prevent overflow */
383 enet_uint32 totalSentPackets; /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
384 enet_uint32 totalReceivedData; /**< total data received, user should reset to 0 as needed to prevent overflow */
385 enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
386 ENetInterceptCallback intercept; /**< callback the user can set to intercept received raw UDP packets */
387 size_t connectedPeers;
388 size_t bandwidthLimitedPeers;
389 size_t duplicatePeers; /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
390 size_t maximumPacketSize; /**< the maximum allowable packet size that may be sent or received on a peer */
391 size_t maximumWaitingData; /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
392} ENetHost;
393
394/**
395 * An ENet event type, as specified in @ref ENetEvent.
396 */
397typedef enum _ENetEventType
398{
399 /** no event occurred within the specified time limit */
400 ENET_EVENT_TYPE_NONE = 0,
401
402 /** a connection request initiated by enet_host_connect has completed.
403 * The peer field contains the peer which successfully connected.
404 */
405 ENET_EVENT_TYPE_CONNECT = 1,
406
407 /** a peer has disconnected. This event is generated on a successful
408 * completion of a disconnect initiated by enet_pper_disconnect, if
409 * a peer has timed out, or if a connection request intialized by
410 * enet_host_connect has timed out. The peer field contains the peer
411 * which disconnected. The data field contains user supplied data
412 * describing the disconnection, or 0, if none is available.
413 */
414 ENET_EVENT_TYPE_DISCONNECT = 2,
415
416 /** a packet has been received from a peer. The peer field specifies the
417 * peer which sent the packet. The channelID field specifies the channel
418 * number upon which the packet was received. The packet field contains
419 * the packet that was received; this packet must be destroyed with
420 * enet_packet_destroy after use.
421 */
422 ENET_EVENT_TYPE_RECEIVE = 3
423} ENetEventType;
424
425/**
426 * An ENet event as returned by enet_host_service().
427
428 @sa enet_host_service
429 */
430typedef struct _ENetEvent
431{
432 ENetEventType type; /**< type of the event */
433 ENetPeer * peer; /**< peer that generated a connect, disconnect or receive event */
434 enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */
435 enet_uint32 data; /**< data associated with the event, if appropriate */
436 ENetPacket * packet; /**< packet associated with the event, if appropriate */
437} ENetEvent;
438
439/** @defgroup global ENet global functions
440 @{
441*/
442
443/**
444 Initializes ENet globally. Must be called prior to using any functions in
445 ENet.
446 @returns 0 on success, < 0 on failure
447*/
448ENET_API int enet_initialize (void);
449
450/**
451 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.
452
453 @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
454 @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
455 @returns 0 on success, < 0 on failure
456*/
457ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
458
459/**
460 Shuts down ENet globally. Should be called when a program that has
461 initialized ENet exits.
462*/
463ENET_API void enet_deinitialize (void);
464
465/**
466 Gives the linked version of the ENet library.
467 @returns the version number
468*/
469ENET_API ENetVersion enet_linked_version (void);
470
471/** @} */
472
473/** @defgroup private ENet private implementation functions */
474
475/**
476 Returns the wall-time in milliseconds. Its initial value is unspecified
477 unless otherwise set.
478 */
479ENET_API enet_uint32 enet_time_get (void);
480/**
481 Sets the current wall-time in milliseconds.
482 */
483ENET_API void enet_time_set (enet_uint32);
484
485/** @defgroup socket ENet socket functions
486 @{
487*/
488ENET_API ENetSocket enet_socket_create (ENetSocketType);
489ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
490ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *);
491ENET_API int enet_socket_listen (ENetSocket, int);
492ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
493ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
494ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
495ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
496ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
497ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
498ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
499ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
500ENET_API void enet_socket_destroy (ENetSocket);
501ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
502
503/** @} */
504
505/** @defgroup Address ENet address functions
506 @{
507*/
508/** Attempts to resolve the host named by the parameter hostName and sets
509 the host field in the address parameter if successful.
510 @param address destination to store resolved address
511 @param hostName host name to lookup
512 @retval 0 on success
513 @retval < 0 on failure
514 @returns the address of the given hostName in address on success
515*/
516ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
517
518/** Gives the printable form of the IP address specified in the address parameter.
519 @param address address printed
520 @param hostName destination for name, must not be NULL
521 @param nameLength maximum length of hostName.
522 @returns the null-terminated name of the host in hostName on success
523 @retval 0 on success
524 @retval < 0 on failure
525*/
526ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
527
528/** Attempts to do a reverse lookup of the host field in the address parameter.
529 @param address address used for reverse lookup
530 @param hostName destination for name, must not be NULL
531 @param nameLength maximum length of hostName.
532 @returns the null-terminated name of the host in hostName on success
533 @retval 0 on success
534 @retval < 0 on failure
535*/
536ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
537
538/** @} */
539
540ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
541ENET_API void enet_packet_destroy (ENetPacket *);
542ENET_API int enet_packet_resize (ENetPacket *, size_t);
543ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
544
545ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
546ENET_API void enet_host_destroy (ENetHost *);
547ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
548ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
549ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
550ENET_API void enet_host_flush (ENetHost *);
551ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
552ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *);
553ENET_API int enet_host_compress_with_range_coder (ENetHost * host);
554ENET_API void enet_host_channel_limit (ENetHost *, size_t);
555ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
556extern void enet_host_bandwidth_throttle (ENetHost *);
557extern enet_uint32 enet_host_random_seed (void);
558
559ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
560ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
561ENET_API void enet_peer_ping (ENetPeer *);
562ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32);
563ENET_API void enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
564ENET_API void enet_peer_reset (ENetPeer *);
565ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
566ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32);
567ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32);
568ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
569extern int enet_peer_throttle (ENetPeer *, enet_uint32);
570extern void enet_peer_reset_queues (ENetPeer *);
571extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
572extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
573extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
574extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
575extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
576extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
577extern void enet_peer_on_connect (ENetPeer *);
578extern void enet_peer_on_disconnect (ENetPeer *);
579
580ENET_API void * enet_range_coder_create (void);
581ENET_API void enet_range_coder_destroy (void *);
582ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
583ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
584
585extern size_t enet_protocol_command_size (enet_uint8);
586
587#ifdef __cplusplus
588}
589#endif
590
591#endif /* __ENET_ENET_H__ */
592
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-17 22:23:56 +0000