added a mechanism to check for a valid standard map. Closes #132

8 files changed, 227 insertions, 18 deletions

diff --git a/src/engine/client/client.cpp b/src/engine/client/client.cpp
index 28c0fad4..8353bc0a 100644
--- a/src/engine/client/client.cpp
+++ b/src/engine/client/client.cpp
@@ -26,7 +26,7 @@
 #include <engine/shared/compression.h>
 #include <engine/shared/datafile.h>
 #include <engine/shared/demo.h>
-#include <engine/shared/memheap.h>
+#include <engine/shared/mapchecker.h>
 #include <engine/shared/network.h>
 #include <engine/shared/packer.h>
 #include <engine/shared/protocol.h>
@@ -1023,24 +1023,47 @@ int CClient::PlayerScoreComp(const void *a, const void *b)
 
 void CClient::ProcessConnlessPacket(CNetChunk *pPacket)
 {
-	// version info
-	if(pPacket->m_DataSize == (int)(sizeof(VERSIONSRV_VERSION) + sizeof(VERSION_DATA)) &&
-		mem_comp(pPacket->m_pData, VERSIONSRV_VERSION, sizeof(VERSIONSRV_VERSION)) == 0 &&
-		m_VersionInfo.m_State == CVersionInfo::STATE_READY && net_addr_comp(&pPacket->m_Address, &m_VersionInfo.m_VersionServeraddr.m_Addr) == 0)
+	// version server
+	if(m_VersionInfo.m_State == CVersionInfo::STATE_READY && net_addr_comp(&pPacket->m_Address, &m_VersionInfo.m_VersionServeraddr.m_Addr) == 0)
 	{
-		unsigned char *pVersionData = (unsigned char*)pPacket->m_pData + sizeof(VERSIONSRV_VERSION);
-		int VersionMatch = !mem_comp(pVersionData, VERSION_DATA, sizeof(VERSION_DATA));
+		// version info
+		if(pPacket->m_DataSize == (int)(sizeof(VERSIONSRV_VERSION) + sizeof(VERSION_DATA)) &&
+			mem_comp(pPacket->m_pData, VERSIONSRV_VERSION, sizeof(VERSIONSRV_VERSION)) == 0)
+		
+		{
+			unsigned char *pVersionData = (unsigned char*)pPacket->m_pData + sizeof(VERSIONSRV_VERSION);
+			int VersionMatch = !mem_comp(pVersionData, VERSION_DATA, sizeof(VERSION_DATA));
+
+			char aBuf[256];
+			str_format(aBuf, sizeof(aBuf), "version does %s (%d.%d.%d)",
+				VersionMatch ? "match" : "NOT match",
+				pVersionData[1], pVersionData[2], pVersionData[3]);
+			m_pConsole->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "client/version", aBuf);
 
-		char aBuf[256];
-		str_format(aBuf, sizeof(aBuf), "version does %s (%d.%d.%d)",
-			VersionMatch ? "match" : "NOT match",
-			pVersionData[1], pVersionData[2], pVersionData[3]);
-		m_pConsole->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "client/version", aBuf);
+			// assume version is out of date when version-data doesn't match
+			if (!VersionMatch)
+			{
+				str_format(m_aVersionStr, sizeof(m_aVersionStr), "%d.%d.%d", pVersionData[1], pVersionData[2], pVersionData[3]);
+			}
+
+			// request the map version list now
+			CNetChunk Packet;
+			mem_zero(&Packet, sizeof(Packet));
+			Packet.m_ClientID = -1;
+			Packet.m_Address = m_VersionInfo.m_VersionServeraddr.m_Addr;
+			Packet.m_pData = VERSIONSRV_GETMAPLIST;
+			Packet.m_DataSize = sizeof(VERSIONSRV_GETMAPLIST);
+			Packet.m_Flags = NETSENDFLAG_CONNLESS;
+			m_NetClient.Send(&Packet);
+		}
 
-		// assume version is out of date when version-data doesn't match
-		if (!VersionMatch)
+		// map version list
+		if(pPacket->m_DataSize >= (int)sizeof(VERSIONSRV_MAPLIST) &&
+			mem_comp(pPacket->m_pData, VERSIONSRV_MAPLIST, sizeof(VERSIONSRV_MAPLIST)) == 0)		
 		{
-			str_format(m_aVersionStr, sizeof(m_aVersionStr), "%d.%d.%d", pVersionData[1], pVersionData[2], pVersionData[3]);
+			int Size = pPacket->m_DataSize-sizeof(VERSIONSRV_MAPLIST);
+			int Num = Size/sizeof(CMapVersion);
+			m_MapChecker.AddMaplist((CMapVersion *)((char*)pPacket->m_pData+sizeof(VERSIONSRV_MAPLIST)), Num);
 		}
 	}
 
@@ -1073,9 +1096,9 @@ void CClient::ProcessConnlessPacket(CNetChunk *pPacket)
 			NETADDR Addr;
 
 			// copy address
-			Addr.type = (pAddrs->m_aType[0]<<24) | (pAddrs->m_aType[1]<<16) | (pAddrs->m_aType[2]<<8) | pAddrs->m_aType[3];
-			mem_copy(Addr.ip, pAddrs->m_aIp, sizeof(Addr.ip));
-			Addr.port = (pAddrs->m_aPort[0]<<8) | pAddrs->m_aPort[1];
+			Addr.type = (pAddrs[i].m_aType[0]<<24) | (pAddrs[i].m_aType[1]<<16) | (pAddrs[i].m_aType[2]<<8) | pAddrs[i].m_aType[3];
+			mem_copy(Addr.ip, pAddrs[i].m_aIp, sizeof(Addr.ip));
+			Addr.port = (pAddrs[i].m_aPort[0]<<8) | pAddrs[i].m_aPort[1];
 			
 			m_ServerBrowser.Set(Addr, IServerBrowser::SET_MASTER_ADD, -1, 0x0);
 		}
@@ -1159,6 +1182,10 @@ void CClient::ProcessServerPacket(CNetChunk *pPacket)
 			if(Unpacker.Error())
 				return;
 
+			// check for valid standard map
+			if(!m_MapChecker.IsMapValid(pMap, MapCrc, MapSize))
+				pError = "invalid standard map";
+
 			for(int i = 0; pMap[i]; i++) // protect the player from nasty map names
 			{
 				if(pMap[i] == '/' || pMap[i] == '\\')
diff --git a/src/engine/client/client.h b/src/engine/client/client.h
index b0696b96..86c56e0a 100644
--- a/src/engine/client/client.h
+++ b/src/engine/client/client.h
@@ -106,6 +106,7 @@ class CClient : public IClient, public CDemoPlayer::IListner
 	class CDemoRecorder m_DemoRecorder;
 	class CServerBrowser m_ServerBrowser;
 	class CFriends m_Friends;
+	class CMapChecker m_MapChecker;
 
 	char m_aServerAddressStr[256];
 
diff --git a/src/engine/server/server.cpp b/src/engine/server/server.cpp
index f1d2e6e1..f170b1c8 100644
--- a/src/engine/server/server.cpp
+++ b/src/engine/server/server.cpp
@@ -15,6 +15,7 @@
 #include <engine/shared/config.h>
 #include <engine/shared/datafile.h>
 #include <engine/shared/demo.h>
+#include <engine/shared/mapchecker.h>
 #include <engine/shared/network.h>
 #include <engine/shared/packer.h>
 #include <engine/shared/protocol.h>
@@ -1049,6 +1050,13 @@ int CServer::LoadMap(const char *pMapName)
 	/*df = datafile_load(buf);
 	if(!df)
 		return 0;*/
+
+	// check for valid standard map
+	if(!m_MapChecker.ReadAndValidateMap(Storage(), aBuf, IStorage::TYPE_ALL))
+	{
+		Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "mapchecker", "invalid standard map");
+		return 0;
+	}
 		
 	if(!m_pMap->Load(aBuf))
 		return 0;
diff --git a/src/engine/server/server.h b/src/engine/server/server.h
index 00c1c648..abd86f92 100644
--- a/src/engine/server/server.h
+++ b/src/engine/server/server.h
@@ -121,6 +121,7 @@ public:
 	
 	CDemoRecorder m_DemoRecorder;
 	CRegister m_Register;
+	CMapChecker m_MapChecker;
 	
 	CServer();
 	
diff --git a/src/engine/shared/datafile.cpp b/src/engine/shared/datafile.cpp
index 74583ab8..74936ea0 100644
--- a/src/engine/shared/datafile.cpp
+++ b/src/engine/shared/datafile.cpp
@@ -222,6 +222,32 @@ bool CDataFileReader::Open(class IStorage *pStorage, const char *pFilename, int
 	return true;
 }
 
+bool CDataFileReader::GetCrcSize(class IStorage *pStorage, const char *pFilename, int StorageType, unsigned *pCrc, unsigned *pSize)
+{
+	IOHANDLE File = pStorage->OpenFile(pFilename, IOFLAG_READ, StorageType);
+	if(!File)
+		return false;
+	
+	// get crc and size
+	unsigned Crc = 0;
+	unsigned Size = 0;
+	unsigned char aBuffer[64*1024];
+	while(1)
+	{
+		unsigned Bytes = io_read(File, aBuffer, sizeof(aBuffer));
+		if(Bytes <= 0)
+			break;
+		Crc = crc32(Crc, aBuffer, Bytes); // ignore_convention
+		Size += Bytes;
+	}
+	
+	io_close(File);
+
+	*pCrc = Crc;
+	*pSize = Size;
+	return true;
+}
+
 int CDataFileReader::NumData()
 {
 	if(!m_pDataFile) { return 0; }
diff --git a/src/engine/shared/datafile.h b/src/engine/shared/datafile.h
index ce7b11aa..15bed033 100644
--- a/src/engine/shared/datafile.h
+++ b/src/engine/shared/datafile.h
@@ -16,6 +16,8 @@ public:
 	
 	bool Open(class IStorage *pStorage, const char *pFilename, int StorageType);
 	bool Close();
+
+	static bool GetCrcSize(class IStorage *pStorage, const char *pFilename, int StorageType, unsigned *pCrc, unsigned *pSize);
 	
 	void *GetData(int Index);
 	void *GetDataSwapped(int Index); // makes sure that the data is 32bit LE ints when saved
diff --git a/src/engine/shared/mapchecker.cpp b/src/engine/shared/mapchecker.cpp
new file mode 100644
index 00000000..dec4271d
--- /dev/null
+++ b/src/engine/shared/mapchecker.cpp
@@ -0,0 +1,106 @@
+/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
+/* If you are missing that file, acquire a complete release at teeworlds.com.                */
+#include <base/math.h>
+#include <base/system.h>
+
+#include <engine/storage.h>
+
+#include <versionsrv/versionsrv.h>
+
+#include "datafile.h"
+#include "memheap.h"
+#include "mapchecker.h"
+
+CMapChecker::CMapChecker()
+{
+	Init();
+	SetDefaults();
+}
+
+void CMapChecker::Init()
+{
+	m_Whitelist.Reset();
+	m_pFirst = 0;
+	m_RemoveDefaultList = false;
+}
+
+void CMapChecker::SetDefaults()
+{
+	AddMaplist(s_aMapVersionList, s_NumMapVersionItems);
+	m_RemoveDefaultList = true;
+}
+
+void CMapChecker::AddMaplist(CMapVersion *pMaplist, int Num)
+{
+	if(m_RemoveDefaultList)
+		Init();
+
+	for(int i = 0; i < Num; ++i)
+	{
+		CWhitelistEntry *pEntry = (CWhitelistEntry *)m_Whitelist.Allocate(sizeof(CWhitelistEntry));
+		pEntry->m_pNext = m_pFirst;
+		m_pFirst = pEntry;
+
+		str_copy(pEntry->m_aMapName, pMaplist[i].m_aName, sizeof(pEntry->m_aMapName));
+		pEntry->m_MapCrc = (pMaplist[i].m_aCrc[0]<<24) | (pMaplist[i].m_aCrc[1]<<16) | (pMaplist[i].m_aCrc[2]<<8) | pMaplist[i].m_aCrc[3]; 
+		pEntry->m_MapSize = (pMaplist[i].m_aSize[0]<<24) | (pMaplist[i].m_aSize[1]<<16) | (pMaplist[i].m_aSize[2]<<8) | pMaplist[i].m_aSize[3];
+	}
+}
+
+bool CMapChecker::IsMapValid(const char *pMapName, unsigned MapCrc, unsigned MapSize)
+{
+	bool StandardMap = false;
+	for(CWhitelistEntry *pCurrent = m_pFirst; pCurrent; pCurrent = pCurrent->m_pNext)
+	{
+		if(str_comp(pCurrent->m_aMapName, pMapName) == 0)
+		{
+			StandardMap = true;
+			if(pCurrent->m_MapCrc == MapCrc && pCurrent->m_MapSize == MapSize)
+				return true;
+		}
+	}
+	return StandardMap?false:true;
+}
+
+bool CMapChecker::ReadAndValidateMap(IStorage *pStorage, const char *pFilename, int StorageType)
+{
+	bool LoadedMapInfo = false;
+	bool StandardMap = false;
+	unsigned MapCrc = 0;
+	unsigned MapSize = 0;
+
+	// extract map name
+	char aMapName[MAX_MAP_LENGTH];
+	const char *pExtractedName = pFilename;
+	const char *pEnd = 0;
+	for(const char *pSrc = pFilename; *pSrc; ++pSrc)
+	{
+		if(*pSrc == '/' || *pSrc == '\\')
+			pExtractedName = pSrc+1;
+		else if(*pSrc == '.')
+			pEnd = pSrc;
+	}
+	int Length = (int)(pEnd - pExtractedName);
+	if(Length <= 0 || Length >= MAX_MAP_LENGTH)
+		return true;
+	str_copy(aMapName, pExtractedName, min((int)MAX_MAP_LENGTH, (int)(pEnd-pExtractedName+1)));
+
+	// check for valid map
+	for(CWhitelistEntry *pCurrent = m_pFirst; pCurrent; pCurrent = pCurrent->m_pNext)
+	{
+		if(str_comp(pCurrent->m_aMapName, aMapName) == 0)
+		{
+			StandardMap = true;
+			if(!LoadedMapInfo)
+			{
+				if(!CDataFileReader::GetCrcSize(pStorage, pFilename, StorageType, &MapCrc, &MapSize))
+					return true;
+				LoadedMapInfo = true;
+			}
+
+			if(pCurrent->m_MapCrc == MapCrc && pCurrent->m_MapSize == MapSize)
+				return true;
+		}
+	}
+	return StandardMap?false:true;
+}
diff --git a/src/engine/shared/mapchecker.h b/src/engine/shared/mapchecker.h
new file mode 100644
index 00000000..0d4332d9
--- /dev/null
+++ b/src/engine/shared/mapchecker.h
@@ -0,0 +1,38 @@
+/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
+/* If you are missing that file, acquire a complete release at teeworlds.com.                */
+#ifndef ENGINE_SHARED_MAPCHECKER_H
+#define ENGINE_SHARED_MAPCHECKER_H
+
+#include "memheap.h"
+
+class CMapChecker
+{
+	enum
+	{
+		MAX_MAP_LENGTH=8,
+	};
+
+	struct CWhitelistEntry
+	{
+		char m_aMapName[MAX_MAP_LENGTH];
+		unsigned m_MapCrc;
+		unsigned m_MapSize;
+		CWhitelistEntry *m_pNext;
+	};
+	
+	class CHeap m_Whitelist;
+	CWhitelistEntry *m_pFirst;
+
+	bool m_RemoveDefaultList;
+
+	void Init();
+	void SetDefaults();
+
+public:
+	CMapChecker();
+	void AddMaplist(class CMapVersion *pMaplist, int Num);
+	bool IsMapValid(const char *pMapName, unsigned MapCrc, unsigned MapSize);
+	bool ReadAndValidateMap(class IStorage *pStorage, const char *pFilename, int StorageType);
+};
+
+#endif