• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

enet.h

Go to the documentation of this file.
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 4
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    ENET_SOCKOPT_RCVTIMEO  = 6,
00055    ENET_SOCKOPT_SNDTIMEO  = 7
00056 } ENetSocketOption;
00057 
00058 enum
00059 {
00060    ENET_HOST_ANY       = 0,            
00061    ENET_HOST_BROADCAST = 0xFFFFFFFF,   
00063    ENET_PORT_ANY       = 0             
00064 };
00065 
00076 typedef struct _ENetAddress
00077 {
00078    enet_uint32 host;
00079    enet_uint16 port;
00080 } ENetAddress;
00081 
00091 typedef enum _ENetPacketFlag
00092 {
00095    ENET_PACKET_FLAG_RELIABLE    = (1 << 0),
00099    ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
00101    ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
00104    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3)
00105 } ENetPacketFlag;
00106 
00107 struct _ENetPacket;
00108 typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
00109 
00129 typedef struct _ENetPacket
00130 {
00131    size_t                   referenceCount;  
00132    enet_uint32              flags;           
00133    enet_uint8 *             data;            
00134    size_t                   dataLength;      
00135    ENetPacketFreeCallback   freeCallback;    
00136 } ENetPacket;
00137 
00138 typedef struct _ENetAcknowledgement
00139 {
00140    ENetListNode acknowledgementList;
00141    enet_uint32  sentTime;
00142    ENetProtocol command;
00143 } ENetAcknowledgement;
00144 
00145 typedef struct _ENetOutgoingCommand
00146 {
00147    ENetListNode outgoingCommandList;
00148    enet_uint16  reliableSequenceNumber;
00149    enet_uint16  unreliableSequenceNumber;
00150    enet_uint32  sentTime;
00151    enet_uint32  roundTripTimeout;
00152    enet_uint32  roundTripTimeoutLimit;
00153    enet_uint32  fragmentOffset;
00154    enet_uint16  fragmentLength;
00155    enet_uint16  sendAttempts;
00156    ENetProtocol command;
00157    ENetPacket * packet;
00158 } ENetOutgoingCommand;
00159 
00160 typedef struct _ENetIncomingCommand
00161 {  
00162    ENetListNode     incomingCommandList;
00163    enet_uint16      reliableSequenceNumber;
00164    enet_uint16      unreliableSequenceNumber;
00165    ENetProtocol     command;
00166    enet_uint32      fragmentCount;
00167    enet_uint32      fragmentsRemaining;
00168    enet_uint32 *    fragments;
00169    ENetPacket *     packet;
00170 } ENetIncomingCommand;
00171 
00172 typedef enum _ENetPeerState
00173 {
00174    ENET_PEER_STATE_DISCONNECTED                = 0,
00175    ENET_PEER_STATE_CONNECTING                  = 1,
00176    ENET_PEER_STATE_ACKNOWLEDGING_CONNECT       = 2,
00177    ENET_PEER_STATE_CONNECTION_PENDING          = 3,
00178    ENET_PEER_STATE_CONNECTION_SUCCEEDED        = 4,
00179    ENET_PEER_STATE_CONNECTED                   = 5,
00180    ENET_PEER_STATE_DISCONNECT_LATER            = 6,
00181    ENET_PEER_STATE_DISCONNECTING               = 7,
00182    ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT    = 8,
00183    ENET_PEER_STATE_ZOMBIE                      = 9 
00184 } ENetPeerState;
00185 
00186 #ifndef ENET_BUFFER_MAXIMUM
00187 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
00188 #endif
00189 
00190 enum
00191 {
00192    ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
00193    ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
00194    ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
00195    ENET_HOST_DEFAULT_MTU                  = 1400,
00196 
00197    ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
00198    ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
00199    ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
00200    ENET_PEER_PACKET_THROTTLE_COUNTER      = 7, 
00201    ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
00202    ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
00203    ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
00204    ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
00205    ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
00206    ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
00207    ENET_PEER_TIMEOUT_LIMIT                = 32,
00208    ENET_PEER_TIMEOUT_MINIMUM              = 5000,
00209    ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
00210    ENET_PEER_PING_INTERVAL                = 500,
00211    ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
00212    ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
00213    ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
00214    ENET_PEER_RELIABLE_WINDOWS             = 16,
00215    ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
00216    ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
00217 };
00218 
00219 typedef struct _ENetChannel
00220 {
00221    enet_uint16  outgoingReliableSequenceNumber;
00222    enet_uint16  outgoingUnreliableSequenceNumber;
00223    enet_uint16  usedReliableWindows;
00224    enet_uint16  reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
00225    enet_uint16  incomingReliableSequenceNumber;
00226    enet_uint16  incomingUnreliableSequenceNumber;
00227    ENetList     incomingReliableCommands;
00228    ENetList     incomingUnreliableCommands;
00229 } ENetChannel;
00230 
00236 typedef struct _ENetPeer
00237 { 
00238    ENetListNode  dispatchList;
00239    struct _ENetHost * host;
00240    enet_uint16   outgoingPeerID;
00241    enet_uint16   incomingPeerID;
00242    enet_uint32   connectID;
00243    enet_uint8    outgoingSessionID;
00244    enet_uint8    incomingSessionID;
00245    ENetAddress   address;            
00246    void *        data;               
00247    ENetPeerState state;
00248    ENetChannel * channels;
00249    size_t        channelCount;       
00250    enet_uint32   incomingBandwidth;  
00251    enet_uint32   outgoingBandwidth;  
00252    enet_uint32   incomingBandwidthThrottleEpoch;
00253    enet_uint32   outgoingBandwidthThrottleEpoch;
00254    enet_uint32   incomingDataTotal;
00255    enet_uint32   outgoingDataTotal;
00256    enet_uint32   lastSendTime;
00257    enet_uint32   lastReceiveTime;
00258    enet_uint32   nextTimeout;
00259    enet_uint32   earliestTimeout;
00260    enet_uint32   packetLossEpoch;
00261    enet_uint32   packetsSent;
00262    enet_uint32   packetsLost;
00263    enet_uint32   packetLoss;          
00264    enet_uint32   packetLossVariance;
00265    enet_uint32   packetThrottle;
00266    enet_uint32   packetThrottleLimit;
00267    enet_uint32   packetThrottleCounter;
00268    enet_uint32   packetThrottleEpoch;
00269    enet_uint32   packetThrottleAcceleration;
00270    enet_uint32   packetThrottleDeceleration;
00271    enet_uint32   packetThrottleInterval;
00272    enet_uint32   pingInterval;
00273    enet_uint32   timeoutLimit;
00274    enet_uint32   timeoutMinimum;
00275    enet_uint32   timeoutMaximum;
00276    enet_uint32   lastRoundTripTime;
00277    enet_uint32   lowestRoundTripTime;
00278    enet_uint32   lastRoundTripTimeVariance;
00279    enet_uint32   highestRoundTripTimeVariance;
00280    enet_uint32   roundTripTime;            
00281    enet_uint32   roundTripTimeVariance;
00282    enet_uint32   mtu;
00283    enet_uint32   windowSize;
00284    enet_uint32   reliableDataInTransit;
00285    enet_uint16   outgoingReliableSequenceNumber;
00286    ENetList      acknowledgements;
00287    ENetList      sentReliableCommands;
00288    ENetList      sentUnreliableCommands;
00289    ENetList      outgoingReliableCommands;
00290    ENetList      outgoingUnreliableCommands;
00291    ENetList      dispatchedCommands;
00292    int           needsDispatch;
00293    enet_uint16   incomingUnsequencedGroup;
00294    enet_uint16   outgoingUnsequencedGroup;
00295    enet_uint32   unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 
00296    enet_uint32   eventData;
00297 } ENetPeer;
00298 
00301 typedef struct _ENetCompressor
00302 {
00304    void * context;
00306    size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
00308    size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
00310    void (ENET_CALLBACK * destroy) (void * context);
00311 } ENetCompressor;
00312 
00314 typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
00315  
00332 typedef struct _ENetHost
00333 {
00334    ENetSocket           socket;
00335    ENetAddress          address;                     
00336    enet_uint32          incomingBandwidth;           
00337    enet_uint32          outgoingBandwidth;           
00338    enet_uint32          bandwidthThrottleEpoch;
00339    enet_uint32          mtu;
00340    enet_uint32          randomSeed;
00341    int                  recalculateBandwidthLimits;
00342    ENetPeer *           peers;                       
00343    size_t               peerCount;                   
00344    size_t               channelLimit;                
00345    enet_uint32          serviceTime;
00346    ENetList             dispatchQueue;
00347    int                  continueSending;
00348    size_t               packetSize;
00349    enet_uint16          headerFlags;
00350    ENetProtocol         commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
00351    size_t               commandCount;
00352    ENetBuffer           buffers [ENET_BUFFER_MAXIMUM];
00353    size_t               bufferCount;
00354    ENetChecksumCallback checksum;                    
00355    ENetCompressor       compressor;
00356    enet_uint8           packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
00357    ENetAddress          receivedAddress;
00358    enet_uint8 *         receivedData;
00359    size_t               receivedDataLength;
00360    enet_uint32          totalSentData;               
00361    enet_uint32          totalSentPackets;            
00362    enet_uint32          totalReceivedData;           
00363    enet_uint32          totalReceivedPackets;        
00364 } ENetHost;
00365 
00369 typedef enum _ENetEventType
00370 {
00372    ENET_EVENT_TYPE_NONE       = 0,  
00373 
00377    ENET_EVENT_TYPE_CONNECT    = 1,  
00378 
00386    ENET_EVENT_TYPE_DISCONNECT = 2,  
00387 
00394    ENET_EVENT_TYPE_RECEIVE    = 3
00395 } ENetEventType;
00396 
00402 typedef struct _ENetEvent 
00403 {
00404    ENetEventType        type;      
00405    ENetPeer *           peer;      
00406    enet_uint8           channelID; 
00407    enet_uint32          data;      
00408    ENetPacket *         packet;    
00409 } ENetEvent;
00410 
00420 ENET_API int enet_initialize (void);
00421 
00429 ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
00430 
00435 ENET_API void enet_deinitialize (void);
00436 
00445 ENET_API enet_uint32 enet_time_get (void);
00449 ENET_API void enet_time_set (enet_uint32);
00450 
00454 ENET_API ENetSocket enet_socket_create (ENetSocketType);
00455 ENET_API int        enet_socket_bind (ENetSocket, const ENetAddress *);
00456 ENET_API int        enet_socket_listen (ENetSocket, int);
00457 ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
00458 ENET_API int        enet_socket_connect (ENetSocket, const ENetAddress *);
00459 ENET_API int        enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
00460 ENET_API int        enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
00461 ENET_API int        enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
00462 ENET_API int        enet_socket_set_option (ENetSocket, ENetSocketOption, int);
00463 ENET_API void       enet_socket_destroy (ENetSocket);
00464 ENET_API int        enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
00465 
00479 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
00480 
00489 ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
00490 
00499 ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
00500 
00503 ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
00504 ENET_API void         enet_packet_destroy (ENetPacket *);
00505 ENET_API int          enet_packet_resize  (ENetPacket *, size_t);
00506 ENET_API enet_uint32  enet_crc32 (const ENetBuffer *, size_t);
00507                 
00508 ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
00509 ENET_API void       enet_host_destroy (ENetHost *);
00510 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
00511 ENET_API int        enet_host_check_events (ENetHost *, ENetEvent *);
00512 ENET_API int        enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
00513 ENET_API void       enet_host_flush (ENetHost *);
00514 ENET_API void       enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
00515 ENET_API void       enet_host_compress (ENetHost *, const ENetCompressor *);
00516 ENET_API int        enet_host_compress_with_range_coder (ENetHost * host);
00517 ENET_API void       enet_host_channel_limit (ENetHost *, size_t);
00518 ENET_API void       enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
00519 extern   void       enet_host_bandwidth_throttle (ENetHost *);
00520 
00521 ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
00522 ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
00523 ENET_API void                enet_peer_ping (ENetPeer *);
00524 ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
00525 ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
00526 ENET_API void                enet_peer_reset (ENetPeer *);
00527 ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
00528 ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
00529 ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
00530 ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
00531 extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
00532 extern void                  enet_peer_reset_queues (ENetPeer *);
00533 extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
00534 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
00535 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
00536 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
00537 extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
00538 extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
00539 
00540 ENET_API void * enet_range_coder_create (void);
00541 ENET_API void   enet_range_coder_destroy (void *);
00542 ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
00543 ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
00544    
00545 extern size_t enet_protocol_command_size (enet_uint8);
00546 
00547 #ifdef __cplusplus
00548 }
00549 #endif
00550 
00551 #endif /* __ENET_ENET_H__ */
00552 

Generated on Tue May 29 2012 10:40:44 for enet by  doxygen 1.7.1