the whole game

2026-03-02 22:04:18 +03:00
parent 816e9060b4
commit f0617a5d22
2069 changed files with 581500 additions and 0 deletions
--- a/src/network/RakNetInstance.cpp
+++ b/src/network/RakNetInstance.cpp
@@ -0,0 +1,740 @@
+#include "RakNetInstance.h"
+#include "Packet.h"
+#include "NetEventCallback.h"
+#include "../raknet/RakPeerInterface.h"
+#include "../raknet/BitStream.h"
+#include "../raknet/MessageIdentifiers.h"
+#include "../raknet/GetTime.h"
+#include "../AppConstants.h"
+
+#include "../platform/log.h"
+
+#define APP_IDENTIFIER "MCCPP;" APP_VERSION_STRING ";"
+#define APP_IDENTIFIER_MINECON "MCCPP;MINECON;"
+
+RakNetInstance::RakNetInstance()
+:	rakPeer(NULL),
+	_isServer(false),
+	_isLoggedIn(false)
+{
+	rakPeer = RakNet::RakPeerInterface::GetInstance();
+	rakPeer->SetTimeoutTime(20000, RakNet::UNASSIGNED_SYSTEM_ADDRESS);
+    rakPeer->SetOccasionalPing(true);
+}
+
+RakNetInstance::~RakNetInstance()
+{
+	if (rakPeer)
+	{
+		rakPeer->Shutdown(100, 0);
+		RakNet::RakPeerInterface::DestroyInstance(rakPeer);
+		rakPeer = NULL;
+	}
+}
+
+bool RakNetInstance::host(const std::string& localName, int port, int maxConnections /* = 4 */)
+{
+	if (rakPeer->IsActive())
+	{
+		rakPeer->Shutdown(500);
+	}
+
+	RakNet::SocketDescriptor socket(port, 0);
+	socket.socketFamily = AF_INET;
+
+	rakPeer->SetMaximumIncomingConnections(maxConnections);
+	RakNet::StartupResult result = rakPeer->Startup(maxConnections, &socket, 1);
+
+	_isServer = true;
+	isPingingForServers = false;
+
+	return (result == RakNet::RAKNET_STARTED);
+}
+
+void RakNetInstance::announceServer(const std::string& localName)
+{
+	if (_isServer && rakPeer->IsActive())
+	{
+		RakNet::RakString connectionData;
+
+#if defined(MINECON)
+		connectionData += APP_IDENTIFIER_MINECON;
+#else
+		connectionData += APP_IDENTIFIER;
+#endif
+		connectionData += localName.c_str();
+
+		RakNet::BitStream bitStream;
+		bitStream.Write(connectionData);
+		rakPeer->SetOfflinePingResponse((const char*)bitStream.GetData(), bitStream.GetNumberOfBytesUsed());
+	}
+}
+
+bool RakNetInstance::connect(const char* host, int port)
+{
+	_isLoggedIn = false;
+	RakNet::StartupResult result;
+
+	RakNet::SocketDescriptor socket(0, 0);
+	socket.socketFamily = AF_INET;
+
+	if (rakPeer->IsActive())
+	{
+		rakPeer->Shutdown(500);
+	}
+
+	result = rakPeer->Startup(4, &socket, 1);
+
+	_isServer = false;
+	isPingingForServers = false;
+
+	if (result == RakNet::RAKNET_STARTED)
+	{
+		RakNet::ConnectionAttemptResult connectResult = rakPeer->Connect(host, port, NULL, 0, NULL, 0, 12, 500, 0);
+
+		return (connectResult == RakNet::CONNECTION_ATTEMPT_STARTED);
+	}
+
+	return false;
+}
+
+void RakNetInstance::disconnect()
+{
+	if (rakPeer->IsActive())
+	{
+		rakPeer->Shutdown(500);
+	}
+	_isLoggedIn = false;
+	_isServer = false;
+	isPingingForServers = false;
+}
+
+void RakNetInstance::pingForHosts(int basePort)
+{
+	if (!rakPeer->IsActive())
+	{
+		RakNet::SocketDescriptor socket(0, 0);
+		rakPeer->Startup(4, &socket, 1);
+	}
+
+	isPingingForServers = true;
+	pingPort = basePort;
+	lastPingTime = RakNet::GetTimeMS();
+
+	for (int i = 0; i < 4; ++i)
+		rakPeer->Ping("255.255.255.255", basePort + i, true);
+}
+
+void RakNetInstance::stopPingForHosts()
+{
+	if (isPingingForServers)
+	{
+		rakPeer->Shutdown(0);
+		isPingingForServers = false;
+	}
+}
+
+const ServerList& RakNetInstance::getServerList()
+{
+	return availableServers;
+}
+
+void RakNetInstance::clearServerList()
+{
+	availableServers.clear();
+	/*
+	for (int i = 0; i < 20; ++i) {
+		PingedCompatibleServer ps;
+		ps.isSpecial = false;
+		ps.name = "Fake-Real";
+		ps.address.FromString("192.168.1.236|19132");
+		availableServers.push_back(ps);
+	}
+	*/
+}
+
+RakNet::RakPeerInterface* RakNetInstance::getPeer()
+{
+	return rakPeer;
+}
+
+bool RakNetInstance::isProbablyBroken() {
+    return rakPeer->errorState < -100;
+}
+void RakNetInstance::resetIsBroken() {
+	rakPeer->errorState = 0;
+}
+
+bool RakNetInstance::isMyLocalGuid(const RakNet::RakNetGUID& guid)
+{
+	return rakPeer->IsActive() && rakPeer->GetMyGUID() == guid;
+}
+
+void RakNetInstance::runEvents(NetEventCallback* callback)
+{
+	RakNet::Packet* currentEvent;
+
+	while ((currentEvent = rakPeer->Receive()) != NULL)
+	{
+		int packetId = currentEvent->data[0];
+		int length = currentEvent->length;
+
+		RakNet::BitStream activeBitStream(currentEvent->data + 1, length - 1, false);
+
+		if (callback) {
+			if (packetId < ID_USER_PACKET_ENUM)
+			{
+				//LOGI("Received event: %s\n", getPacketName(packetId));
+				switch (packetId)
+				{
+				case ID_NEW_INCOMING_CONNECTION:
+					callback->onNewClient(currentEvent->guid);
+					break;
+				case ID_CONNECTION_REQUEST_ACCEPTED:
+					serverGuid = currentEvent->guid;
+					callback->onConnect(currentEvent->guid);
+					break;
+				case ID_CONNECTION_ATTEMPT_FAILED:
+					callback->onUnableToConnect();
+					break;
+				case ID_DISCONNECTION_NOTIFICATION:
+				case ID_CONNECTION_LOST:
+					callback->onDisconnect(currentEvent->guid);
+					break;
+				case ID_UNCONNECTED_PONG:
+					{
+						RakNet::TimeMS time;
+						RakNet::RakString data;
+						activeBitStream.Read(time);
+						activeBitStream.Read(data);
+
+						int index = handleUnconnectedPong(data, currentEvent, APP_IDENTIFIER, false);
+						if (index < 0) {
+							// Check if it's an official Mojang MineCon server
+							index = handleUnconnectedPong(data, currentEvent, APP_IDENTIFIER_MINECON, true);
+							if (index >= 0) availableServers[index].isSpecial = true;
+						}
+					}
+					break;
+				}
+			}
+			else
+			{
+				int userPacketId = packetId - ID_USER_PACKET_ENUM;
+				bool isStatusPacket = userPacketId <= PACKET_READY;
+
+				if (isStatusPacket || _isServer || _isLoggedIn) {
+
+					if (Packet* packet = MinecraftPackets::createPacket(packetId)) {
+						packet->read(&activeBitStream);
+						packet->handle(currentEvent->guid, callback);
+						delete packet;
+					}
+				}
+			}
+		}
+
+		rakPeer->DeallocatePacket(currentEvent);
+		//delete activeBitStream;
+	}
+
+	if (isPingingForServers)
+	{
+		if (RakNet::GetTimeMS() - lastPingTime > 1000)
+		{
+			// remove servers that hasn't responded for a while
+			ServerList::iterator it = availableServers.begin();
+			for (; it != availableServers.end(); )
+			{
+				if (RakNet::GetTimeMS() - it->pingTime > 3000)
+				{
+					it = availableServers.erase(it);
+				}
+				else
+				{
+					++it;
+				}
+			}
+
+			pingForHosts(pingPort);
+		}
+	}
+
+}
+
+void RakNetInstance::send(Packet& packet) {
+	RakNet::BitStream bitStream;
+	packet.write(&bitStream);
+	if (_isServer)
+	{
+		// broadcast to all connected clients
+		rakPeer->Send(&bitStream, packet.priority, packet.reliability, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
+	}
+	else
+	{
+		// send to server
+		rakPeer->Send(&bitStream, packet.priority, packet.reliability, 0, serverGuid, false);
+	}
+}
+
+void RakNetInstance::send(const RakNet::RakNetGUID& guid, Packet& packet) {
+	RakNet::BitStream bitStream;
+	packet.write(&bitStream);
+	rakPeer->Send(&bitStream, packet.priority, packet.reliability, 0, guid, false);
+}
+
+
+void RakNetInstance::send(Packet* packet)
+{
+	send(*packet);
+	delete packet;
+}
+
+void RakNetInstance::send(const RakNet::RakNetGUID& guid, Packet* packet)
+{
+	send(guid, *packet);
+	delete packet;
+}
+
+#ifdef _DEBUG
+const char* RakNetInstance::getPacketName(int packetId)
+{
+
+	switch (packetId)
+	{
+	case ID_CONNECTED_PING:
+		return "ID_CONNECTED_PING";
+		
+	case ID_UNCONNECTED_PING:
+		return "ID_UNCONNECTED_PING";
+		
+	case ID_UNCONNECTED_PING_OPEN_CONNECTIONS:
+		return "ID_UNCONNECTED_PING_OPEN_CONNECTIONS";
+		
+	case ID_CONNECTED_PONG:
+		return "ID_CONNECTED_PONG";
+		
+	case ID_DETECT_LOST_CONNECTIONS:
+		return "ID_DETECT_LOST_CONNECTIONS";
+		
+	case ID_OPEN_CONNECTION_REQUEST_1:
+		return "ID_OPEN_CONNECTION_REQUEST_1";
+		
+	case ID_OPEN_CONNECTION_REPLY_1:
+		return "ID_OPEN_CONNECTION_REPLY_1";
+		
+	case ID_OPEN_CONNECTION_REQUEST_2:
+		return "ID_OPEN_CONNECTION_REQUEST_2";
+		
+	case ID_OPEN_CONNECTION_REPLY_2:
+		return "ID_OPEN_CONNECTION_REPLY_2";
+		
+	case ID_CONNECTION_REQUEST:
+		return "ID_CONNECTION_REQUEST";
+		
+	case ID_REMOTE_SYSTEM_REQUIRES_PUBLIC_KEY:
+		return "ID_REMOTE_SYSTEM_REQUIRES_PUBLIC_KEY";
+		
+	case ID_OUR_SYSTEM_REQUIRES_SECURITY:
+		return "ID_OUR_SYSTEM_REQUIRES_SECURITY";
+		
+	case ID_PUBLIC_KEY_MISMATCH:
+		return "ID_PUBLIC_KEY_MISMATCH";
+		
+	case ID_OUT_OF_BAND_INTERNAL:
+		return "ID_OUT_OF_BAND_INTERNAL";
+		
+	case ID_SND_RECEIPT_ACKED:
+		return "ID_SND_RECEIPT_ACKED";
+		
+	case ID_SND_RECEIPT_LOSS:
+		return "ID_SND_RECEIPT_LOSS";
+		
+	case ID_CONNECTION_REQUEST_ACCEPTED:
+		return "ID_CONNECTION_REQUEST_ACCEPTED";
+		
+	case ID_CONNECTION_ATTEMPT_FAILED:
+		return "ID_CONNECTION_ATTEMPT_FAILED";
+		
+	case ID_ALREADY_CONNECTED:
+		return "ID_ALREADY_CONNECTED";
+		
+	case ID_NEW_INCOMING_CONNECTION:
+		return "ID_NEW_INCOMING_CONNECTION";
+		
+	case ID_NO_FREE_INCOMING_CONNECTIONS:
+		return "ID_NO_FREE_INCOMING_CONNECTIONS";
+		
+	case ID_DISCONNECTION_NOTIFICATION:
+		return "ID_DISCONNECTION_NOTIFICATION";
+		
+	case ID_CONNECTION_LOST:
+		return "ID_CONNECTION_LOST";
+		
+	case ID_CONNECTION_BANNED:
+		return "ID_CONNECTION_BANNED";
+		
+	case ID_INVALID_PASSWORD:
+		return "ID_INVALID_PASSWORD";
+		
+	case ID_INCOMPATIBLE_PROTOCOL_VERSION:
+		return "ID_INCOMPATIBLE_PROTOCOL_VERSION";
+		
+	case ID_IP_RECENTLY_CONNECTED:
+		return "ID_IP_RECENTLY_CONNECTED";
+		
+	case ID_TIMESTAMP:
+		return "ID_TIMESTAMP";
+		
+	case ID_UNCONNECTED_PONG:
+		return "ID_UNCONNECTED_PONG";
+		
+	case ID_ADVERTISE_SYSTEM:
+		return "ID_ADVERTISE_SYSTEM";
+		
+	case ID_DOWNLOAD_PROGRESS:
+		return "ID_DOWNLOAD_PROGRESS";
+		
+	case ID_REMOTE_DISCONNECTION_NOTIFICATION:
+		return "ID_REMOTE_DISCONNECTION_NOTIFICATION";
+		
+	case ID_REMOTE_CONNECTION_LOST:
+		return "ID_REMOTE_CONNECTION_LOST";
+		
+	case ID_REMOTE_NEW_INCOMING_CONNECTION:
+		return "ID_REMOTE_NEW_INCOMING_CONNECTION";
+		
+	case ID_FILE_LIST_TRANSFER_HEADER:
+		return "ID_FILE_LIST_TRANSFER_HEADER";
+		
+	case ID_FILE_LIST_TRANSFER_FILE:
+		return "ID_FILE_LIST_TRANSFER_FILE";
+		
+	case ID_FILE_LIST_REFERENCE_PUSH_ACK:
+		return "ID_FILE_LIST_REFERENCE_PUSH_ACK";
+		
+	case ID_DDT_DOWNLOAD_REQUEST:
+		return "ID_DDT_DOWNLOAD_REQUEST";
+		
+	case ID_TRANSPORT_STRING:
+		return "ID_TRANSPORT_STRING";
+		
+	case ID_REPLICA_MANAGER_CONSTRUCTION:
+		return "ID_REPLICA_MANAGER_CONSTRUCTION";
+		
+	case ID_REPLICA_MANAGER_SCOPE_CHANGE:
+		return "ID_REPLICA_MANAGER_SCOPE_CHANGE";
+		
+	case ID_REPLICA_MANAGER_SERIALIZE:
+		return "ID_REPLICA_MANAGER_SERIALIZE";
+		
+	case ID_REPLICA_MANAGER_DOWNLOAD_STARTED:
+		return "ID_REPLICA_MANAGER_DOWNLOAD_STARTED";
+		
+	case ID_REPLICA_MANAGER_DOWNLOAD_COMPLETE:
+		return "ID_REPLICA_MANAGER_DOWNLOAD_COMPLETE";
+		
+	case ID_RAKVOICE_OPEN_CHANNEL_REQUEST:
+		return "ID_RAKVOICE_OPEN_CHANNEL_REQUEST";
+		
+	case ID_RAKVOICE_OPEN_CHANNEL_REPLY:
+		return "ID_RAKVOICE_OPEN_CHANNEL_REPLY";
+		
+	case ID_RAKVOICE_CLOSE_CHANNEL:
+		return "ID_RAKVOICE_CLOSE_CHANNEL";
+		
+	case ID_RAKVOICE_DATA:
+		return "ID_RAKVOICE_DATA";
+		
+	case ID_AUTOPATCHER_GET_CHANGELIST_SINCE_DATE:
+		return "ID_AUTOPATCHER_GET_CHANGELIST_SINCE_DATE";
+		
+	case ID_AUTOPATCHER_CREATION_LIST:
+		return "ID_AUTOPATCHER_CREATION_LIST";
+		
+	case ID_AUTOPATCHER_DELETION_LIST:
+		return "ID_AUTOPATCHER_DELETION_LIST";
+		
+	case ID_AUTOPATCHER_GET_PATCH:
+		return "ID_AUTOPATCHER_GET_PATCH";
+		
+	case ID_AUTOPATCHER_PATCH_LIST:
+		return "ID_AUTOPATCHER_PATCH_LIST";
+		
+	case ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR:
+		return "ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR";
+		
+	case ID_AUTOPATCHER_FINISHED_INTERNAL:
+		return "ID_AUTOPATCHER_FINISHED_INTERNAL";
+		
+	case ID_AUTOPATCHER_FINISHED:
+		return "ID_AUTOPATCHER_FINISHED";
+		
+	case ID_AUTOPATCHER_RESTART_APPLICATION:
+		return "ID_AUTOPATCHER_RESTART_APPLICATION";
+		
+	case ID_NAT_PUNCHTHROUGH_REQUEST:
+		return "ID_NAT_PUNCHTHROUGH_REQUEST";
+		
+	case ID_NAT_GROUP_PUNCHTHROUGH_REQUEST:
+		return "ID_NAT_GROUP_PUNCHTHROUGH_REQUEST";
+		
+	case ID_NAT_GROUP_PUNCHTHROUGH_REPLY:
+		return "ID_NAT_GROUP_PUNCHTHROUGH_REPLY";
+		
+	case ID_NAT_CONNECT_AT_TIME:
+		return "ID_NAT_CONNECT_AT_TIME";
+		
+	case ID_NAT_GET_MOST_RECENT_PORT:
+		return "ID_NAT_GET_MOST_RECENT_PORT";
+		
+	case ID_NAT_CLIENT_READY:
+		return "ID_NAT_CLIENT_READY";
+		
+	case ID_NAT_GROUP_PUNCHTHROUGH_FAILURE_NOTIFICATION:
+		return "ID_NAT_GROUP_PUNCHTHROUGH_FAILURE_NOTIFICATION";
+		
+	case ID_NAT_TARGET_NOT_CONNECTED:
+		return "ID_NAT_TARGET_NOT_CONNECTED";
+		
+	case ID_NAT_TARGET_UNRESPONSIVE:
+		return "ID_NAT_TARGET_UNRESPONSIVE";
+		
+	case ID_NAT_CONNECTION_TO_TARGET_LOST:
+		return "ID_NAT_CONNECTION_TO_TARGET_LOST";
+		
+	case ID_NAT_ALREADY_IN_PROGRESS:
+		return "ID_NAT_ALREADY_IN_PROGRESS";
+		
+	case ID_NAT_PUNCHTHROUGH_FAILED:
+		return "ID_NAT_PUNCHTHROUGH_FAILED";
+		
+	case ID_NAT_PUNCHTHROUGH_SUCCEEDED:
+		return "ID_NAT_PUNCHTHROUGH_SUCCEEDED";
+		
+	case ID_NAT_GROUP_PUNCH_FAILED:
+		return "ID_NAT_GROUP_PUNCH_FAILED";
+		
+	case ID_NAT_GROUP_PUNCH_SUCCEEDED:
+		return "ID_NAT_GROUP_PUNCH_SUCCEEDED";
+		
+	case ID_READY_EVENT_SET:
+		return "ID_READY_EVENT_SET";
+		
+	case ID_READY_EVENT_UNSET:
+		return "ID_READY_EVENT_UNSET";
+		
+	case ID_READY_EVENT_ALL_SET:
+		return "ID_READY_EVENT_ALL_SET";
+		
+	case ID_READY_EVENT_QUERY:
+		return "ID_READY_EVENT_QUERY";
+		
+	case ID_LOBBY_GENERAL:
+		return "ID_LOBBY_GENERAL";
+		
+	case ID_RPC_REMOTE_ERROR:
+		return "ID_RPC_REMOTE_ERROR";
+		
+	case ID_RPC_PLUGIN:
+		return "ID_RPC_PLUGIN";
+		
+	case ID_FILE_LIST_REFERENCE_PUSH:
+		return "ID_FILE_LIST_REFERENCE_PUSH";
+		
+	case ID_READY_EVENT_FORCE_ALL_SET:
+		return "ID_READY_EVENT_FORCE_ALL_SET";
+		
+	case ID_ROOMS_EXECUTE_FUNC:
+		return "ID_ROOMS_EXECUTE_FUNC";
+		
+	case ID_ROOMS_LOGON_STATUS:
+		return "ID_ROOMS_LOGON_STATUS";
+		
+	case ID_ROOMS_HANDLE_CHANGE:
+		return "ID_ROOMS_HANDLE_CHANGE";
+		
+	case ID_LOBBY2_SEND_MESSAGE:
+		return "ID_LOBBY2_SEND_MESSAGE";
+		
+	case ID_LOBBY2_SERVER_ERROR:
+		return "ID_LOBBY2_SERVER_ERROR";
+		
+	case ID_FCM2_NEW_HOST:
+		return "ID_FCM2_NEW_HOST";
+		
+	case ID_FCM2_REQUEST_FCMGUID:
+		return "ID_FCM2_REQUEST_FCMGUID";
+		
+	case ID_FCM2_RESPOND_CONNECTION_COUNT:
+		return "ID_FCM2_RESPOND_CONNECTION_COUNT";
+		
+	case ID_FCM2_INFORM_FCMGUID:
+		return "ID_FCM2_INFORM_FCMGUID";
+		
+	case ID_FCM2_UPDATE_MIN_TOTAL_CONNECTION_COUNT:
+		return "ID_FCM2_UPDATE_MIN_TOTAL_CONNECTION_COUNT";
+		
+	case ID_UDP_PROXY_GENERAL:
+		return "ID_UDP_PROXY_GENERAL";
+		
+	case ID_SQLite3_EXEC:
+		return "ID_SQLite3_EXEC";
+		
+	case ID_SQLite3_UNKNOWN_DB:
+		return "ID_SQLite3_UNKNOWN_DB";
+		
+	case ID_SQLLITE_LOGGER:
+		return "ID_SQLLITE_LOGGER";
+		
+	case ID_NAT_TYPE_DETECTION_REQUEST:
+		return "ID_NAT_TYPE_DETECTION_REQUEST";
+		
+	case ID_NAT_TYPE_DETECTION_RESULT:
+		return "ID_NAT_TYPE_DETECTION_RESULT";
+		
+	case ID_ROUTER_2_INTERNAL:
+		return "ID_ROUTER_2_INTERNAL";
+		
+	case ID_ROUTER_2_FORWARDING_NO_PATH:
+		return "ID_ROUTER_2_FORWARDING_NO_PATH";
+		
+	case ID_ROUTER_2_FORWARDING_ESTABLISHED:
+		return "ID_ROUTER_2_FORWARDING_ESTABLISHED";
+		
+	case ID_ROUTER_2_REROUTED:
+		return "ID_ROUTER_2_REROUTED";
+		
+	case ID_TEAM_BALANCER_INTERNAL:
+		return "ID_TEAM_BALANCER_INTERNAL";
+		
+	case ID_TEAM_BALANCER_REQUESTED_TEAM_CHANGE_PENDING:
+		return "ID_TEAM_BALANCER_REQUESTED_TEAM_CHANGE_PENDING";
+		
+	case ID_TEAM_BALANCER_TEAMS_LOCKED:
+		return "ID_TEAM_BALANCER_TEAMS_LOCKED";
+		
+	case ID_TEAM_BALANCER_TEAM_ASSIGNED:
+		return "ID_TEAM_BALANCER_TEAM_ASSIGNED";
+		
+	case ID_LIGHTSPEED_INTEGRATION:
+		return "ID_LIGHTSPEED_INTEGRATION";
+		
+	case ID_XBOX_LOBBY:
+		return "ID_XBOX_LOBBY";
+		
+	case ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_SUCCESS:
+		return "ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_SUCCESS";
+		
+	case ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_SUCCESS:
+		return "ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_SUCCESS";
+		
+	case ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_FAILURE:
+		return "ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_FAILURE";
+		
+	case ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_FAILURE:
+		return "ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_FAILURE";
+		
+	case ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_TIMEOUT:
+		return "ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_TIMEOUT";
+		
+	case ID_TWO_WAY_AUTHENTICATION_NEGOTIATION:
+		return "ID_TWO_WAY_AUTHENTICATION_NEGOTIATION";
+		
+	case ID_CLOUD_POST_REQUEST:
+		return "ID_CLOUD_POST_REQUEST";
+		
+	case ID_CLOUD_RELEASE_REQUEST:
+		return "ID_CLOUD_RELEASE_REQUEST";
+		
+	case ID_CLOUD_GET_REQUEST:
+		return "ID_CLOUD_GET_REQUEST";
+		
+	case ID_CLOUD_GET_RESPONSE:
+		return "ID_CLOUD_GET_RESPONSE";
+		
+	case ID_CLOUD_UNSUBSCRIBE_REQUEST:
+		return "ID_CLOUD_UNSUBSCRIBE_REQUEST";
+		
+	case ID_CLOUD_SERVER_TO_SERVER_COMMAND:
+		return "ID_CLOUD_SERVER_TO_SERVER_COMMAND";
+		
+	case ID_CLOUD_SUBSCRIPTION_NOTIFICATION:
+		return "ID_CLOUD_SUBSCRIPTION_NOTIFICATION";
+		
+	case ID_RESERVED_1:
+		return "ID_RESERVED_1";
+		
+	case ID_RESERVED_2:
+		return "ID_RESERVED_2";
+		
+	case ID_RESERVED_3:
+		return "ID_RESERVED_3";
+		
+	case ID_RESERVED_4:
+		return "ID_RESERVED_4";
+		
+	case ID_RESERVED_5:
+		return "ID_RESERVED_5";
+		
+	case ID_RESERVED_6:
+		return "ID_RESERVED_6";
+		
+	case ID_RESERVED_7:
+		return "ID_RESERVED_7";
+		
+	case ID_RESERVED_8:
+		return "ID_RESERVED_8";
+		
+	case ID_RESERVED_9:
+		return "ID_RESERVED_9";
+		
+	default:
+		break;
+	}
+	return "Unknown or user-defined";
+}
+#endif
+
+int RakNetInstance::handleUnconnectedPong(const RakNet::RakString& data, const RakNet::Packet* p, const char* appid, bool insertAtBeginning)
+{
+	RakNet::RakString appIdentifier(appid);
+	// This weird code is a result of RakString.Find being pretty useless
+	bool emptyNameOrLonger = data.GetLength() >= appIdentifier.GetLength();
+
+	if ( !emptyNameOrLonger || appIdentifier.StrCmp(data.SubStr(0, appIdentifier.GetLength())) != 0)
+		return -1;
+
+	bool found = false;
+	for (unsigned int i = 0; i < availableServers.size(); i++) {
+		if (availableServers[i].address == p->systemAddress) {
+			availableServers[i].pingTime = RakNet::GetTimeMS();
+
+			bool emptyName = data.GetLength() == appIdentifier.GetLength();
+			if (emptyName)
+				availableServers[i].name = "";
+			else {
+				availableServers[i].name = data.SubStr(appIdentifier.GetLength(), data.GetLength() - appIdentifier.GetLength());
+			}
+			//LOGI("Swapping name: %s\n", availableServers[i].name.C_String());
+			return i;
+		}
+	}
+	PingedCompatibleServer server;
+	server.address = p->systemAddress;
+	server.pingTime = RakNet::GetTimeMS();
+	server.isSpecial = false;
+	server.name = data.SubStr(appIdentifier.GetLength(), data.GetLength() - appIdentifier.GetLength());
+
+	if (insertAtBeginning) {
+		availableServers.insert(availableServers.begin(), server);
+		return 0;
+	} else {
+		availableServers.push_back(server);
+		return availableServers.size() - 1;
+	}
+}
+
+void RakNetInstance::setIsLoggedIn( bool status ) {
+	_isLoggedIn = status;
+}