peer.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */



// 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 "peerinterface.h"
#include "BitStream.h"
#include "SingleProducerConsumer.h"
#include "SimpleMutex.h"
#include "DS_OrderedList.h"
#include "Export.h"
#include "string.h"
#include "thread.h"
//#include "socket.h"
#include "smartptr.h"
#include "DS_ThreadsafeAllocatingQueue.h"
#include "SignaledEvent.h"
#include "NativeFeatureIncludes.h"
#include "SecureHandshake.h"
#include "LocklessTypes.h"
#include "DS_Queue.h"

namespace SLNet {
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 RNS2EventHandler
{
public:
    RakPeer();

    virtual ~RakPeer();

    // --------------------------------------------------------------------------------------------Major Low Level Functions - Functions needed by most users--------------------------------------------------------------------------------------------
    StartupResult Startup( unsigned int 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 int 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, SLNet::TimeMS timeoutTime=0 );

    virtual ConnectionAttemptResult ConnectWithSocket(const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, RakNetSocket2* socket, PublicKey *publicKey=0, unsigned sendConnectionAttemptCount=6, unsigned timeBetweenSendConnectionAttemptsMS=1000, SLNet::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 SLNet::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 int 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( unsigned int index );

    RakNetGUID GetGUIDFromIndex( unsigned int index );

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

    void AddToBanList( const char *IP, SLNet::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 );

    SLNet::Time GetClockDifferential( const AddressOrGUID systemIdentifier );
    
    // --------------------------------------------------------------------------------------------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;

    void SetInternalID(SystemAddress systemAddress, int index=0);

    SystemAddress GetExternalID( const SystemAddress target ) const;

    const RakNetGUID GetMyGUID(void) const;

    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(SLNet::TimeMS timeMS, const SystemAddress target );
    
    SLNet::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(SLNet::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 RakNetSocket2* GetSocket( const SystemAddress target );

    virtual void GetSockets( DataStructures::List<RakNetSocket2* > &sockets );
    virtual void ReleaseSockets( DataStructures::List<RakNetSocket2* > &sockets );

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

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

    virtual void SetIncomingDatagramEventHandler( bool (*_incomingDatagramEventHandler)(RNS2RecvStruct *) );

    // --------------------------------------------------------------------------------------------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 unsigned int index, RakNetStatistics *rns );
    virtual void GetStatisticsList(DataStructures::List<SystemAddress> &addresses, DataStructures::List<RakNetGUID> &guids, DataStructures::List<RakNetStatistics> &statistics);

    virtual unsigned int GetReceiveBufferSize(void);

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


    // Call manually if RAKPEER_USER_THREADED==1 at least every 30 milliseconds.
    // updateBitStream should be:
    //  BitStream updateBitStream( MAXIMUM_MTU_SIZE
    // #if LIBCAT_SECURITY==1
    //  + cat::AuthenticatedEncryption::OVERHEAD_BYTES
    // #endif
    // );
    bool RunUpdateCycle( BitStream &updateBitStream );

    // Call manually if RAKPEER_USER_THREADED==1 at least every 30 milliseconds.
    // Call in a loop until returns false if the socket is non-blocking
    // remotePortRakNetWasStartedOn_PS3 and extraSocketOptions are from SocketDescriptor when the socket was created
    // bool RunRecvFromOnce( RakNetSocket *s );

    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;
        SLNet::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 ];  
        SLNet::Time pingAndClockDifferentialWriteIndex;  
        unsigned short lowestPing; 
        SLNet::Time nextPingTime;  
        SLNet::Time lastReliableSend; 
        SLNet::Time connectionTime; 
//      int connectionSocketIndex; // index into connectionSockets to send back on.
        RakNetGUID guid;
        int MTUSize;
        // Reference counted socket to send back on
        RakNetSocket2* 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;
    };

    // DS_APR
    //void ProcessChromePacket(RakNetSocket2 *s, const char *buffer, int dataSize, const SystemAddress& recvFromAddress, SLNet::TimeUS timeRead);
    // /DS_APR
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, RakNetSocket2* rakNetSocket, bool *isOfflineMessage, SLNet::TimeUS timeRead );
    friend void ProcessNetworkPacket( const SystemAddress systemAddress, const char *data, const int length, RakPeer *rakPeer, SLNet::TimeUS timeRead, BitStream &updateBitStream );
    friend void ProcessNetworkPacket( const SystemAddress systemAddress, const char *data, const int length, RakPeer *rakPeer, RakNetSocket2* rakNetSocket, SLNet::TimeUS timeRead, BitStream &updateBitStream );

    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, SLNet::TimeMS timeoutTime, RakNetSocket2* 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, SLNet::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, SLNet::Time incomingTimestamp );
    void NotifyAndFlagForShutdown( const SystemAddress systemAddress, bool performImmediate, unsigned char orderingChannel, PacketPriority disconnectionNotificationPriority );
    unsigned int GetNumberOfRemoteInitiatedConnections( void ) const;
    RemoteSystemStruct * AssignSystemAddressToRemoteSystemList( const SystemAddress systemAddress, RemoteSystemStruct::ConnectMode connectionMode, RakNetSocket2* incomingRakNetSocket, bool *thisIPConnectedRecently, SystemAddress bindingAddress, int incomingMTU, RakNetGUID guid, bool useSecurity );
    void ShiftIncomingTimestamp( unsigned char *data, const SystemAddress &systemAddress ) const;
    SLNet::Time GetBestClockDifferential( const SystemAddress systemAddress ) const;

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

    volatile bool endThreads;
    volatile bool isMainLoopThreadActive;
    
    // SLNet::LocklessUint32_t isRecvFromLoopThreadActive;


    bool occasionalPing;  

    unsigned int maximumNumberOfPeers;
    //05/02/06 Just using maximumNumberOfPeers instead
    //unsigned short remoteSystemListSize;
    unsigned int maximumIncomingConnections;
    SLNet::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;
        SLNet::TimeMS timeout; // 0 for none
    };

    struct RequestedConnectionStruct
    {
        SystemAddress systemAddress;
        SLNet::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;
        SLNet::TimeMS timeoutTime;
        PublicKeyMode publicKeyMode;
        RakNetSocket2* 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;
    // Threadsafe, and not thread safe
    DataStructures::List<PluginInterface2*> pluginListTS, pluginListNTS;

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

    // 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;
        RakNetSocket2* 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;


    // DataStructures::ThreadsafeAllocatingQueue<RNS2RecvStruct> bufferedPackets;

    DataStructures::Queue<RNS2RecvStruct*> bufferedPacketsFreePool;
    SLNet::SimpleMutex bufferedPacketsFreePoolMutex;
    DataStructures::Queue<RNS2RecvStruct*> bufferedPacketsQueue;
    SLNet::SimpleMutex bufferedPacketsQueueMutex;

    virtual void DeallocRNS2RecvStruct(RNS2RecvStruct *s, const char *file, unsigned int line);
    virtual RNS2RecvStruct *AllocRNS2RecvStruct(const char *file, unsigned int line);
    void SetupBufferedPackets(void);
    void PushBufferedPacket(RNS2RecvStruct * p);
    RNS2RecvStruct *PopBufferedPacket(void);

    struct SocketQueryOutput
    {
        SocketQueryOutput() {}
        ~SocketQueryOutput() {}
        DataStructures::List<RakNetSocket2* > 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, SLNet::TimeUS currentTime, uint32_t receipt );
    //bool HandleBufferedRPC(BufferedCommandStruct *bcs, SLNet::TimeMS time);
    void ClearBufferedCommands(void);
    void ClearBufferedPackets(void);
    void ClearSocketQueryOutput(void);
    void ClearRequestedConnectionList(void);
    void AddPacketToProducer(SLNet::Packet *p);
    unsigned int GenerateSeedFromGuid(void);
    SLNet::Time GetClockDifferentialInt(RemoteSystemStruct *remoteSystem) const;
    SimpleMutex securityExceptionMutex;

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

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

    SLNet::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;
    SLNet::TimeMS unreliableTimeout;

    bool (*incomingDatagramEventHandler)(RNS2RecvStruct *);

    // Systems in this list will not go through the secure connection process, even when secure connections are turned on. Wildcards are accepted.
    DataStructures::List<SLNet::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(SLNet::Time sendPingTime, SLNet::Time sendPongTime, RemoteSystemStruct *remoteSystem);
    void CallPluginCallbacks(DataStructures::List<PluginInterface2*> &pluginList, Packet *packet);

#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






    virtual void OnRNS2Recv(RNS2RecvStruct *recvStruct);
    void FillIPList(void);
} 
// #if defined(SN_TARGET_PSP2)
// __attribute__((aligned(8)))
// #endif
;

} // namespace SLNet

#endif