peerinterface.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.
 */




#ifndef __RAK_PEER_INTERFACE_H
#define __RAK_PEER_INTERFACE_H

#include "PacketPriority.h"
#include "types.h"
#include "memoryoverride.h"
#include "Export.h"
#include "DS_List.h"
#include "smartptr.h"
#include "socket2.h"

namespace SLNet
{
// Forward declarations
class BitStream;
class PluginInterface2;
struct RPCMap;
struct RakNetStatistics;
struct RakNetBandwidth;
class RouterInterface;
class NetworkIDManager;

class RAK_DLL_EXPORT RakPeerInterface
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(RakPeerInterface)

    
    virtual ~RakPeerInterface() {}

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

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

    virtual void DisableSecurity( void )=0;

    virtual void AddToSecurityExceptionList(const char *ip)=0;

    virtual void RemoveFromSecurityExceptionList(const char *ip)=0;

    virtual bool IsInSecurityExceptionList(const char *ip)=0;

    virtual void SetMaximumIncomingConnections( unsigned short numberAllowed )=0;

    virtual unsigned int GetMaximumIncomingConnections( void ) const=0;

    virtual unsigned short NumberOfConnections(void) const=0;

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

    virtual void GetIncomingPassword( char* passwordData, int *passwordDataLength  )=0;

    virtual ConnectionAttemptResult Connect( const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, PublicKey *publicKey=0, unsigned connectionSocketIndex=0, unsigned sendConnectionAttemptCount=12, unsigned timeBetweenSendConnectionAttemptsMS=500, SLNet::TimeMS timeoutTime=0 )=0;

    virtual ConnectionAttemptResult ConnectWithSocket(const char* host, unsigned short remotePort, const char *passwordData, int passwordDataLength, RakNetSocket2* socket, PublicKey *publicKey=0, unsigned sendConnectionAttemptCount=12, unsigned timeBetweenSendConnectionAttemptsMS=500, SLNet::TimeMS timeoutTime=0)=0;

    //virtual bool Console2LobbyConnect( void *networkServiceId, const char *passwordData, int passwordDataLength )=0;

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

    virtual bool IsActive( void ) const=0;

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

    virtual uint32_t GetNextSendReceipt(void)=0;

    virtual uint32_t IncrementNextSendReceipt(void)=0;

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

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

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

    virtual 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 )=0;

    virtual Packet* Receive( void )=0;

    virtual void DeallocatePacket( Packet *packet )=0;

    virtual unsigned int GetMaximumNumberOfPeers( void ) const=0;

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

    virtual ConnectionState GetConnectionState(const AddressOrGUID systemIdentifier)=0;

    virtual void CancelConnectionAttempt( const SystemAddress target )=0;

    virtual int GetIndexFromSystemAddress( const SystemAddress systemAddress ) const=0;

    virtual SystemAddress GetSystemAddressFromIndex( unsigned int index )=0;

    virtual RakNetGUID GetGUIDFromIndex( unsigned int index )=0;

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

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

    virtual void RemoveFromBanList( const char *IP )=0;

    virtual void ClearBanList( void )=0;

    virtual bool IsBanned( const char *IP )=0;

    virtual void SetLimitIPConnectionFrequency(bool b)=0;

    // --------------------------------------------------------------------------------------------Pinging Functions - Functions dealing with the automatic ping mechanism--------------------------------------------------------------------------------------------
    virtual void Ping( const SystemAddress target )=0;

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

    virtual int GetAveragePing( const AddressOrGUID systemIdentifier )=0;

    virtual int GetLastPing( const AddressOrGUID systemIdentifier ) const=0;

    virtual int GetLowestPing( const AddressOrGUID systemIdentifier ) const=0;

    virtual void SetOccasionalPing( bool doPing )=0;

    virtual SLNet::Time GetClockDifferential( const AddressOrGUID systemIdentifier )=0;

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

    virtual void GetOfflinePingResponse( char **data, unsigned int *length )=0;

    //--------------------------------------------------------------------------------------------Network Functions - Functions dealing with the network in general--------------------------------------------------------------------------------------------
    virtual SystemAddress GetInternalID( const SystemAddress systemAddress=UNASSIGNED_SYSTEM_ADDRESS, const int index=0 ) const=0;

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

    virtual SystemAddress GetExternalID( const SystemAddress target ) const=0;

    virtual const RakNetGUID GetMyGUID(void) const=0;

    virtual SystemAddress GetMyBoundAddress(const int socketIndex=0)=0;

    static uint64_t Get64BitUniqueRandomNumber(void);

    virtual const RakNetGUID& GetGuidFromSystemAddress( const SystemAddress input ) const=0;

    virtual SystemAddress GetSystemAddressFromGuid( const RakNetGUID input ) const=0;

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

    virtual void SetTimeoutTime(SLNet::TimeMS timeMS, const SystemAddress target )=0;

    virtual SLNet::TimeMS GetTimeoutTime( const SystemAddress target )=0;

    virtual int GetMTUSize( const SystemAddress target ) const=0;

    virtual unsigned GetNumberOfAddresses( void )=0;

    virtual const char* GetLocalIP( unsigned int index )=0;

    virtual bool IsLocalIP( const char *ip )=0;

    virtual void AllowConnectionResponseIPMigration( bool allow )=0;

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

    virtual void SetSplitMessageProgressInterval(int interval)=0;

    virtual int GetSplitMessageProgressInterval(void) const=0;

    virtual void SetUnreliableTimeout(SLNet::TimeMS timeoutMS)=0;

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

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

    virtual void DetachPlugin( PluginInterface2 *messageHandler )=0;

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

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

    virtual Packet* AllocatePacket(unsigned dataSize)=0;

    virtual RakNetSocket2* GetSocket( const SystemAddress target )=0;

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

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

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

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

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

    virtual void SetPerConnectionOutgoingBandwidthLimit( unsigned maxBitsPerSecond )=0;

    virtual bool IsNetworkSimulatorActive( void )=0;

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

    virtual RakNetStatistics * GetStatistics( const SystemAddress systemAddress, RakNetStatistics *rns=0 )=0;
    virtual bool GetStatistics( const unsigned int index, RakNetStatistics *rns )=0;
    virtual void GetStatisticsList(DataStructures::List<SystemAddress> &addresses, DataStructures::List<RakNetGUID> &guids, DataStructures::List<RakNetStatistics> &statistics)=0;

    virtual unsigned int GetReceiveBufferSize(void)=0;

    // --------------------------------------------------------------------------------------------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
    // );
    virtual bool RunUpdateCycle( BitStream &updateBitStream )=0;

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

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

} // namespace SLNet

#endif