khanat-opennel-code/code/ryzom/client/src/permanent_ban.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "stdpch.h"
#include "permanent_ban.h"
#include "nel/misc/file.h"
#include "nel/misc/path.h"
#include "nel/misc/big_file.h"
#include "nel/misc/random.h"


using namespace NLMISC;


#define REGKEY_RYZOM_PATH "Software\\Nevrax\\ryzom"
#define REGKEY_PERMANENT_BAN "PB"


//************************************************************
static void setPermanentBanRegistryKey(bool on)
{
#ifndef NL_OS_WINDOWS
	nlinfo("Not implemented");
#else
	HKEY hKey;
	if (RegCreateKey(HKEY_CURRENT_USER, REGKEY_RYZOM_PATH, &hKey)==ERROR_SUCCESS)
	{
		DWORD permanentBan = on ? 1 : 0;
		LONG result = RegSetValueEx(hKey, REGKEY_PERMANENT_BAN, 0, REG_DWORD, (LPBYTE)&permanentBan, 4);
		if (result != ERROR_SUCCESS)
		{
			nlwarning("pb key not created");
		}
	}
	else
	{
		nlwarning("pb key not created");
	}
#endif
}

//************************************************************
static bool getPermanentBanRegistryKey()
{
#ifndef NL_OS_WINDOWS
	return false; // not implemented
#else
	HKEY hKey;
	if (RegOpenKeyEx(HKEY_CURRENT_USER, REGKEY_RYZOM_PATH, 0, KEY_READ, &hKey)==ERROR_SUCCESS)
	{
		DWORD permanentBan;
		DWORD type;
		DWORD dataSize = sizeof(DWORD);
		RegQueryValueEx (hKey, REGKEY_PERMANENT_BAN, 0, &type, (LPBYTE)&permanentBan, &dataSize);
		if (type == REG_DWORD && dataSize == sizeof(DWORD))
		{
			return permanentBan != 0;
		}
	}
	return false;
#endif
}

//***********************************************************
static void setPermanentBanFileMarker(const std::string &path, bool on)
{
	if (on)
	{
		try
		{
			// simply touch a file
			COFile f(path);
			#ifdef NL_OS_WINDOWS
				SetFileAttributes(path.c_str(), FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
			#endif
		}
		catch(EStream &e)
		{
			nlinfo(e.what());
		}
	}
	else
	{
		CFile::deleteFile(path);
	}
}

//***********************************************************
static bool getPermanentBanFileMarker(const std::string &path)
{
	return CFile::isExists(path);
}

#define PERMANENT_BAN_FILE0 "c:\\3289763c1ecd044e"
#define PERMANENT_BAN_FILE1 "78d0732e50bf2bbd"

//************************************************************
void setPermanentBanMarkers(bool on)
{
	setPermanentBanRegistryKey(on);
	setPermanentBanFileMarker(PERMANENT_BAN_FILE0, on);
	setPermanentBanFileMarker(CPath::getWindowsDirectory() + PERMANENT_BAN_FILE1, on);
}


//************************************************************
bool testPermanentBanMarkers()
{
	/*#ifndef NL_OS_WINDOWS
		nlinfo("Not implemented");
		return false;
	#else
		if (getPermanentBanRegistryKey()) return true;
		if (getPermanentBanFileMarker(PERMANENT_BAN_FILE0)) return true;
		if (getPermanentBanFileMarker(CPath::getWindowsDirectory() + PERMANENT_BAN_FILE1)) return true;
	#endif
	return false;
	*/
	return false;
}


// mark a bnp file without corrupting its datas (this force the patch to be applied the next time the client is launched, thus delaying the trouble maker)
static void markBNPFile(std::string &path)
{
	CRandom rnd;
	rnd.srand((sint32) CTime::getLocalTime());

	uint32 nFileSize=CFile::getFileSize(path);
	if (!nFileSize) return;
	FILE *f = fopen(path.c_str(), "rb+");
	if (!f) return;
// Result
	if (nlfseek64 (f, nFileSize-4, SEEK_SET) != 0)
	{
		fclose (f);
		return;
	}

	uint32 nOffsetFromBegining;
	if (fread (&nOffsetFromBegining, sizeof(uint32), 1, f) != 1)
	{
		fclose (f);
		return;
	}

	if (nlfseek64 (f, nOffsetFromBegining, SEEK_SET) != 0)
	{
		fclose (f);
		return;
	}

	// Read the file count
	uint32 nNbFile;
	if (fread (&nNbFile, sizeof(uint32), 1, f) != 1)
	{
		fclose (f);
		return;
	}
	for (uint32 i = 0; i < nNbFile; ++i)
	{
		char FileName[MAX_PATH];
		uint8 nStringSize;
		if (fread (&nStringSize, 1, 1, f) != 1)
		{
			fclose(f);
			return;
		}

		sint64 currPos = nlftell64(f);
		if (currPos < 0)
		{
			fclose(f);
			return;
		}
		if (fread (FileName, 1, nStringSize, f) != nStringSize)
		{
			fclose (f);
			return;
		}

		FileName[nStringSize] = 0;

		for(uint k = 0; k < nStringSize; ++k)
		{
			if (rnd.rand() & 1) FileName[k] = toupper(FileName[k]);
			else FileName[k] = tolower(FileName[k]);
		}


		if (nlfseek64 (f, currPos, SEEK_SET) != 0)
		{
			fclose (f);
			return;
		}


		// write shuffled version
		if (fwrite(FileName, 1, nStringSize, f) != nStringSize)
		{
			fclose(f);
			return;
		}
		fflush(f);

		uint32 nFileSize2;
		if (fread (&nFileSize2, sizeof(uint32), 1, f) != 1)
		{
			fclose (f);
			return;
		}

		uint32 nFilePos;
		if (fread (&nFilePos, sizeof(uint32), 1, f) != 1)
		{
			fclose (f);
			return;
		}
	}

	fclose (f);
}

//************************************************************
void applyPermanentBanPunishment()
{
	// go in the data directory & touch all bnp files so that the client should repatch all its datas
	std::vector<std::string> bigFilePaths;
	CBigFile::getInstance().getBigFilePaths(bigFilePaths);
	for(uint k = 0; k < bigFilePaths.size(); ++k)
	{
		markBNPFile(bigFilePaths[k]);
	}
}