#include <RakPeer.h>
Public Member Functions | |
RakPeer () | |
Constructor. | |
virtual | ~RakPeer () |
Destructor. | |
bool | Startup (unsigned short maxConnections, int _threadSleepTimer, SocketDescriptor *socketDescriptors, unsigned socketDescriptorCount) |
Starts the network threads, opens the listen port. You must call this before calling Connect(). Multiple calls while already active are ignored. To call this function again with different settings, you must first call Shutdown(). | |
void | InitializeSecurity (const char *pubKeyE, const char *pubKeyN, const char *privKeyP, const char *privKeyQ) |
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) |
bool | Connect (const char *host, unsigned short remotePort, const char *passwordData, int passwordDataLength, unsigned connectionSocketIndex=0) |
Connect to the specified host (ip or domain name) and server port. Calling Connect and not calling SetMaximumIncomingConnections acts as a dedicated client. Calling both acts as a true peer. This is a non-blocking connection. You know the connection is successful when IsConnected() returns true or Receive() gets a message with the type identifier ID_CONNECTION_ACCEPTED. If the connection is not successful, such as a rejected connection or no response then neither of these things will happen. | |
void | Shutdown (unsigned int blockDuration, unsigned char orderingChannel=0) |
Connect to the specified network ID (Platform specific console function) Does built-in NAT traversal. | |
bool | IsActive (void) const |
bool | GetConnectionList (SystemAddress *remoteSystems, unsigned short *numberOfSystems) const |
bool | Send (const char *data, const int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast) |
void | SendLoopback (const char *data, const int length) |
bool | Send (const RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast) |
bool | SendList (char **data, const int *lengths, const int numParameters, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast) |
Packet * | Receive (void) |
void | DeallocatePacket (Packet *packet) |
unsigned short | GetMaximumNumberOfPeers (void) const |
Return the total number of connections we are allowed. | |
void | RegisterAsRemoteProcedureCall (const char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms)) |
void | RegisterClassMemberRPC (const char *uniqueID, void *functionPointer) |
void | UnregisterAsRemoteProcedureCall (const char *uniqueID) |
void | SetNetworkIDManager (NetworkIDManager *manager) |
NetworkIDManager * | GetNetworkIDManager (void) const |
bool | RPC (const char *uniqueID, const char *data, BitSize_t bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, RakNetTime *includedTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget) |
bool | RPC (const char *uniqueID, const RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, RakNetTime *includedTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget) |
void | CloseConnection (const SystemAddress target, bool sendDisconnectionNotification, unsigned char orderingChannel=0) |
bool | IsConnected (const SystemAddress systemAddress, bool includeInProgress=false, bool includeDisconnecting=false) |
int | GetIndexFromSystemAddress (const SystemAddress systemAddress) |
SystemAddress | GetSystemAddressFromIndex (int index) |
void | AddToBanList (const char *IP, RakNetTime milliseconds=0) |
void | RemoveFromBanList (const char *IP) |
void | ClearBanList (void) |
Allows all previously banned IPs to connect. | |
bool | IsBanned (const char *IP) |
void | Ping (const SystemAddress target) |
bool | Ping (const char *host, unsigned short remotePort, bool onlyReplyOnAcceptingConnections, unsigned connectionSocketIndex=0) |
int | GetAveragePing (const SystemAddress systemAddress) |
int | GetLastPing (const SystemAddress systemAddress) const |
int | GetLowestPing (const SystemAddress systemAddress) const |
void | SetOccasionalPing (bool doPing) |
void | SetOfflinePingResponse (const char *data, const unsigned int length) |
void | GetOfflinePingResponse (char **data, unsigned int *length) |
SystemAddress | GetInternalID (const SystemAddress systemAddress=UNASSIGNED_SYSTEM_ADDRESS, const int index=0) const |
SystemAddress | GetExternalID (const SystemAddress target) const |
RakNetGUID | GetGuidFromSystemAddress (const SystemAddress input) const |
SystemAddress | GetSystemAddressFromGuid (const RakNetGUID input) const |
void | SetTimeoutTime (RakNetTime timeMS, const SystemAddress target) |
bool | SetMTUSize (int size, const SystemAddress target) |
int | GetMTUSize (const SystemAddress target) const |
unsigned | GetNumberOfAddresses (void) |
Returns the number of IP addresses this system has internally. Get the actual addresses from GetLocalIP(). | |
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 (RakNetTime timeoutMS) |
void | SendTTL (const char *host, unsigned short remotePort, int ttl, unsigned connectionSocketIndex=0) |
void | SetCompileFrequencyTable (bool doCompile) |
bool | GetOutgoingFrequencyTable (unsigned int outputFrequencyTable[256]) |
bool | GenerateCompressionLayer (unsigned int inputFrequencyTable[256], bool inputLayer) |
bool | DeleteCompressionLayer (bool inputLayer) |
float | GetCompressionRatio (void) const |
float | GetDecompressionRatio (void) const |
void | AttachPlugin (PluginInterface *plugin) |
void | DetachPlugin (PluginInterface *messageHandler) |
void | PushBackPacket (Packet *packet, bool pushAtHead) |
void | SetRouterInterface (RouterInterface *routerInterface) |
void | RemoveRouterInterface (RouterInterface *routerInterface) |
Packet * | AllocatePacket (unsigned dataSize) |
void | ApplyNetworkSimulator (double maxSendBPS, unsigned short minExtraPing, unsigned short extraPingVariance) |
void | SetPerConnectionOutgoingBandwidthLimit (unsigned maxBitsPerSecond) |
bool | IsNetworkSimulatorActive (void) |
void | UseUserSocket (int socket, bool haveRakNetCloseSocket, unsigned connectionSocketIndex) |
void | RebindSocketAddress (unsigned connectionSocketIndex, SocketDescriptor &sd) |
RakNetStatistics *const | GetStatistics (const SystemAddress systemAddress, RakNetStatistics *rns=0) |
Protected Member Functions | |
RemoteSystemStruct * | GetRemoteSystemFromSystemAddress (const SystemAddress systemAddress, bool calledFromNetworkThread, bool onlyActive) const |
void | ParseConnectionRequestPacket (RakPeer::RemoteSystemStruct *remoteSystem, SystemAddress systemAddress, const char *data, int byteSize) |
Parse out a connection request packet. | |
void | OnConnectionRequest (RakPeer::RemoteSystemStruct *remoteSystem, unsigned char *AESKey, bool setAESKey) |
When we get a connection request from an ip / port, accept it unless full. | |
void | NotifyAndFlagForShutdown (const SystemAddress systemAddress, bool performImmediate, unsigned char orderingChannel) |
Send a reliable disconnect packet to this player and disconnect them when it is delivered. | |
unsigned short | GetNumberOfRemoteInitiatedConnections (void) const |
Returns how many remote systems initiated a connection to us. | |
RemoteSystemStruct * | AssignSystemAddressToRemoteSystemList (const SystemAddress systemAddress, RemoteSystemStruct::ConnectMode connectionMode, unsigned connectionSocketIndex) |
Get a free remote system from the list and assign our systemAddress to it. Should only be called from the update thread - not the user thread. | |
void | ShiftIncomingTimestamp (unsigned char *data, SystemAddress systemAddress) const |
An incoming packet has a timestamp, so adjust it to be relative to this system. | |
RakNetTime | GetBestClockDifferential (const SystemAddress systemAddress) const |
Get the most probably accurate clock differential for a certain player. | |
bool | HandleRPCPacket (const char *data, int length, SystemAddress systemAddress) |
void | HandleRPCReplyPacket (const char *data, int length, SystemAddress systemAddress) |
Protected Attributes | |
volatile bool | endThreads |
Set this to true to terminate the Peer thread execution. | |
volatile bool | isMainLoopThreadActive |
true if the peer thread is active. | |
*unsigned short | maximumNumberOfPeers |
Store the maximum number of peers allowed to connect. | |
unsigned short | maximumIncomingConnections |
Store the maximum number of peers able to connect, including reserved connection slots for pings, etc. | |
SystemAddress | mySystemAddress [MAXIMUM_NUMBER_OF_INTERNAL_IDS] |
Local Player ID. | |
RemoteSystemStruct * | remoteSystemList |
bool | updateCycleIsRunning |
RunUpdateCycle is not thread safe but we don't need to mutex calls. Just skip calls if it is running already. | |
unsigned int | bytesSentPerSecond |
The list of people we have tried to connect to recently. | |
unsigned int | frequencyTable [256] |
Compression stuff. | |
RSACrypt | rsacrypt |
Encryption and security. | |
bool | allowConnectionResponseIPMigration |
How long it has been since things were updated by a call to receiveUpdate thread uses this to determine how long to sleep for. |
The primary interface for RakNet, RakPeer contains all major functions for the library. See the individual functions for what the class can do.
void RakPeer::AddToBanList | ( | const char * | IP, | |
RakNetTime | milliseconds = 0 | |||
) | [virtual] |
Bans an IP from connecting. Banned IPs persist between connections but are not saved on shutdown nor loaded on startup. param[in] IP Dotted IP address. Can use * as a wildcard, such as 128.0.0.* will ban all IP addresses starting with 128.0.0
[in] | milliseconds | how many ms for a temporary ban. Use 0 for a permanent ban |
Implements RakPeerInterface.
void RakPeer::AddToSecurityExceptionList | ( | const char * | ip | ) | [virtual] |
If secure connections are on, do not use secure connections for a specific IP address. This is useful if you have a fixed-address internal server behind a LAN.
[in] | ip | IP address to add. * wildcards are supported. |
Implements RakPeerInterface.
bool RakPeer::AdvertiseSystem | ( | const char * | host, | |
unsigned short | remotePort, | |||
const char * | data, | |||
int | dataLength, | |||
unsigned | connectionSocketIndex = 0 | |||
) | [virtual] |
Sends a one byte message ID_ADVERTISE_SYSTEM to the remote unconnected system. This will tell the remote system our external IP outside the LAN along with some user data.
[in] | host | Either a dotted IP address or a domain name |
[in] | remotePort | Which port to connect to on the remote machine. |
[in] | data | Optional data to append to the packet. |
[in] | dataLength | length of data in bytes. Use 0 if no data. |
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
Implements RakPeerInterface.
Packet * RakPeer::AllocatePacket | ( | unsigned | dataSize | ) | [virtual] |
[in] | dataSize | How many bytes to allocate for the buffer |
Implements RakPeerInterface.
void RakPeer::AllowConnectionResponseIPMigration | ( | bool | allow | ) | [virtual] |
Allow or disallow connection responses from any IP. Normally this should be false, but may be necessary when connecting to servers with multiple IP addresses.
[in] | allow | - True to allow this behavior, false to not allow. Defaults to false. Value persists between connections |
Implements RakPeerInterface.
void RakPeer::ApplyNetworkSimulator | ( | double | maxSendBPS, | |
unsigned short | minExtraPing, | |||
unsigned short | extraPingVariance | |||
) | [virtual] |
Adds simulated ping and packet loss to the outgoing data flow. To simulate bi-directional ping and packet loss, you should call this on both the sender and the recipient, with half the total ping and maxSendBPS value on each. You can exclude network simulator code with the _RELEASE define to decrease code size Use http://www.jenkinssoftware.com/raknet/forum/index.php?topic=1671.0 instead.
[in] | maxSendBPS | Maximum bits per second to send. Packetloss grows linearly. 0 to disable. (CURRENTLY BROKEN - ALWAYS DISABLED) |
[in] | minExtraPing | The minimum time to delay sends. |
[in] | extraPingVariance | The additional random time to delay sends. |
Implements RakPeerInterface.
RakPeer::RemoteSystemStruct * RakPeer::AssignSystemAddressToRemoteSystemList | ( | const SystemAddress | systemAddress, | |
RemoteSystemStruct::ConnectMode | connectionMode, | |||
unsigned | connectionSocketIndex | |||
) | [protected] |
Get a free remote system from the list and assign our systemAddress to it. Should only be called from the update thread - not the user thread.
Add this player to the lookup tree
void RakPeer::AttachPlugin | ( | PluginInterface * | plugin | ) | [virtual] |
Attatches a Plugin interface to run code automatically on message receipt in the Receive call
[in] | messageHandler | Pointer to a plugin to attach |
Implements RakPeerInterface.
void RakPeer::CloseConnection | ( | const SystemAddress | target, | |
bool | sendDisconnectionNotification, | |||
unsigned char | orderingChannel = 0 | |||
) | [virtual] |
Close the connection to another host (if we initiated the connection it will disconnect, if they did it will kick them out).
[in] | target | Which system to close the connection to. |
[in] | sendDisconnectionNotification | True to send ID_DISCONNECTION_NOTIFICATION to the recipient. False to close it silently. |
[in] | channel | Which ordering channel to send the disconnection notification on, if any |
Implements RakPeerInterface.
bool RakPeer::Connect | ( | const char * | host, | |
unsigned short | remotePort, | |||
const char * | passwordData, | |||
int | passwordDataLength, | |||
unsigned | connectionSocketIndex = 0 | |||
) | [virtual] |
Connect to the specified host (ip or domain name) and server port. Calling Connect and not calling SetMaximumIncomingConnections acts as a dedicated client. Calling both acts as a true peer. This is a non-blocking connection. You know the connection is successful when IsConnected() returns true or Receive() gets a message with the type identifier ID_CONNECTION_ACCEPTED. If the connection is not successful, such as a rejected connection or no response then neither of these things will happen.
[in] | host | Either a dotted IP address or a domain name |
[in] | remotePort | Which port to connect to on the remote machine. |
[in] | passwordData | A data block that must match the data block on the server passed to SetIncomingPassword. This can be a string or can be a stream of data. Use 0 for no password. |
[in] | passwordDataLength | The length in bytes of passwordData |
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
Implements RakPeerInterface.
void RakPeer::DeallocatePacket | ( | Packet * | packet | ) | [virtual] |
Call this to deallocate a message returned by Receive() when you are done handling it.
[in] | packet | The message to deallocate. |
Implements RakPeerInterface.
bool RakPeer::DeleteCompressionLayer | ( | bool | inputLayer | ) | [virtual] |
Delete the output or input layer as specified. This is not necessary to call and is only valuable for freeing memory.
[in] | inputLayer | True to mean the inputLayer, false to mean the output layer |
Implements RakPeerInterface.
void RakPeer::DetachPlugin | ( | PluginInterface * | messageHandler | ) | [virtual] |
Detaches a Plugin interface to run code automatically on message receipt
[in] | messageHandler | Pointer to a plugin to detach |
Implements RakPeerInterface.
void RakPeer::DisableSecurity | ( | void | ) | [virtual] |
bool RakPeer::GenerateCompressionLayer | ( | unsigned int | inputFrequencyTable[256], | |
bool | inputLayer | |||
) | [virtual] |
This is an optional function to generate the compression layer based on the input frequency table. If you want to use it you should call this twice - once with inputLayer as true and once as false. The frequency table passed here with inputLayer=true should match the frequency table on the recipient with inputLayer=false. Likewise, the frequency table passed here with inputLayer=false should match the frequency table on the recipient with inputLayer=true. Calling this function when there is an existing layer will overwrite the old layer.
[in] | inputFrequencyTable | A frequency table for your data |
[in] | inputLayer | Is this the input layer? |
Implements RakPeerInterface.
int RakPeer::GetAveragePing | ( | const SystemAddress | systemAddress | ) | [virtual] |
Returns the average of all ping times read for the specific system or -1 if none read yet
[in] | systemAddress | Which system we are referring to |
Implements RakPeerInterface.
float RakPeer::GetCompressionRatio | ( | void | ) | const [virtual] |
Returns the compression ratio. A low compression ratio is good. Compression is for outgoing data
Implements RakPeerInterface.
bool RakPeer::GetConnectionList | ( | SystemAddress * | remoteSystems, | |
unsigned short * | numberOfSystems | |||
) | const [virtual] |
Fills the array remoteSystems with the SystemAddress of all the systems we are connected to
[out] | remoteSystems | An array of SystemAddress structures to be filled with the SystemAddresss of the systems we are connected to. Pass 0 to remoteSystems to only get the number of systems we are connected to |
[in,out] | numberOfSystems | As input, the size of remoteSystems array. As output, the number of elements put into the array |
Implements RakPeerInterface.
float RakPeer::GetDecompressionRatio | ( | void | ) | const [virtual] |
Returns the decompression ratio. A high decompression ratio is good. Decompression is for incoming data
Implements RakPeerInterface.
SystemAddress RakPeer::GetExternalID | ( | const SystemAddress | target | ) | const [virtual] |
Return the unique address identifier that represents you on the the network and is based on your externalIP / port (the IP / port the specified player uses to communicate with you)
[in] | target | Which remote system you are referring to for your external ID. Usually the same for all systems, unless you have two or more network cards. |
Implements RakPeerInterface.
RakNetGUID RakPeer::GetGuidFromSystemAddress | ( | const SystemAddress | input | ) | const [virtual] |
Given a connected system, give us the unique GUID representing that instance of RakPeer. This will be the same on all systems connected to that instance of RakPeer, even if the external system addresses are different O(log2(n)) If input is UNASSIGNED_SYSTEM_ADDRESS, will return your own GUID
[in] | input | The system address of the system we are connected to |
Implements RakPeerInterface.
void RakPeer::GetIncomingPassword | ( | char * | passwordData, | |
int * | passwordDataLength | |||
) | [virtual] |
Gets the password passed to SetIncomingPassword
[out] | passwordData | Should point to a block large enough to hold the password data you passed to SetIncomingPassword() |
[in,out] | passwordDataLength | Maximum size of the array passwordData. Modified to hold the number of bytes actually written |
Implements RakPeerInterface.
int RakPeer::GetIndexFromSystemAddress | ( | const SystemAddress | systemAddress | ) | [virtual] |
Given a systemAddress, returns an index from 0 to the maximum number of players allowed - 1. This includes systems which were formerly connected, but are not now connected
[in] | systemAddress | The SystemAddress we are referring to |
Implements RakPeerInterface.
SystemAddress RakPeer::GetInternalID | ( | const SystemAddress | systemAddress = UNASSIGNED_SYSTEM_ADDRESS , |
|
const int | index = 0 | |||
) | const [virtual] |
Return the unique address identifier that represents you or another system on the the network and is based on your local IP / port.
[in] | systemAddress | Use UNASSIGNED_SYSTEM_ADDRESS to get your behind-LAN address. Use a connected system to get their behind-LAN address |
[in] | index | When you have multiple internal IDs, which index to return? Currently limited to MAXIMUM_NUMBER_OF_INTERNAL_IDS (so the maximum value of this variable is MAXIMUM_NUMBER_OF_INTERNAL_IDS-1) |
Implements RakPeerInterface.
int RakPeer::GetLastPing | ( | const SystemAddress | systemAddress | ) | const [virtual] |
Returns the last ping time read for the specific system or -1 if none read yet
[in] | systemAddress | Which system we are referring to |
Implements RakPeerInterface.
const char * RakPeer::GetLocalIP | ( | unsigned int | index | ) | [virtual] |
Returns an IP address at index 0 to GetNumberOfAddresses-1
[in] | index | index into the list of IP addresses |
Implements RakPeerInterface.
int RakPeer::GetLowestPing | ( | const SystemAddress | systemAddress | ) | const [virtual] |
Returns the lowest ping time read or -1 if none read yet
[in] | systemAddress | Which system we are referring to |
Implements RakPeerInterface.
unsigned short RakPeer::GetMaximumIncomingConnections | ( | void | ) | const [virtual] |
Returns the value passed to SetMaximumIncomingConnections()
Implements RakPeerInterface.
int RakPeer::GetMTUSize | ( | const SystemAddress | target | ) | const [virtual] |
Returns the current MTU size
[in] | target | Which system to get this for. UNASSIGNED_SYSTEM_ADDRESS to get the default |
Implements RakPeerInterface.
NetworkIDManager * RakPeer::GetNetworkIDManager | ( | void | ) | const [virtual] |
Implements RakPeerInterface.
void RakPeer::GetOfflinePingResponse | ( | char ** | data, | |
unsigned int * | length | |||
) | [virtual] |
Returns pointers to a copy of the data passed to SetOfflinePingResponse
[out] | data | A pointer to a copy of the data passed to SetOfflinePingResponse() |
[out] | length | A pointer filled in with the length parameter passed to SetOfflinePingResponse() |
Implements RakPeerInterface.
bool RakPeer::GetOutgoingFrequencyTable | ( | unsigned int | outputFrequencyTable[256] | ) | [virtual] |
Returns the frequency of outgoing bytes into output frequency table The purpose is to save to file as either a master frequency table from a sample game session for passing to GenerateCompressionLayer()
[out] | outputFrequencyTable | The frequency of each corresponding byte |
Implements RakPeerInterface.
RakPeer::RemoteSystemStruct * RakPeer::GetRemoteSystemFromSystemAddress | ( | const SystemAddress | systemAddress, | |
bool | calledFromNetworkThread, | |||
bool | onlyActive | |||
) | const [protected] |
Get the reliability layer associated with a systemAddress.
[in] | systemAddress | The player identifier |
int RakPeer::GetSplitMessageProgressInterval | ( | void | ) | const [virtual] |
Returns what was passed to SetSplitMessageProgressInterval()
Implements RakPeerInterface.
RakNetStatistics *const RakPeer::GetStatistics | ( | const SystemAddress | systemAddress, | |
RakNetStatistics * | rns = 0 | |||
) | [virtual] |
Returns a structure containing a large set of network statistics for the specified system. You can map this data to a string using the C style StatisticsToString() function
[in] | systemAddress,: | Which connected system to get statistics for |
[in] | rns | If you supply this structure, it will be written to it. Otherwise it will use a static struct, which is not threadsafe |
Implements RakPeerInterface.
SystemAddress RakPeer::GetSystemAddressFromGuid | ( | const RakNetGUID | input | ) | const [virtual] |
Given the GUID of a connected system, give us the system address of that system. The GUID will be the same on all systems connected to that instance of RakPeer, even if the external system addresses are different Currently O(log(n)), but this may be improved in the future If input is UNASSIGNED_RAKNET_GUID, will return UNASSIGNED_SYSTEM_ADDRESS
[in] | input | The RakNetGUID of the system we are checking to see if we are connected to |
Implements RakPeerInterface.
SystemAddress RakPeer::GetSystemAddressFromIndex | ( | int | index | ) | [virtual] |
This function is only useful for looping through all systems Given an index, will return a SystemAddress.
[in] | index | Index should range between 0 and the maximum number of players allowed - 1. |
Implements RakPeerInterface.
bool RakPeer::HandleRPCPacket | ( | const char * | data, | |
int | length, | |||
SystemAddress | systemAddress | |||
) | [protected] |
Handles an RPC packet. This is sending an RPC request
[in] | data | A packet returned from Receive with the ID ID_RPC |
[in] | length | The size of the packet data |
[in] | systemAddress | The sender of the packet |
void RakPeer::HandleRPCReplyPacket | ( | const char * | data, | |
int | length, | |||
SystemAddress | systemAddress | |||
) | [protected] |
Handles an RPC reply packet. This is data returned from an RPC call
[in] | data | A packet returned from Receive with the ID ID_RPC |
[in] | length | The size of the packet data |
[in] | systemAddress | The sender of the packet |
data | A packet returned from Receive with the ID ID_RPC | |
length | The size of the packet data | |
systemAddress | The sender of the packet |
void RakPeer::InitializeSecurity | ( | const char * | pubKeyE, | |
const char * | pubKeyN, | |||
const char * | privKeyP, | |||
const char * | privKeyQ | |||
) | [virtual] |
Secures connections though a combination of SHA1, AES128, SYN Cookies, and RSA to prevent connection spoofing, replay attacks, data eavesdropping, packet tampering, and MitM attacks. There is a significant amount of processing and a slight amount of bandwidth overhead for this feature. If you accept connections, you must call this or else secure connections will not be enabled for incoming connections. If you are connecting to another system, you can call this with values for the (e and p,q) public keys before connecting to prevent MitM Define how many bits are used in RakNetDefines.h with RAKNET_RSA_FACTOR_LIMBS
[in] | pubKeyE | A pointer to the public keys from the RSACrypt class. |
[in] | pubKeyN | A pointer to the public keys from the RSACrypt class. |
[in] | privKeyP | Public key generated from the RSACrypt class. |
[in] | privKeyQ | Public key generated from the RSACrypt class. If the private keys are 0, then a new key will be generated when this function is called |
Implements RakPeerInterface.
bool RakPeer::IsActive | ( | void | ) | const [inline, virtual] |
Returns if the network thread is running
Implements RakPeerInterface.
bool RakPeer::IsBanned | ( | const char * | IP | ) | [virtual] |
Returns true or false indicating if a particular IP is banned.
[in] | IP | - Dotted IP address. |
Implements RakPeerInterface.
bool RakPeer::IsConnected | ( | const SystemAddress | systemAddress, | |
bool | includeInProgress = false , |
|||
bool | includeDisconnecting = false | |||
) | [virtual] |
Returns if a particular systemAddress is connected to us (this also returns true if we are in the process of connecting)
[in] | systemAddress | The SystemAddress we are referring to |
[in] | includeInProgress | If true, also return true for connections that are in progress but haven't completed |
[in] | includeDisconnecting | If true, also return true for connections that are in the process of disconnecting |
Implements RakPeerInterface.
bool RakPeer::IsInSecurityExceptionList | ( | const char * | ip | ) | [virtual] |
Checks to see if a given IP is in the security exception list
[in] | IP | address to check. |
Implements RakPeerInterface.
bool RakPeer::IsLocalIP | ( | const char * | ip | ) | [virtual] |
Is this a local IP?
[in] | An | IP address to check, excluding the port |
Implements RakPeerInterface.
bool RakPeer::IsNetworkSimulatorActive | ( | void | ) | [virtual] |
Returns if you previously called ApplyNetworkSimulator
Implements RakPeerInterface.
unsigned short RakPeer::NumberOfConnections | ( | void | ) | const [virtual] |
Returns how many open connections there are at this time
Implements RakPeerInterface.
bool RakPeer::Ping | ( | const char * | host, | |
unsigned short | remotePort, | |||
bool | onlyReplyOnAcceptingConnections, | |||
unsigned | connectionSocketIndex = 0 | |||
) | [virtual] |
Send a ping to the specified unconnected system. The remote system, if it is Initialized, will respond with ID_PONG followed by sizeof(RakNetTime) containing the system time the ping was sent.(Default is 4 bytes - See __GET_TIME_64BIT in RakNetTypes.h
[in] | host | Either a dotted IP address or a domain name. Can be 255.255.255.255 for LAN broadcast. |
[in] | remotePort | Which port to connect to on the remote machine. |
[in] | onlyReplyOnAcceptingConnections | Only request a reply if the remote system is accepting connections |
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
Implements RakPeerInterface.
void RakPeer::Ping | ( | const SystemAddress | target | ) | [virtual] |
Send a ping to the specified connected system.
[in] | target | Which system to ping |
Implements RakPeerInterface.
void RakPeer::PushBackPacket | ( | Packet * | packet, | |
bool | pushAtHead | |||
) | [virtual] |
Put a message back at the end of the receive queue in case you don't want to deal with it immediately
[in] | packet | The packet you want to push back. |
[in] | pushAtHead | True to push the packet so that the next receive call returns it. False to push it at the end of the queue (obviously pushing it at the end makes the packets out of order) |
Implements RakPeerInterface.
void RakPeer::RebindSocketAddress | ( | unsigned | connectionSocketIndex, | |
SocketDescriptor & | sd | |||
) | [virtual] |
Have RakNet recreate a socket using a different port. The socket should not be in use - it is up to you to either shutdown or close the connections using it. Otherwise existing connections on that socket will eventually disconnect
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
[in] | sd | Address to bind on |
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
Implements RakPeerInterface.
Packet * RakPeer::Receive | ( | void | ) | [virtual] |
Gets a message from the incoming message queue. Use DeallocatePacket() to deallocate the message after you are done with it. User-thread functions, such as RPC calls and the plugin function PluginInterface::Update occur here.
Implements RakPeerInterface.
void RakPeer::RemoveFromBanList | ( | const char * | IP | ) | [virtual] |
Allows a previously banned IP to connect. param[in] Dotted IP address. Can use * as a wildcard, such as 128.0.0.* will banAll IP addresses starting with 128.0.0
Implements RakPeerInterface.
void RakPeer::RemoveFromSecurityExceptionList | ( | const char * | ip | ) | [virtual] |
Remove a specific connection previously added via AddToSecurityExceptionList
[in] | ip | IP address to remove. Pass 0 to remove all IP addresses. * wildcards are supported. |
Implements RakPeerInterface.
bool RakPeer::Send | ( | const RakNet::BitStream * | bitStream, | |
PacketPriority | priority, | |||
PacketReliability | reliability, | |||
char | orderingChannel, | |||
SystemAddress | systemAddress, | |||
bool | broadcast | |||
) | [virtual] |
Sends a block of data to the specified system that you are connected to. Same as the above version, but takes a BitStream as input.
[in] | bitStream | The bitstream to send |
[in] | priority | What priority level to send on. See PacketPriority.h |
[in] | reliability | How reliability to send this data. See PacketPriority.h |
[in] | orderingChannel | When using ordered or sequenced messages, what channel to order these on. Messages are only ordered relative to other messages on the same stream |
[in] | systemAddress | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_SYSTEM_ADDRESS to specify none |
[in] | broadcast | True to send this packet to all connected systems. If true, then systemAddress specifies who not to send the packet to. |
Implements RakPeerInterface.
bool RakPeer::Send | ( | const char * | data, | |
const int | length, | |||
PacketPriority | priority, | |||
PacketReliability | reliability, | |||
char | orderingChannel, | |||
SystemAddress | systemAddress, | |||
bool | broadcast | |||
) | [virtual] |
Sends a block of data to the specified system that you are connected to. This function only works while the connected The first byte should be a message identifier starting at ID_USER_PACKET_ENUM
[in] | data | The block of data to send |
[in] | length | The size in bytes of the data to send |
[in] | priority | What priority level to send on. See PacketPriority.h |
[in] | reliability | How reliability to send this data. See PacketPriority.h |
[in] | orderingChannel | When using ordered or sequenced messages, what channel to order these on. Messages are only ordered relative to other messages on the same stream |
[in] | systemAddress | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_SYSTEM_ADDRESS to specify none |
[in] | broadcast | True to send this packet to all connected systems. If true, then systemAddress specifies who not to send the packet to. |
Implements RakPeerInterface.
bool RakPeer::SendList | ( | char ** | data, | |
const int * | lengths, | |||
const int | numParameters, | |||
PacketPriority | priority, | |||
PacketReliability | reliability, | |||
char | orderingChannel, | |||
SystemAddress | systemAddress, | |||
bool | broadcast | |||
) | [virtual] |
Sends multiple blocks of data, concatenating them automatically.
This is equivalent to: RakNet::BitStream bs; bs.WriteAlignedBytes(block1, blockLength1); bs.WriteAlignedBytes(block2, blockLength2); bs.WriteAlignedBytes(block3, blockLength3); Send(&bs, ...)
This function only works while the connected
[in] | data | An array of pointers to blocks of data |
[in] | lengths | An array of integers indicating the length of each block of data |
[in] | numParameters | Length of the arrays data and lengths |
[in] | priority | What priority level to send on. See PacketPriority.h |
[in] | reliability | How reliability to send this data. See PacketPriority.h |
[in] | orderingChannel | When using ordered or sequenced messages, what channel to order these on. Messages are only ordered relative to other messages on the same stream |
[in] | systemAddress | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_SYSTEM_ADDRESS to specify none |
[in] | broadcast | True to send this packet to all connected systems. If true, then systemAddress specifies who not to send the packet to. |
This is equivalent to: RakNet::BitStream bs; bs.WriteAlignedBytes(block1, blockLength1); bs.WriteAlignedBytes(block2, blockLength2); bs.WriteAlignedBytes(block3, blockLength3); Send(&bs, ...)
This function only works while the connected
[in] | data | An array of pointers to blocks of data |
[in] | lengths | An array of integers indicating the length of each block of data |
[in] | numParameters | Length of the arrays data and lengths |
[in] | priority | What priority level to send on. See PacketPriority.h |
[in] | reliability | How reliability to send this data. See PacketPriority.h |
[in] | orderingChannel | When using ordered or sequenced messages, what channel to order these on. Messages are only ordered relative to other messages on the same stream |
[in] | systemAddress | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_SYSTEM_ADDRESS to specify none |
[in] | broadcast | True to send this packet to all connected systems. If true, then systemAddress specifies who not to send the packet to. |
Implements RakPeerInterface.
void RakPeer::SendLoopback | ( | const char * | data, | |
const int | length | |||
) | [virtual] |
"Send" to yourself rather than a remote system. The message will be processed through the plugins and returned to the game as usual This function works anytime The first byte should be a message identifier starting at ID_USER_PACKET_ENUM
[in] | data | The block of data to send |
[in] | length | The size in bytes of the data to send |
Implements RakPeerInterface.
void RakPeer::SendTTL | ( | const char * | host, | |
unsigned short | remotePort, | |||
int | ttl, | |||
unsigned | connectionSocketIndex = 0 | |||
) | [virtual] |
Send a message to host, with the IP socket option TTL set to 3 This message will not reach the host, but will open the router.
[in] | ttl | Max hops of datagram Used for NAT-Punchthrough |
Implements RakPeerInterface.
void RakPeer::SetCompileFrequencyTable | ( | bool | doCompile | ) | [virtual] |
Enables or disables frequency table tracking. This is required to get a frequency table, which is used in GenerateCompressionLayer() This value persists between connect calls and defaults to false (no frequency tracking)
[in] | doCompile | True to enable tracking |
Implements RakPeerInterface.
void RakPeer::SetIncomingPassword | ( | const char * | passwordData, | |
int | passwordDataLength | |||
) | [virtual] |
Sets the password incoming connections must match in the call to Connect (defaults to none). Pass 0 to passwordData to specify no password This is a way to set a low level password for all incoming connections. To selectively reject connections, implement your own scheme using CloseConnection() to remove unwanted connections
[in] | passwordData | A data block that incoming connections must match. This can be just a password, or can be a stream of data. Specify 0 for no password data |
[in] | passwordDataLength | The length in bytes of passwordData |
Implements RakPeerInterface.
void RakPeer::SetMaximumIncomingConnections | ( | unsigned short | numberAllowed | ) | [virtual] |
Sets how many incoming connections are allowed. If this is less than the number of players currently connected, no more players will be allowed to connect. If this is greater than the maximum number of peers allowed, it will be reduced to the maximum number of peers allowed. Defaults to 0, meaning by default, nobody can connect to you
[in] | numberAllowed | Maximum number of incoming connections allowed. |
Implements RakPeerInterface.
bool RakPeer::SetMTUSize | ( | int | size, | |
const SystemAddress | target | |||
) | [virtual] |
Set the MTU per datagram. It's important to set this correctly - otherwise packets will be needlessly split, decreasing performance and throughput. Maximum allowed size is MAXIMUM_MTU_SIZE. Too high of a value will cause packets not to arrive at worst and be fragmented at best. Too low of a value will split packets unnecessarily. Recommended size is 1500 sa MTUSize.h
[in] | size | The MTU size |
[in] | target | Which system to set this for. UNASSIGNED_SYSTEM_ADDRESS to set the default, for new systems |
Implements RakPeerInterface.
void RakPeer::SetOccasionalPing | ( | bool | doPing | ) | [virtual] |
Ping the remote systems every so often, or not. This is off by default. Can be called anytime.
[in] | doPing | True to start occasional pings. False to stop them. |
Implements RakPeerInterface.
void RakPeer::SetOfflinePingResponse | ( | const char * | data, | |
const unsigned int | length | |||
) | [virtual] |
Sets the data to send along with a LAN server discovery or offline ping reply. length should be under 400 bytes, as a security measure against flood attacks
[in] | data | a block of data to store, or 0 for none |
[in] | length | The length of data in bytes, or 0 for none |
Implements RakPeerInterface.
void RakPeer::SetPerConnectionOutgoingBandwidthLimit | ( | unsigned | maxBitsPerSecond | ) | [virtual] |
Limits how much outgoing bandwidth can be sent per-connection. This limit does not apply to the sum of all connections! Exceeding the limit queues up outgoing traffic
[in] | maxBitsPerSecond | Maximum bits per second to send. Use 0 for unlimited (default). Once set, it takes effect immedately and persists until called again. |
Implements RakPeerInterface.
void RakPeer::SetSplitMessageProgressInterval | ( | int | interval | ) | [virtual] |
Controls how often to return ID_DOWNLOAD_PROGRESS for large message downloads. ID_DOWNLOAD_PROGRESS is returned to indicate a new partial message chunk, roughly the MTU size, has arrived As it can be slow or cumbersome to get this notification for every chunk, you can set the interval at which it is returned. Defaults to 0 (never return this notification)
[in] | interval | How many messages to use as an interval |
Implements RakPeerInterface.
void RakPeer::SetTimeoutTime | ( | RakNetTime | timeMS, | |
const SystemAddress | target | |||
) | [virtual] |
Set the time, in MS, to use before considering ourselves disconnected after not being able to deliver a reliable message. Default time is 10,000 or 10 seconds in release and 30,000 or 30 seconds in debug.
[in] | timeMS | Time, in MS |
[in] | target | Which system to do this for. Pass UNASSIGNED_SYSTEM_ADDRESS for all systems. |
Implements RakPeerInterface.
void RakPeer::SetUnreliableTimeout | ( | RakNetTime | timeoutMS | ) | [virtual] |
Set how long to wait before giving up on sending an unreliable message Useful if the network is clogged up. Set to 0 or less to never timeout. Defaults to 0.
[in] | timeoutMS | How many ms to wait before simply not sending an unreliable message. |
Implements RakPeerInterface.
void RakPeer::Shutdown | ( | unsigned int | blockDuration, | |
unsigned char | orderingChannel = 0 | |||
) | [virtual] |
Connect to the specified network ID (Platform specific console function) Does built-in NAT traversal.
[in] | networkServiceId | Network ID structure for the online service |
[in] | passwordData | A data block that must match the data block on the server passed to SetIncomingPassword. This can be a string or can be a stream of data. Use 0 for no password. |
[in] | passwordDataLength | The length in bytes of passwordData Stops the network threads and closes all connections. |
[in] | blockDuration | How long, in milliseconds, you should wait for all remaining messages to go out, including ID_DISCONNECTION_NOTIFICATION. If 0, it doesn't wait at all. |
[in] | orderingChannel | If blockDuration > 0, ID_DISCONNECTION_NOTIFICATION will be sent on this channel If you set it to 0 then the disconnection notification won't be sent |
Implements RakPeerInterface.
bool RakPeer::Startup | ( | unsigned short | maxConnections, | |
int | _threadSleepTimer, | |||
SocketDescriptor * | socketDescriptors, | |||
unsigned | socketDescriptorCount | |||
) | [virtual] |
Starts the network threads, opens the listen port. You must call this before calling Connect(). Multiple calls while already active are ignored. To call this function again with different settings, you must first call Shutdown().
Starts the network threads, opens the listen port. You must call this before calling Connect(). Multiple calls while already active are ignored. To call this function again with different settings, you must first call Shutdown().
Set _RAKNET_THREADSAFE in RakNetDefines.h if you want to call RakNet functions from multiple threads (not recommended, as it is much slower and RakNet is already asynchronous).
[in] | maxConnections | The maximum number of connections between this instance of RakPeer and another instance of RakPeer. Required so the network can preallocate and for thread safety. A pure client would set this to 1. A pure server would set it to the number of allowed clients.- A hybrid would set it to the sum of both types of connections |
[in] | localPort | The port to listen for connections on. |
[in] | _threadSleepTimer | How many ms to Sleep each internal update cycle (30 to give the game priority, 0 for regular (recommended) |
[in] | socketDescriptors | An array of SocketDescriptor structures to force RakNet to listen on a particular IP address or port (or both). Each SocketDescriptor will represent one unique socket. Do not pass redundant structures. To listen on a specific port, you can pass SocketDescriptor(myPort,0); such as for a server. For a client, it is usually OK to just pass SocketDescriptor(); |
[in] | socketDescriptorCount | The size of the socketDescriptors array. Pass 1 if you are not sure what to pass. |
Set _RAKNET_THREADSAFE in RakNetDefines.h if you want to call RakNet functions from multiple threads (not recommended, as it is much slower and RakNet is already asynchronous).
[in] | maxConnections | The maximum number of connections between this instance of RakPeer and another instance of RakPeer. Required so the network can preallocate and for thread safety. A pure client would set this to 1. A pure server would set it to the number of allowed clients.- A hybrid would set it to the sum of both types of connections |
[in] | localPort | The port to listen for connections on. |
[in] | _threadSleepTimer | How many ms to Sleep each internal update cycle (30 to give the game priority, 0 for regular (recommended) |
[in] | socketDescriptors | An array of SocketDescriptor structures to force RakNet to listen on a particular IP address or port (or both). Each SocketDescriptor will represent one unique socket. Do not pass redundant structures. To listen on a specific port, you can pass &socketDescriptor, 1SocketDescriptor(myPort,0); such as for a server. For a client, it is usually OK to just pass SocketDescriptor(); |
[in] | socketDescriptorCount | The size of the socketDescriptors array. Pass 1 if you are not sure what to pass. |
Implements RakPeerInterface.
void RakPeer::UseUserSocket | ( | int | socket, | |
bool | haveRakNetCloseSocket, | |||
unsigned | connectionSocketIndex | |||
) | [virtual] |
Have RakNet use a socket you created yourself The socket should not be in use - it is up to you to either shutdown or close the connections using it. Otherwise existing connections on that socket will eventually disconnect This socket will be forgotten after calling Shutdown(), so rebind again if you need to.
[in] | s | The socket to rebind. |
[in] | haveRakNetCloseSocket | If true, RakNet will call closeSocket on shutdown for this socket. |
[in] | connectionSocketIndex | Index into the array of socket descriptors passed to socketDescriptors in RakPeer::Startup() to send on. |
Implements RakPeerInterface.
bool RakPeer::allowConnectionResponseIPMigration [protected] |
How long it has been since things were updated by a call to receiveUpdate thread uses this to determine how long to sleep for.
True to allow connection accepted packets from anyone. False to only allow these packets from servers we requested a connection to.
unsigned int RakPeer::bytesSentPerSecond [protected] |
The list of people we have tried to connect to recently.
Data that both the client and the server needs
unsigned short RakPeer::maximumIncomingConnections [protected] |
Store the maximum number of peers able to connect, including reserved connection slots for pings, etc.
Store the maximum incoming connection allowed
* unsigned short RakPeer::maximumNumberOfPeers [protected] |
Store the maximum number of peers allowed to connect.
Do we occasionally ping the other systems?
RemoteSystemStruct* RakPeer::remoteSystemList [protected] |
This is an array of pointers to RemoteSystemStruct This allows us to preallocate the list when starting, so we don't have to allocate or delete at runtime. Another benefit is that is lets us add and remove active players simply by setting systemAddress and moving elements in the list by copying pointers variables without affecting running threads, even if they are in the reliability layer