RakPeer.h

Go to the documentation of this file.

// TODO - RakNet 4 - Add network simulator
// TODO - RakNet 4 - Enable disabling flow control per connections

#ifndef __RAK_PEER_H
#define __RAK_PEER_H

#include "ReliabilityLayer.h"
#include "RakPeerInterface.h"
#include "BitStream.h"
#include "SingleProducerConsumer.h"
#include "SimpleMutex.h"
#include "DS_OrderedList.h"
#include "Export.h"
#include "RakString.h"
#include "RakThread.h"
#include "RakNetSocket.h"
#include "RakNetSmartPtr.h"
#include "DS_ThreadsafeAllocatingQueue.h"
#include "SignaledEvent.h"
#include "NativeFeatureIncludes.h"
#include "SecureHandshake.h"
#include "LocklessTypes.h"

namespace RakNet {
class HuffmanEncodingTree;
class PluginInterface2;

// Sucks but this struct has to be outside the class.  Inside and DevCPP won't let you refer to the struct as RakPeer::RemoteSystemIndex while GCC
// forces you to do RakPeer::RemoteSystemIndex
struct RemoteSystemIndex{unsigned index; RemoteSystemIndex *next;};
//int RAK_DLL_EXPORT SystemAddressAndIndexComp( const SystemAddress &key, const RemoteSystemIndex &data ); // GCC requires RakPeer::RemoteSystemIndex or it won't compile

class RAK_DLL_EXPORT RakPeer : public RakPeerInterface
{
public:
    RakPeer();

    virtual ~RakPeer();

    // --------------------------------------------------------------------------------------------Major Low Level Functions - Functions needed by most users--------------------------------------------------------------------------------------------
    StartupResult Startup( unsigned short maxConnections, SocketDescriptor *socketDescriptors, unsigned socketDescriptorCount, int threadPriority=-99999 );

    bool InitializeSecurity( const char *publicKey, const char *privateKey, bool bRequireClientKey = false );

    void DisableSecurity( void );

    void AddToSecurityExceptionList(const char *ip);

    void RemoveFromSecurityExceptionList(const char *ip);

    bool IsInSecurityExceptionList(const char *ip);

    void SetMaximumIncomingConnections( unsigned short numberAllowed );

    unsigned short GetMaximumIncomingConnections( void ) const;

    unsigned short NumberOfConnections(void) const;

    void SetIncomingPassword( const char* passwordData, int passwordDataLength );

    void GetIncomingPassword( char* passwordData, int *passwordDataLength  );

    ConnectionAttemptResult Connect( const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, PublicKey *publicKey=0, unsigned connectionSocketIndex=0, unsigned sendConnectionAttemptCount=6, unsigned timeBetweenSendConnectionAttemptsMS=1000, RakNet::TimeMS timeoutTime=0 );

    virtual ConnectionAttemptResult ConnectWithSocket(const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, RakNetSmartPtr<RakNetSocket> socket, PublicKey *publicKey=0, unsigned sendConnectionAttemptCount=6, unsigned timeBetweenSendConnectionAttemptsMS=1000, RakNet::TimeMS timeoutTime=0);

    /* /// \brief Connect to the specified network ID (Platform specific console function)
    //bool Console2LobbyConnect( void *networkServiceId, const char *passwordData, int passwordDataLength );*/  

    void Shutdown( unsigned int blockDuration, unsigned char orderingChannel=0, PacketPriority disconnectionNotificationPriority=LOW_PRIORITY );

    bool IsActive( void ) const;

    bool GetConnectionList( SystemAddress *remoteSystems, unsigned short *numberOfSystems ) const;

    virtual uint32_t GetNextSendReceipt(void);

    virtual uint32_t IncrementNextSendReceipt(void);

    uint32_t Send( const char *data, const int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, uint32_t forceReceiptNumber=0 );

    void SendLoopback( const char *data, const int length );

    uint32_t Send( const RakNet::BitStream * bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, uint32_t forceReceiptNumber=0 );

    uint32_t SendList( const char **data, const int *lengths, const int numParameters, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, uint32_t forceReceiptNumber=0 );

    Packet* Receive( void );

    void DeallocatePacket( Packet *packet );

    unsigned short GetMaximumNumberOfPeers( void ) const;

    // -------------------------------------------------------------------------------------------- Connection Management Functions--------------------------------------------------------------------------------------------
    void CloseConnection( const AddressOrGUID target, bool sendDisconnectionNotification, unsigned char orderingChannel=0, PacketPriority disconnectionNotificationPriority=LOW_PRIORITY );

    void CancelConnectionAttempt( const SystemAddress target );
    ConnectionState GetConnectionState(const AddressOrGUID systemIdentifier);

    int GetIndexFromSystemAddress( const SystemAddress systemAddress ) const;

    SystemAddress GetSystemAddressFromIndex( int index );

    RakNetGUID GetGUIDFromIndex( int index );

    void GetSystemList(DataStructures::List<SystemAddress> &addresses, DataStructures::List<RakNetGUID> &guids) const;

    void AddToBanList( const char *IP, RakNet::TimeMS milliseconds=0 );

    void RemoveFromBanList( const char *IP );

    void ClearBanList( void );

    bool IsBanned( const char *IP );

    void SetLimitIPConnectionFrequency(bool b);
    
    // --------------------------------------------------------------------------------------------Pinging Functions - Functions dealing with the automatic ping mechanism--------------------------------------------------------------------------------------------
    void Ping( const SystemAddress target );

    bool Ping( const char* host, unsigned short remotePort, bool onlyReplyOnAcceptingConnections, unsigned connectionSocketIndex=0 );

    int GetAveragePing( const AddressOrGUID systemIdentifier );

    int GetLastPing( const AddressOrGUID systemIdentifier ) const;

    int GetLowestPing( const AddressOrGUID systemIdentifier ) const;

    void SetOccasionalPing( bool doPing );
    
    // --------------------------------------------------------------------------------------------Static Data Functions - Functions dealing with API defined synchronized memory--------------------------------------------------------------------------------------------
    void SetOfflinePingResponse( const char *data, const unsigned int length );

    void GetOfflinePingResponse( char **data, unsigned int *length );
    
    //--------------------------------------------------------------------------------------------Network Functions - Functions dealing with the network in general--------------------------------------------------------------------------------------------
    SystemAddress GetInternalID( const SystemAddress systemAddress=UNASSIGNED_SYSTEM_ADDRESS, const int index=0 ) const;

    SystemAddress GetExternalID( const SystemAddress target ) const;

    const RakNetGUID GetMyGUID(void);

    SystemAddress GetMyBoundAddress(const int socketIndex=0);

    const RakNetGUID& GetGuidFromSystemAddress( const SystemAddress input ) const;

    SystemAddress GetSystemAddressFromGuid( const RakNetGUID input ) const;

    bool GetClientPublicKeyFromSystemAddress( const SystemAddress input, char *client_public_key ) const;


    void SetTimeoutTime( RakNet::TimeMS timeMS, const SystemAddress target );
    
    RakNet::TimeMS GetTimeoutTime( const SystemAddress target );

    int GetMTUSize( const SystemAddress target ) const;

    unsigned GetNumberOfAddresses( void );

    const char* GetLocalIP( unsigned int index );

    bool IsLocalIP( const char *ip );

    void AllowConnectionResponseIPMigration( bool allow );

    bool AdvertiseSystem( const char *host, unsigned short remotePort, const char *data, int dataLength, unsigned connectionSocketIndex=0 );

    void SetSplitMessageProgressInterval(int interval);

    int GetSplitMessageProgressInterval(void) const;

    void SetUnreliableTimeout(RakNet::TimeMS timeoutMS);

    void SendTTL( const char* host, unsigned short remotePort, int ttl, unsigned connectionSocketIndex=0 );

    // -------------------------------------------------------------------------------------------- Plugin Functions--------------------------------------------------------------------------------------------
    void AttachPlugin( PluginInterface2 *plugin );

    void DetachPlugin( PluginInterface2 *messageHandler );

    // --------------------------------------------------------------------------------------------Miscellaneous Functions--------------------------------------------------------------------------------------------
    void PushBackPacket( Packet *packet, bool pushAtHead );

    void ChangeSystemAddress(RakNetGUID guid, const SystemAddress &systemAddress);

    Packet* AllocatePacket(unsigned dataSize);

    virtual RakNetSmartPtr<RakNetSocket> GetSocket( const SystemAddress target );

    virtual void GetSockets( DataStructures::List<RakNetSmartPtr<RakNetSocket> > &sockets );
    virtual void ReleaseSockets( DataStructures::List<RakNetSmartPtr<RakNetSocket> > &sockets );

    virtual void WriteOutOfBandHeader(RakNet::BitStream *bitStream);

    virtual void SetUserUpdateThread(void (*_userUpdateThreadPtr)(RakPeerInterface *, void *), void *_userUpdateThreadData);

    // --------------------------------------------------------------------------------------------Network Simulator Functions--------------------------------------------------------------------------------------------
    virtual void ApplyNetworkSimulator( float packetloss, unsigned short minExtraPing, unsigned short extraPingVariance);

    virtual void SetPerConnectionOutgoingBandwidthLimit( unsigned maxBitsPerSecond );

    virtual bool IsNetworkSimulatorActive( void );

    // --------------------------------------------------------------------------------------------Statistical Functions - Functions dealing with API performance--------------------------------------------------------------------------------------------

    RakNetStatistics * GetStatistics( const SystemAddress systemAddress, RakNetStatistics *rns=0 );
    bool GetStatistics( const int index, RakNetStatistics *rns );

    virtual unsigned int GetReceiveBufferSize(void);

    // --------------------------------------------------------------------------------------------EVERYTHING AFTER THIS COMMENT IS FOR INTERNAL USE ONLY--------------------------------------------------------------------------------------------

    bool SendOutOfBand(const char *host, unsigned short remotePort, const char *data, BitSize_t dataLength, unsigned connectionSocketIndex=0 );

    // static Packet *AllocPacket(unsigned dataSize, const char *file, unsigned int line);

    struct PingAndClockDifferential
    {
        unsigned short pingTime;
        RakNet::Time clockDifferential;
    };

    struct RemoteSystemStruct
    {
        bool isActive; // Is this structure in use?
        SystemAddress systemAddress;  
        SystemAddress myExternalSystemAddress;  
        SystemAddress theirInternalSystemAddress[MAXIMUM_NUMBER_OF_INTERNAL_IDS];  
        ReliabilityLayer reliabilityLayer;  
        bool weInitiatedTheConnection; 
        PingAndClockDifferential pingAndClockDifferential[ PING_TIMES_ARRAY_SIZE ];  
        RakNet::Time pingAndClockDifferentialWriteIndex;  
        unsigned short lowestPing; 
        RakNet::Time nextPingTime;  
        RakNet::Time lastReliableSend; 
        RakNet::Time connectionTime; 
//      int connectionSocketIndex; // index into connectionSockets to send back on.
        RakNetGUID guid;
        int MTUSize;
        // Reference counted socket to send back on
        RakNetSmartPtr<RakNetSocket> rakNetSocket;
        SystemIndex remoteSystemIndex;

#if LIBCAT_SECURITY==1
        // Cached answer used internally by RakPeer to prevent DoS attacks based on the connexion handshake
        char answer[cat::EasyHandshake::ANSWER_BYTES];

        // If the server has bRequireClientKey = true, then this is set to the validated public key of the connected client
        // Valid after connectMode reaches HANDLING_CONNECTION_REQUEST
        char client_public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
#endif

        enum ConnectMode {NO_ACTION, DISCONNECT_ASAP, DISCONNECT_ASAP_SILENTLY, DISCONNECT_ON_NO_ACK, REQUESTED_CONNECTION, HANDLING_CONNECTION_REQUEST, UNVERIFIED_SENDER, CONNECTED} connectMode;
    };

protected:

    friend RAK_THREAD_DECLARATION(UpdateNetworkLoop);
    friend RAK_THREAD_DECLARATION(RecvFromLoop);
    friend RAK_THREAD_DECLARATION(UDTConnect);

    friend bool ProcessOfflineNetworkPacket( SystemAddress systemAddress, const char *data, const int length, RakPeer *rakPeer, RakNetSmartPtr<RakNetSocket> rakNetSocket, bool *isOfflineMessage, RakNet::TimeUS timeRead );
    friend void ProcessNetworkPacket( const SystemAddress systemAddress, const char *data, const int length, RakPeer *rakPeer, RakNet::TimeUS timeRead );
    friend void ProcessNetworkPacket( const SystemAddress systemAddress, const char *data, const int length, RakPeer *rakPeer, RakNetSmartPtr<RakNetSocket> rakNetSocket, RakNet::TimeUS timeRead );

    int GetIndexFromSystemAddress( const SystemAddress systemAddress, bool calledFromNetworkThread ) const;
    int GetIndexFromGuid( const RakNetGUID guid );

    //void RemoveFromRequestedConnectionsList( const SystemAddress systemAddress );
    // Two versions needed because some buggy compilers strip the last parameter if unused, and crashes
    ConnectionAttemptResult SendConnectionRequest( const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, PublicKey *publicKey, unsigned connectionSocketIndex, unsigned int extraData, unsigned sendConnectionAttemptCount, unsigned timeBetweenSendConnectionAttemptsMS, RakNet::TimeMS timeoutTime, RakNetSmartPtr<RakNetSocket> socket );
    ConnectionAttemptResult SendConnectionRequest( const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, PublicKey *publicKey, unsigned connectionSocketIndex, unsigned int extraData, unsigned sendConnectionAttemptCount, unsigned timeBetweenSendConnectionAttemptsMS, RakNet::TimeMS timeoutTime );
    RemoteSystemStruct *GetRemoteSystemFromSystemAddress( const SystemAddress systemAddress, bool calledFromNetworkThread, bool onlyActive ) const;
    RakPeer::RemoteSystemStruct *GetRemoteSystem( const AddressOrGUID systemIdentifier, bool calledFromNetworkThread, bool onlyActive ) const;
    void ValidateRemoteSystemLookup(void) const;
    RemoteSystemStruct *GetRemoteSystemFromGUID( const RakNetGUID guid, bool onlyActive ) const;
    void ParseConnectionRequestPacket( RakPeer::RemoteSystemStruct *remoteSystem, const SystemAddress &systemAddress, const char *data, int byteSize);
    void OnConnectionRequest( RakPeer::RemoteSystemStruct *remoteSystem, RakNet::Time incomingTimestamp );
    void NotifyAndFlagForShutdown( const SystemAddress systemAddress, bool performImmediate, unsigned char orderingChannel, PacketPriority disconnectionNotificationPriority );
    unsigned short GetNumberOfRemoteInitiatedConnections( void ) const;
    RemoteSystemStruct * AssignSystemAddressToRemoteSystemList( const SystemAddress systemAddress, RemoteSystemStruct::ConnectMode connectionMode, RakNetSmartPtr<RakNetSocket> incomingRakNetSocket, bool *thisIPConnectedRecently, SystemAddress bindingAddress, int incomingMTU, RakNetGUID guid, bool useSecurity );
    void ShiftIncomingTimestamp( unsigned char *data, const SystemAddress &systemAddress ) const;
    RakNet::Time GetBestClockDifferential( const SystemAddress systemAddress ) const;

    bool IsLoopbackAddress(const AddressOrGUID &systemIdentifier, bool matchPort) const;
    SystemAddress GetLoopbackAddress(void) const;

    volatile bool endThreads;
    volatile bool isMainLoopThreadActive;
    
    RakNet::LocklessUint32_t isRecvFromLoopThreadActive;


    bool occasionalPing;  

    unsigned short maximumNumberOfPeers;
    //05/02/06 Just using maximumNumberOfPeers instead
    //unsigned short remoteSystemListSize;
    unsigned short maximumIncomingConnections;
    RakNet::BitStream offlinePingResponse;
    // SystemAddress mySystemAddress[MAXIMUM_NUMBER_OF_INTERNAL_IDS];
    char incomingPassword[256];
    unsigned char incomingPasswordLength;

    RemoteSystemStruct* remoteSystemList;
    RemoteSystemStruct** activeSystemList;
    unsigned int activeSystemListSize;

    // Use a hash, with binaryAddress plus port mod length as the index
    RemoteSystemIndex **remoteSystemLookup;
    unsigned int RemoteSystemLookupHashIndex(const SystemAddress &sa) const;
    void ReferenceRemoteSystem(const SystemAddress &sa, unsigned int remoteSystemListIndex);
    void DereferenceRemoteSystem(const SystemAddress &sa);
    RemoteSystemStruct* GetRemoteSystem(const SystemAddress &sa) const;
    unsigned int GetRemoteSystemIndex(const SystemAddress &sa) const;
    void ClearRemoteSystemLookup(void);
    DataStructures::MemoryPool<RemoteSystemIndex> remoteSystemIndexPool;

    void AddToActiveSystemList(unsigned int remoteSystemListIndex);
    void RemoveFromActiveSystemList(const SystemAddress &sa);

//  unsigned int LookupIndexUsingHashIndex(const SystemAddress &sa) const;
//  unsigned int RemoteSystemListIndexUsingHashIndex(const SystemAddress &sa) const;
//  unsigned int FirstFreeRemoteSystemLookupIndex(const SystemAddress &sa) const;
    
    enum
    {
        // Only put these mutexes in user thread functions!
        requestedConnectionList_Mutex,
        offlinePingResponse_Mutex,
        NUMBER_OF_RAKPEER_MUTEXES
    };
    SimpleMutex rakPeerMutexes[ NUMBER_OF_RAKPEER_MUTEXES ];

    bool updateCycleIsRunning;

    //DataStructures::Queue<RequestedConnectionStruct*> requestedConnectionsList;

    unsigned int bytesSentPerSecond, bytesReceivedPerSecond;
    // bool isSocketLayerBlocking;
    // bool continualPing,isRecvfromThreadActive,isMainLoopThreadActive, endThreads, isSocketLayerBlocking;
    unsigned int validationInteger;
    SimpleMutex incomingQueueMutex, banListMutex; //,synchronizedMemoryQueueMutex, automaticVariableSynchronizationMutex;
    //DataStructures::Queue<Packet *> incomingpacketSingleProducerConsumer; //, synchronizedMemorypacketSingleProducerConsumer;
    // BitStream enumerationData;

    struct BanStruct
    {
        char *IP;
        RakNet::TimeMS timeout; // 0 for none
    };

    struct RequestedConnectionStruct
    {
        SystemAddress systemAddress;
        RakNet::Time nextRequestTime;
        unsigned char requestsMade;
        char *data;
        unsigned short dataLength;
        char outgoingPassword[256];
        unsigned char outgoingPasswordLength;
        unsigned socketIndex;
        unsigned int extraData;
        unsigned sendConnectionAttemptCount;
        unsigned timeBetweenSendConnectionAttemptsMS;
        RakNet::TimeMS timeoutTime;
        PublicKeyMode publicKeyMode;
        RakNetSmartPtr<RakNetSocket> socket;
        enum {CONNECT=1, /*PING=2, PING_OPEN_CONNECTIONS=4,*/ /*ADVERTISE_SYSTEM=2*/} actionToTake;

#if LIBCAT_SECURITY==1
        char handshakeChallenge[cat::EasyHandshake::CHALLENGE_BYTES];
        cat::ClientEasyHandshake *client_handshake;
        char remote_public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
//      char remote_challenge[cat::EasyHandshake::CHALLENGE_BYTES];
    //  char random[16];
#endif
    };
#if LIBCAT_SECURITY==1
    bool GenerateConnectionRequestChallenge(RequestedConnectionStruct *rcs,PublicKey *publicKey);
#endif

    //DataStructures::List<DataStructures::List<MemoryBlock>* > automaticVariableSynchronizationList;
    DataStructures::List<BanStruct*> banList;
    DataStructures::List<PluginInterface2*> messageHandlerList;

    DataStructures::Queue<RequestedConnectionStruct*> requestedConnectionQueue;
    SimpleMutex requestedConnectionQueueMutex;

    bool RunUpdateCycle( RakNet::TimeUS timeNS, RakNet::Time timeMS );
    // void RunMutexedUpdateCycle(void);

    struct BufferedCommandStruct
    {
        BitSize_t numberOfBitsToSend;
        PacketPriority priority;
        PacketReliability reliability;
        char orderingChannel;
        AddressOrGUID systemIdentifier;
        bool broadcast;
        RemoteSystemStruct::ConnectMode connectionMode;
        NetworkID networkID;
        bool blockingCommand; // Only used for RPC
        char *data;
        bool haveRakNetCloseSocket;
        unsigned connectionSocketIndex;
        unsigned short remotePortRakNetWasStartedOn_PS3;
        unsigned int extraSocketOptions;
        SOCKET socket;
        unsigned short port;
        uint32_t receipt;
        enum {BCS_SEND, BCS_CLOSE_CONNECTION, BCS_GET_SOCKET, BCS_CHANGE_SYSTEM_ADDRESS,/* BCS_USE_USER_SOCKET, BCS_REBIND_SOCKET_ADDRESS, BCS_RPC, BCS_RPC_SHIFT,*/ BCS_DO_NOTHING} command;
    };

    // Single producer single consumer queue using a linked list
    //BufferedCommandStruct* bufferedCommandReadIndex, bufferedCommandWriteIndex;

    DataStructures::ThreadsafeAllocatingQueue<BufferedCommandStruct> bufferedCommands;


    // Constructor not called!
    struct RecvFromStruct
    {



        char data[MAXIMUM_MTU_SIZE];

        int bytesRead;
        SystemAddress systemAddress;
        RakNet::TimeUS timeRead;
        SOCKET s;
        unsigned short remotePortRakNetWasStartedOn_PS3;
        unsigned int extraSocketOptions;
    };


    DataStructures::ThreadsafeAllocatingQueue<RecvFromStruct> bufferedPackets;


    struct SocketQueryOutput
    {
        SocketQueryOutput() {}
        ~SocketQueryOutput() {}
        DataStructures::List<RakNetSmartPtr<RakNetSocket> > sockets;
    };

    DataStructures::ThreadsafeAllocatingQueue<SocketQueryOutput> socketQueryOutput;


    bool AllowIncomingConnections(void) const;

    void PingInternal( const SystemAddress target, bool performImmediate, PacketReliability reliability );
    // This stores the user send calls to be handled by the update thread.  This way we don't have thread contention over systemAddresss
    void CloseConnectionInternal( const AddressOrGUID& systemIdentifier, bool sendDisconnectionNotification, bool performImmediate, unsigned char orderingChannel, PacketPriority disconnectionNotificationPriority );
    void SendBuffered( const char *data, BitSize_t numberOfBitsToSend, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, RemoteSystemStruct::ConnectMode connectionMode, uint32_t receipt );
    void SendBufferedList( const char **data, const int *lengths, const int numParameters, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, RemoteSystemStruct::ConnectMode connectionMode, uint32_t receipt );
    bool SendImmediate( char *data, BitSize_t numberOfBitsToSend, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, bool useCallerDataAllocation, RakNet::TimeUS currentTime, uint32_t receipt );
    //bool HandleBufferedRPC(BufferedCommandStruct *bcs, RakNet::TimeMS time);
    void ClearBufferedCommands(void);
    void ClearBufferedPackets(void);
    void ClearSocketQueryOutput(void);
    void ClearRequestedConnectionList(void);
    void AddPacketToProducer(RakNet::Packet *p);
    unsigned int GenerateSeedFromGuid(void);
    SimpleMutex securityExceptionMutex;

    //DataStructures::AVLBalancedBinarySearchTree<RPCNode> rpcTree;
    int defaultMTUSize;
    bool trackFrequencyTable;

    // Smart pointer so I can return the object to the user
    DataStructures::List<RakNetSmartPtr<RakNetSocket> > socketList;
    void DerefAllSockets(void);
    unsigned int GetRakNetSocketFromUserConnectionSocketIndex(unsigned int userIndex) const;
    // Used for RPC replies
    RakNet::BitStream *replyFromTargetBS;
    SystemAddress replyFromTargetPlayer;
    bool replyFromTargetBroadcast;

    RakNet::TimeMS defaultTimeoutTime;

    // Generate and store a unique GUID
    void GenerateGUID(void);
    unsigned int GetSystemIndexFromGuid( const RakNetGUID input ) const;
    RakNetGUID myGuid;

    unsigned maxOutgoingBPS;

    // Nobody would use the internet simulator in a final build.
#ifdef _DEBUG
    double _packetloss;
    unsigned short _minExtraPing, _extraPingVariance;
#endif
    
    //unsigned int lastUserUpdateCycle;
    bool allowConnectionResponseIPMigration;

    SystemAddress firstExternalID;
    int splitMessageProgressInterval;
    RakNet::TimeMS unreliableTimeout;

    // Systems in this list will not go through the secure connection process, even when secure connections are turned on. Wildcards are accepted.
    DataStructures::List<RakNet::RakString> securityExceptionList;

    SystemAddress ipList[ MAXIMUM_NUMBER_OF_INTERNAL_IDS ];

    bool allowInternalRouting;

    void (*userUpdateThreadPtr)(RakPeerInterface *, void *);
    void *userUpdateThreadData;


    SignaledEvent quitAndDataEvents;
    bool limitConnectionFrequencyFromTheSameIP;

    SimpleMutex packetAllocationPoolMutex;
    DataStructures::MemoryPool<Packet> packetAllocationPool;

    SimpleMutex packetReturnMutex;
    DataStructures::Queue<Packet*> packetReturnQueue;
    Packet *AllocPacket(unsigned dataSize, const char *file, unsigned int line);
    Packet *AllocPacket(unsigned dataSize, unsigned char *data, const char *file, unsigned int line);

    SimpleMutex sendReceiptSerialMutex;
    uint32_t sendReceiptSerial;
    void ResetSendReceipt(void);
    void OnConnectedPong(RakNet::Time sendPingTime, RakNet::Time sendPongTime, RemoteSystemStruct *remoteSystem);

#if LIBCAT_SECURITY==1
    // Encryption and security
    bool _using_security, _require_client_public_key;
    char my_public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
    cat::ServerEasyHandshake *_server_handshake;
    cat::CookieJar *_cookie_jar;
    bool InitializeClientSecurity(RequestedConnectionStruct *rcs, const char *public_key);
#endif





} 
// #if defined(SN_TARGET_PSP2)
// __attribute__((aligned(8)))
// #endif
;

} // namespace RakNet

#endif