+Unity Runtime codeHEADmaster

1 files changed, 692 insertions, 0 deletions

diff --git a/Runtime/Network/MasterServerInterface.cpp b/Runtime/Network/MasterServerInterface.cpp
new file mode 100644
index 0000000..8ce20d7
--- /dev/null
+++ b/Runtime/Network/MasterServerInterface.cpp
@@ -0,0 +1,692 @@
+#include "UnityPrefix.h"
+#include "MasterServerInterface.h"
+
+#if ENABLE_NETWORK
+#include "External/RakNet/builds/include/TableSerializer.h"
+#include "External/RakNet/builds/include/BitStream.h"
+#include "External/RakNet/builds/include/StringCompressor.h"
+#include "External/RakNet/builds/include/DS_Table.h"
+#include "External/RakNet/builds/include/RakNetworkFactory.h"
+#include "External/RakNet/builds/include/SocketLayer.h"
+#include "Configuration/UnityConfigureVersion.h"
+#include "NetworkManager.h"
+#include <time.h>
+#include "NetworkUtility.h"
+
+// Future todos
+// TODO: ATM there is a 200 ms delay on disconnects. It "could" be possible that more than 200 ms pass before a network action is completed
+//       maybe this should be done only after we make sure the operation is done.
+// NOTE: Row IDs are sent to clients when they do not have a row ID (first reg) or when the master server has restarted (and forgotten everything).
+//       The problem is that updates from the client are sent with the old row ID which is not found during lookup and a new one sent to the client
+//       The client never receives this new row ID because the connection is always closed after sending updates. The simples solution is to
+//       keep client connections persistent for clients running hosts. Clients which just query for the host list (game clients) disconnect immediately.
+
+namespace {
+	const int kMasterServerPort = 23466;
+	const time_t kMaxUpdateInterval = 2;
+}
+
+MasterServerInterface::MasterServerInterface(MemLabelId label, ObjectCreationMode mode)
+:	Super(label, mode)
+{
+	m_Peer = RakNetworkFactory::GetRakPeerInterface();
+	m_GameType = "";
+	m_HostName = "";
+	m_PendingRegister = false;
+	m_PendingHostUpdate = false;
+	m_PendingQuery = false;
+	m_RowID = -1;
+	m_LastHostUpdateTime = 0;
+	m_Registered = false;
+	m_MasterServerID.binaryAddress = 0;
+	m_MasterServerID.port = kMasterServerPort;
+	m_Version[0]=2; m_Version[1]=0; m_Version[2]=0;
+	m_UpdateRate = 10;
+	m_IsDedicatedServer = false;
+	time(&m_ShutdownTimer);
+
+	m_HostDatabaseClient = new LightweightDatabaseClient;
+	
+	// Create the cell update that will be reused for storing last update
+	strcpy(m_LastUpdate[0].columnName,"NAT");
+	m_LastUpdate[0].columnType = DataStructures::Table::NUMERIC;
+	m_LastUpdate[0].cellValue.Set(0);
+	strcpy(m_LastUpdate[1].columnName,"Game name");
+	m_LastUpdate[1].columnType = DataStructures::Table::STRING;
+	m_LastUpdate[1].cellValue.Set(0);
+	strcpy(m_LastUpdate[2].columnName,"Connected players");
+	m_LastUpdate[2].columnType = DataStructures::Table::NUMERIC;
+	m_LastUpdate[2].cellValue.Set(0);
+	strcpy(m_LastUpdate[3].columnName,"Player limit");
+	m_LastUpdate[3].columnType = DataStructures::Table::NUMERIC;
+	m_LastUpdate[3].cellValue.Set(0);
+	strcpy(m_LastUpdate[4].columnName,"Password protected");
+	m_LastUpdate[4].columnType = DataStructures::Table::NUMERIC;
+	m_LastUpdate[4].cellValue.Set(0);
+	strcpy(m_LastUpdate[5].columnName,"IP address");
+	m_LastUpdate[5].columnType = DataStructures::Table::BINARY;
+	m_LastUpdate[5].cellValue.Set(NULL, 0);
+	strcpy(m_LastUpdate[6].columnName,"Port");
+	m_LastUpdate[6].columnType = DataStructures::Table::NUMERIC;
+	m_LastUpdate[6].cellValue.Set(0);
+	strcpy(m_LastUpdate[7].columnName,"Comment");
+	m_LastUpdate[7].columnType = DataStructures::Table::STRING;
+	m_LastUpdate[7].cellValue.Set(0);
+}
+
+MasterServerInterface::~MasterServerInterface()
+{
+	delete m_HostDatabaseClient;
+	m_HostDatabaseClient = NULL;
+	RakNetworkFactory::DestroyRakPeerInterface(m_Peer);
+	m_Peer = NULL;
+}
+
+void MasterServerInterface::NetworkOnApplicationQuit()
+{
+	m_Peer->Shutdown(100);
+	m_HostList.clear();
+	// Reset to default values
+	m_MasterServerID.binaryAddress = 0;
+	m_MasterServerID.port = kMasterServerPort;	
+	m_GameType = "";
+	m_HostName = "";
+	m_HostComment = "";
+	m_PendingRegister = false;
+	m_PendingHostUpdate = false;
+	m_PendingQuery = false;
+	m_RowID = -1;
+	m_Registered = false;
+	m_UpdateRate = 10;
+	m_IsDedicatedServer = false;
+}
+
+// Resolve the master server address if it is invalid
+void MasterServerInterface::ResolveMasterServerAddress()
+{
+	ResolveAddress(m_MasterServerID, "masterserver.unity3d.com", "masterserverbeta.unity3d.com",
+		"Cannot resolve master server address, you must be connected to the internet before using it or set the address to something accessible to you.");
+}
+
+void MasterServerInterface::ClientConnect()
+{
+	ResolveMasterServerAddress();
+
+	SocketDescriptor sd(0,0);
+	if (!m_Peer->Startup(1, 30, &sd, 1))
+	{
+		SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, kFailedToCreatedSocketOrThread);
+	}
+	m_Peer->AttachPlugin(&m_DatabaseClient);
+	if (!m_Peer->Connect(m_MasterServerID.ToString(false), m_MasterServerID.port, 0, 0))
+	{
+		if (m_Peer->GetMaximumNumberOfPeers() >= m_Peer->NumberOfConnections())
+		{
+			ErrorString("Internal error while connecting to master server. Too many connected peers.");
+		}
+		else
+		{
+			ErrorString("Internal error while attempting to connect to master server.");
+			SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, kIncorrectParameters);
+		}
+	}
+}
+
+bool MasterServerInterface::CheckServerConnection()
+{
+	ResolveMasterServerAddress();
+	
+	if (!GetNetworkManager().GetPeer()->IsConnected(m_MasterServerID))
+	{
+		ServerConnect();
+		return false;
+	}
+	if (!GetNetworkManager().GetPeer()->IsActive())
+	{
+		ServerConnect();
+		return false;
+	}
+	return true;
+}
+
+void MasterServerInterface::ServerConnect()
+{
+	if (!GetNetworkManager().GetPeer()->Connect(m_MasterServerID.ToString(false), m_MasterServerID.port, 0, 0))
+	{
+		ErrorString("Internal error while attempting to connect to master server\n");
+		SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, kInternalDirectConnectFailed);
+	}
+	NetworkInfo(NULL, "Attempting to connect to master server at %s:%d", m_MasterServerID.ToString(false), m_MasterServerID.port);
+	m_PendingRegister = true;
+}
+
+void MasterServerInterface::ProcessPacket(Packet *packet)
+{
+	switch(packet->data[0])
+	{
+		// Disconnect and connection lost only occurs for clients requesting host info, not servers registering their info
+		case ID_DISCONNECTION_NOTIFICATION:
+		{
+			NetworkInfo(NULL, "Disconnected from master server");
+			SendToAllNetworkViews(kDisconnectedFromMasterServer, ID_DISCONNECTION_NOTIFICATION);
+			m_PendingQuery = false;
+			break;
+		}
+		case ID_CONNECTION_LOST:
+		{
+			// If connection was lost with master server we should re-register the host. If running as client do nothing.
+			if (GetNetworkManager().IsServer())
+			{
+				NetworkInfo(NULL, "Lost connection to master server, reconnecting and resending host info");
+				ResetHostState();
+				SendHostUpdate();
+			}
+			else
+			{
+				ErrorString("Connection with master server lost");
+				SendToAllNetworkViews(kDisconnectedFromMasterServer, ID_CONNECTION_LOST);
+				m_PendingQuery = false;
+			}
+			break;
+		}
+		case ID_CONNECTION_BANNED:
+		{
+			ErrorString("Temporarily banned from the master server");
+			SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, ID_CONNECTION_BANNED);
+			break;
+		}
+		case ID_CONNECTION_REQUEST_ACCEPTED:
+		{
+			NetworkInfo(NULL, "Connected to master server at %s", packet->systemAddress.ToString());
+			if (m_PendingRegister)
+			{
+				m_PendingRegister = false;
+				RegisterHost(m_GameType, m_HostName, m_HostComment);
+			}
+			if (m_PendingQuery)
+			{
+				m_PendingQuery = false;
+				QueryHostList(m_GameType);
+			}
+			if (m_PendingHostUpdate)
+			{
+				m_PendingHostUpdate = false;
+				SendHostUpdate();
+			}
+			break;
+		}
+		case ID_ALREADY_CONNECTED:
+		{
+			NetworkError(NULL, "Already connected to the master server, the server probably hasn't cleaned up because of an abrupt disconnection.");
+			SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, ID_ALREADY_CONNECTED);
+			m_PendingQuery = false;
+			break;
+		}
+		case ID_CONNECTION_ATTEMPT_FAILED:
+		{
+			ErrorString(Format("Failed to connect to master server at %s", packet->systemAddress.ToString()));
+			SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, ID_CONNECTION_ATTEMPT_FAILED);
+			ResetHostState();
+			break;
+		}
+		// TODO: atm the server does not send this during client lookups, but maybe it should (as all tables are dynamically created this will never be returned to hosts)
+		case ID_DATABASE_UNKNOWN_TABLE:
+		{
+			ErrorString("Unkown game type");
+			// This uses NetworkConnectionError enums, and this status message doesn't belong in there 
+			//SendToAllNetworkViews(kMasterServerConnectionAttemptFailed, kUnkownGameType);
+			break;
+		}
+		// This should never occur as we don't use db passwords directly
+		case ID_DATABASE_INCORRECT_PASSWORD:
+		{
+			ErrorString("Incorrect master server password");
+			break;
+		}
+		case ID_DATABASE_QUERY_REPLY:
+		{
+			NetworkInfo(NULL, "Incoming host list query response from master server.");
+			
+			DataStructures::Table table;
+			if (TableSerializer::DeserializeTable(packet->data+sizeof(MessageID), packet->length-sizeof(MessageID), &table))
+			{
+				m_HostList.clear();
+				DataStructures::Page<unsigned, DataStructures::Table::Row*, _TABLE_BPLUS_TREE_ORDER> *cur = table.GetListHead();
+				while (cur)
+				{
+					for (int i=0; i < (unsigned)cur->size; i++)
+					{
+						// NOTE: The first three cell values are the systemId (binary), last ping response time and next ping 
+						// send time(numerics)
+						DataStructures::List<DataStructures::Table::Cell*> cells = cur->data[i]->cells;
+						HostData data;
+						if (cells[5]->c != NULL && 
+							(int)cells[9]->i != 0 && 
+							cells[9]->c != NULL && 
+							(int)cells[10]->i != 0 &&
+							cells[12]->c != NULL)
+						{
+							data.useNat			   = (int)cells[4]->i;
+							data.gameType		   = m_GameType;
+							data.gameName		   = cells[5]->c;
+							data.connectedPlayers  = (int)cells[6]->i;
+							data.playerLimit	   = (int)cells[7]->i;
+							data.passwordProtected = (int)cells[8]->i;
+							data.guid = cells[12]->c;
+
+							int ipCount = int(cells[9]->i / 16);
+							// If the size of the data is not a factor of 16 then something has gone wrong (IP addresses have size 16)
+							if (((int)cells[9]->i) % 16 == 0)
+							{
+								for (int ip=0; ip < ipCount; ip++)
+								{
+									const char* ipData = cells[9]->c + ip * 16;
+									if( ipData[0] == 0 ) break;
+									data.IP.push_back( ipData );
+								}														
+							}
+							else
+							{
+								ErrorString(Format("Malformed data inside IP information packet. Size was %f", cells[8]->i));
+							}
+							data.port			   = int(cells[10]->i);
+							if (cells[11]->c != NULL)
+								data.comment	   = cells[11]->c;
+							else
+								data.comment       = "";
+							m_HostList.push_back(data);
+						}
+						else
+						{
+							ErrorString("Received malformed data in the host list from the master server\n");
+						}
+					}
+					cur=cur->next;
+				}
+			} 
+			else
+			{
+				m_HostList.clear();
+			}
+			SendToAllNetworkViews(kMasterServerEvent, kHostListReceived);
+			break;
+		}
+		case ID_DATABASE_ROWID:
+		{
+			unsigned int rowID;
+			RakNet::BitStream stream;
+			stream.Write((char*)packet->data, packet->length);
+			stream.IgnoreBits(8);
+			stream.Read(rowID);
+
+			NetworkInfo(NULL, "Received identifier %u from master server", rowID);
+			SendToAllNetworkViews(kMasterServerEvent, kRegistrationSucceeded);
+			m_RowID = rowID;
+			
+			break;
+		}
+		case ID_MASTERSERVER_REDIRECT:
+		{
+			SystemAddress newMaster, newFacilitator;
+			RakNet::BitStream b(packet->data, packet->length, false);
+			b.IgnoreBits(8);
+			b.Read(newMaster);
+			b.Read(newFacilitator);
+			
+			GetNetworkManager().SwapFacilitatorID(newFacilitator);
+			SystemAddress oldMasterServer = m_MasterServerID;
+			GetNetworkManager().SetOldMasterServerAddress(oldMasterServer);
+			m_MasterServerID = newMaster;
+			ResetHostState();
+			
+			if (GetNetworkManager().IsServer())
+			{
+				GetNetworkManager().GetPeer()->CloseConnection(oldMasterServer, true);
+				NetworkInfo(NULL, "Redirecting master server host updates to %s", newMaster.ToString());
+				NetworkInfo(NULL, "Changing facilitator location to %s", newFacilitator.ToString());
+				SendHostUpdate();
+			}
+			else
+			{
+				NetworkInfo(NULL, "Redirecting master server host list queries to %s", newMaster.ToString());
+				NetworkInfo(NULL, "Changing facilitator location to %s", newFacilitator.ToString());
+				Disconnect();
+				QueryHostList();
+			}
+			break;
+		}
+		case ID_MASTERSERVER_MSG:
+		{
+			int msgLength;
+			RakNet::BitStream b(packet->data, packet->length, false);
+			b.IgnoreBits(8);
+			b.Read(msgLength);
+			if (msgLength > 0)
+			{
+				char* msg = new char[msgLength];
+				b.Read(msg, msgLength);
+				LogString(Format("Message from master server: %s", msg));
+				delete[] msg;
+			}
+			break;
+		}
+		default:
+		{
+			NetworkError(NULL, "Unknown message from master server (%s) %d", packet->systemAddress.ToString(), packet->data[0]);
+			break;
+		}
+	}
+}
+
+void MasterServerInterface::NetworkUpdate()
+{
+	if (!m_Peer)
+		return;
+		
+	// Send heartbeat if running as server, only send if running as server and we have already registered (m_HostName set)
+	if (m_UpdateRate > 0 && m_Registered)
+	{
+		if ((time(0) - m_LastHostUpdateTime > m_UpdateRate) && m_HostName.size() > 1 && !m_PendingRegister)
+		{
+			SendHostUpdate();
+		}
+	}
+	
+	if (!m_Peer->IsActive())
+		return;
+		
+	// If not registering or already registered, this is a client, then check for shutdown timeout
+	if (!m_Registered && !m_PendingRegister && time(0) > m_ShutdownTimer + 20)
+	{
+		// Use a short delay, its not that bad if the disconnect notification never arrives at master server
+		m_Peer->Shutdown(50, 0);
+	}
+
+	Packet *p;
+	p=m_Peer->Receive();
+	while (p)
+	{
+		ProcessPacket(p);
+		m_Peer->DeallocatePacket(p);
+		p=m_Peer->Receive();
+	}
+}
+
+void MasterServerInterface::QueryHostList()
+{
+	QueryHostList(m_GameType);
+}
+
+void MasterServerInterface::QueryHostList(string gameType)
+{
+	time(&m_ShutdownTimer);
+
+	// Wait for previous query to clear
+	if (m_PendingQuery) return;
+
+	if (gameType.empty())
+	{
+		ErrorString("Empty game type given in QueryHostList(), aborting query.");
+		return;
+	}
+	m_GameType = gameType;
+	
+	ResolveMasterServerAddress();
+	
+	if (m_Peer == NULL)
+	{
+		ClientConnect();
+		m_PendingQuery = true;
+		return;
+	}
+	else if (!m_Peer->IsActive())
+	{
+		ClientConnect();
+		m_PendingQuery = true;
+		return;
+	}
+	else if (!m_Peer->IsConnected(m_MasterServerID))
+	{
+		ClientConnect();
+		m_PendingQuery = true;
+		return;
+	}
+	
+	m_DatabaseClient.QueryTable(m_Version, gameType.c_str(), 0, 0, 0, 0, 0, 0, 0, m_MasterServerID, false);
+//	LogString("Sent host query to master server");
+	// Disconnect after the list has arrived
+}
+
+void MasterServerInterface::ClearHostList()
+{
+	m_HostList.clear();
+}
+
+bool MasterServerInterface::PopulateUpdate()
+{
+	return PopulateUpdate(m_HostName, m_HostComment);
+}
+
+bool MasterServerInterface::PopulateUpdate(string gameName, string comment)
+{
+	// TODO: The function inside GetIPs uses char arrays which are pre-allocated. If it returns a full array then it is possible there
+	// are more IP addresses, in which case it should get a larger char array to use.
+	char ips[10][16];
+	int size = GetIPs(ips)*16;
+	if (size == 0)
+		ErrorString("Could not retrieve internal IP address. Host registration failed.");
+	
+	bool changed = false;
+	
+	if (((int)m_LastUpdate[0].cellValue.i) != static_cast<int>(GetNetworkManager().GetUseNat()))
+		changed = true;
+	
+	if (((int)m_LastUpdate[1].cellValue.i) != 0 && changed != true)
+	{
+		if (strcmp(m_LastUpdate[1].cellValue.c,gameName.c_str()) != 0)
+		{
+			changed = true;
+			m_LastUpdate[1].cellValue.Clear();
+			m_LastUpdate[1].cellValue.Set(const_cast<char*>(gameName.c_str()));
+		}
+	}
+	else
+	{
+		changed = true;
+	}
+	
+	//printf_console("connCount: Comparing %d and %d\n", intCell, GetNetworkManager().GetConnectionCount());
+	if (((int)m_LastUpdate[2].cellValue.i) != (GetNetworkManager().GetConnectionCount() + static_cast<int>(!m_IsDedicatedServer)) && changed != true)
+		changed = true;		
+	//printf_console("maxCount: Comparing %d and %d\n", intCell, GetNetworkManager().GetMaxConnections());
+	if (((int)m_LastUpdate[3].cellValue.i) != GetNetworkManager().GetMaxConnections() + static_cast<int>(!m_IsDedicatedServer) && changed != true)
+		changed = true;
+	//printf_console("password: Comparing %d and %d\n", intCell, GetNetworkManager().IsPasswordProtected());
+	if (((int)m_LastUpdate[4].cellValue.i) != static_cast<int>(GetNetworkManager().IsPasswordProtected()) && changed != true)
+		changed = true;
+		
+	if (((int)m_LastUpdate[5].cellValue.i) != 0 && changed != true)
+	{
+		/*printf_console("IPs: Comparing size %d and %d\n", intCell, size);
+		for (int i=0; i < intCell; i++)
+			printf_console("%x", tmpIPs[i]);
+		printf_console(" ");
+		for (int i=0; i < size; i++)
+			printf_console("%x", static_cast<char*>(ips[0])[i]);
+		printf_console("\n");*/
+		if (m_LastUpdate[5].cellValue.i != size)
+			changed = true;
+		else if (memcmp(m_LastUpdate[5].cellValue.c, ips, size) != 0)
+			changed = true;
+	}
+	else
+	{
+		changed = true;
+	}
+	
+	//printf_console("port: Comparing %d and %d\n", intCell, GetNetworkManager().GetPort());
+	if (((int)m_LastUpdate[6].cellValue.i) != GetNetworkManager().GetPort() && changed != true)
+		changed = true;
+	
+	if (((int)m_LastUpdate[7].cellValue.i) != 0 && changed != true)
+	{
+		//printf_console("comment: Comparing %s and %s\n", tmpComment, comment.c_str());
+		if (strcmp(m_LastUpdate[7].cellValue.c, comment.c_str()) != 0)
+			changed = true;
+	}
+	else
+	{
+		changed = true;
+	}
+	
+	if (changed)
+	{
+		for (int i = 0; i < CELL_COUNT; i++)
+			m_LastUpdate[i].cellValue.Clear();
+		m_LastUpdate[0].columnType=DataStructures::Table::NUMERIC;
+		m_LastUpdate[0].cellValue.Set(GetNetworkManager().GetUseNat());
+		m_LastUpdate[1].columnType=DataStructures::Table::STRING;
+		m_LastUpdate[1].cellValue.Set(const_cast<char*>(gameName.c_str()));
+		m_LastUpdate[2].columnType=DataStructures::Table::NUMERIC;
+		m_LastUpdate[2].cellValue.Set(GetNetworkManager().GetConnectionCount() + static_cast<int>(!m_IsDedicatedServer));
+		m_LastUpdate[3].columnType=DataStructures::Table::NUMERIC;
+		m_LastUpdate[3].cellValue.Set(GetNetworkManager().GetMaxConnections() + static_cast<int>(!m_IsDedicatedServer));
+		m_LastUpdate[4].columnType=DataStructures::Table::NUMERIC;
+		m_LastUpdate[4].cellValue.Set(static_cast<int>(GetNetworkManager().IsPasswordProtected()));
+		m_LastUpdate[5].columnType=DataStructures::Table::BINARY;
+		m_LastUpdate[5].cellValue.Set((char*)ips, size);
+		m_LastUpdate[6].columnType=DataStructures::Table::NUMERIC;
+		m_LastUpdate[6].cellValue.Set(GetNetworkManager().GetPort());
+		m_LastUpdate[7].columnType=DataStructures::Table::STRING;
+		m_LastUpdate[7].cellValue.Set(const_cast<char*>(comment.c_str()));
+	}
+	
+	return changed;
+}
+
+void MasterServerInterface::RegisterHost(string gameType, string gameName, string comment)
+{
+	// Wait until pending registrations have cleared or that a certain interval has passed (don't want to hammer the server)
+	if (m_PendingRegister || m_LastHostUpdateTime > time(0) - kMaxUpdateInterval)
+		return;
+		
+	if (gameType.empty())
+	{
+		ErrorString("Empty game type given during host registration, aborting");
+		SendToAllNetworkViews(kMasterServerEvent, kRegistrationFailedGameName);
+		return;
+	}
+	if (gameName.empty())
+	{
+		ErrorString("Empty game name given during host registration, aborting");
+		SendToAllNetworkViews(kMasterServerEvent, kRegistrationFailedGameType);
+		return;
+	}
+	if (GetNetworkManager().GetPort() == 0)
+	{
+		ErrorString("It's not possible to register a host until it is running.");
+		SendToAllNetworkViews(kMasterServerEvent, kRegistrationFailedNoServer);
+		return;
+	}
+	
+	m_GameType = gameType;
+	m_HostName = gameName;
+	m_HostComment = comment;
+
+	GetNetworkManager().GetPeer()->AttachPlugin(m_HostDatabaseClient);
+
+	if (!CheckServerConnection())
+		return;
+	
+	PopulateUpdate();
+	
+	m_LastHostUpdateTime = time(0);
+
+	m_HostDatabaseClient->UpdateRow(m_Version, gameType.c_str(), 0, RUM_UPDATE_OR_ADD_ROW, false, 0, m_LastUpdate, CELL_COUNT, m_MasterServerID, false );
+	NetworkLog(NULL, "Sent host registration to master server, registering a %sNAT assisted game as\n \"%s\", %d, %d, %s, \"%s\"", 
+		(GetNetworkManager().GetUseNat()) ? "" : "non-", 
+		gameName.c_str(),
+		GetNetworkManager().GetConnectionCount() + static_cast<int>(!m_IsDedicatedServer),
+		GetNetworkManager().GetMaxConnections() + static_cast<int>(!m_IsDedicatedServer),
+		(GetNetworkManager().IsPasswordProtected()) ? "password protected" : "not password protected",
+		comment.c_str());
+	
+	m_Registered = true;
+}
+
+// Uses the game server peer
+void MasterServerInterface::SendHostUpdate()
+{
+	// Wait until pending host updates are finished
+	if (m_PendingHostUpdate) 
+	{
+		NetworkInfo(NULL, "Still waiting for a master server reponse to another host update, ignoring this update.");
+		return;
+	}
+	
+	if (!CheckServerConnection())
+		return;
+
+	if (!PopulateUpdate())
+		return;
+
+	m_LastHostUpdateTime = time(0);
+	
+	if (m_RowID == -1)
+	{
+		m_HostDatabaseClient->UpdateRow(m_Version, m_GameType.c_str(), 0, RUM_UPDATE_OR_ADD_ROW, false, 0, m_LastUpdate, CELL_COUNT, m_MasterServerID, false );
+		NetworkInfo(NULL, "Sent new host update to master server");
+	}
+	else
+	{
+		m_HostDatabaseClient->UpdateRow(m_Version, m_GameType.c_str(), 0, RUM_UPDATE_OR_ADD_ROW, true, m_RowID, m_LastUpdate, CELL_COUNT, m_MasterServerID, false );
+		NetworkInfo(NULL, "Sent host update to master server with identifier %d", m_RowID);
+	}
+	
+	m_Registered = true;
+}
+
+void MasterServerInterface::Disconnect()
+{
+	m_Peer->Shutdown(200);
+	m_Peer->DetachPlugin(&m_DatabaseClient);
+}
+
+// Uses the game server peer
+void MasterServerInterface::UnregisterHost()
+{
+	if (GetNetworkManagerPtr())
+	{
+		if (GetNetworkManager().GetPeer()->IsConnected(m_MasterServerID))
+			m_HostDatabaseClient->RemoveRow(m_GameType.c_str(), 0, m_RowID, m_MasterServerID, false);
+		// Always detach DB plugin when running as a server, nothing will happen if it's not attached
+		if (GetNetworkManager().IsServer())
+			GetNetworkManager().GetPeer()->DetachPlugin(m_HostDatabaseClient);
+	}
+	
+	// Reset some local variables
+	m_RowID = -1;
+	m_GameType = "";
+	m_HostName = "";
+	m_HostComment = "";
+	m_Registered = false;
+}
+
+std::vector<HostData> MasterServerInterface::PollHostList()
+{	
+	return m_HostList;
+}
+
+void MasterServerInterface::ResetHostState()
+{
+	m_PendingRegister = false;
+	m_PendingHostUpdate = false;
+	m_Registered = false;
+}
+
+
+
+IMPLEMENT_CLASS (MasterServerInterface)
+GET_MANAGER (MasterServerInterface)
+GET_MANAGER_PTR (MasterServerInterface)
+#endif