UTANBanManager104.MutUTAN

/******************************************************************************
UTAN Ban Manager v1.04                                                    <br/>
Coded by Wormbo, Copyright © 2003-2006 UTAN, 2009-2011 Wormbo
******************************************************************************/

class MutUTAN extends Mutator config;


//=============================================================================
// Structs
//=============================================================================

struct CIDR {
	var int IP;
	var byte Prefix;
};

struct TListEntry {
	var int ID;
	var GUID GUID;
	var CIDR IP;
	var bool bIsRemote;
	var bool bIsExclude;
	var bool bIsCheater;
	var bool bIsDisabled;
	var int HashNext;
};

struct TQueuedPlayerData {
	var string PlayerName;
	var string PlayerGUID;
	var string PlayerIP;
};

struct IPBan {
	var int Index;
	var CIDR IP;
};


//=============================================================================
// Enums
//=============================================================================

enum ELogLevel {
	LL_Status,
	LL_DumpBans,
	LL_Update,
	LL_Message,
	LL_Warning,
	LL_Kick,
	LL_ExternalKick,
	LL_Error
};


//=============================================================================
// Configuration
//=============================================================================

var private config string BanDatabaseName;
var private config bool bForceCreateDatabaseFile;
var private config bool bStoreDatabaseInINI;
var private config string LogFileNameMask;
var private config string LogFileTimeStamp;
var private config bool bShowInServerName;
var private config string AppealContactInfo;

var private config string MasterserverHost;
var private config int    MasterserverPort;
var private config string MasterserverAuthUser;
var private config string MasterserverAuthPass;
var private config string MasterserverUpdateURL;
var private config string MasterserverTrackURL;
var private config bool   bTrackPlayerJoins;
var private config bool   bSendNamesAsUTF8;
var private config bool   bGetFreshList;


//=============================================================================
// Localization
//=============================================================================

var localized string lblBanDatabaseName;
var localized string lblForceCreateDatabaseFile;
var localized string lblStoreDatabaseInINI;
var localized string lblLogFileNameMask;
var localized string lblLogFileTimeStamp;
var localized string lblShowInServerName;
var localized string lblAppealContactInfo;

var localized string lblMasterserverHost;
var localized string lblMasterserverPort;
var localized string lblMasterserverAuthUser;
var localized string lblMasterserverAuthPass;
var localized string lblMasterserverUpdateURL;
var localized string lblMasterserverTrackURL;
var localized string lblTrackPlayerJoins;
var localized string lblSendNamesAsUTF8;
var localized string lblGetFreshList;


var localized string descBanDatabaseName;
var localized string descForceCreateDatabaseFile;
var localized string descStoreDatabaseInINI;
var localized string descLogFileNameMask;
var localized string descLogFileTimeStamp;
var localized string descShowInServerName;
var localized string descAppealContactInfo;

var localized string descMasterserverHost;
var localized string descMasterserverPort;
var localized string descMasterserverAuthUser;
var localized string descMasterserverAuthPass;
var localized string descMasterserverUpdateURL;
var localized string descMasterserverTrackURL;
var localized string descTrackPlayerJoins;
var localized string descSendNamesAsUTF8;
var localized string descGetFreshList;


var private localized string BanMessage, BanMessageIP, BanMessageGUID;


//=============================================================================
// Variables
//=============================================================================

var(UTAN) noexport const editconst string Build;
var(UTAN) noexport const editconst string Copyright;

const HASH_SIZE = 2048;

/** A default ban entry for the UT2004 demo GUID. */
var const editconst TListEntry DefaultBan;

var UTANBanDatabase BanDB;
var UTANUplink Uplink;
var array<TListEntry> BanList;
var array<PlayerController> Players, PendingKicks;
var int GUIDsHash[HASH_SIZE], ExcludesHash[HASH_SIZE];
var array<IPBan> BannedIPs;

var array<TQueuedPlayerData> QueuedTrackReports;

var FileLog LogFile;
var array<string> DelayedLogs;
var float LastLogSaveTime;
var float LastLogWriteTime;
var bool bLogFileSaved;
var bool bLogFileOpened;
var string CurrentLogFileName;
var string MatchStartTime;
var bool bReceivedInitialUpdate;


/**
Initialize the local ban database and query the UTAN database for updates.
*/
event PostBeginPlay()
{
	local int i, n;
	local int Low, Middle, High;
	//local string UpdateURL;
	local bool bInitializeNewDB;
	local TListEntry NewEntry;

	Super.PostBeginPlay();

	log(" ", 'UTAN');
	log("==================================================", 'UTAN');
	log(""@GetVersionString(), 'UTAN');
	log(""@Copyright, 'UTAN');
	log("==================================================", 'UTAN');

	if ( Level.NetMode == NM_Standalone ) {
		log("The UTAN Ban Manager must be run on a server.", 'Warning');
		Destroy();
		return;
	}

	if ( BanDatabaseName == "" ) {
		BanDatabaseName = "UTAN104BanDatabase";
		LogLine("No ban database file name specified, will use '"$BanDatabaseName$"'", LL_Warning);
		bForceCreateDatabaseFile = True;
		SaveConfig();
	}

	CurrentLogFileName = FillMaskValues(LogFileNameMask);
	MatchStartTime = FillMaskValues("%y-%m-%d, %h:%n:%s");

	log(" * Logging to" @ Eval(CurrentLogFileName == "", "main log file", CurrentLogFileName), 'UTAN');

	// check for UTAN query handler
	for (i = 0; i < class'UTServerAdmin'.default.QueryHandlerClasses.Length; ++i) {
		if (class'UTServerAdmin'.default.QueryHandlerClasses[i] ~= string(class'UTANQueryHandler'))
			break;
	}
	if (i == class'UTServerAdmin'.default.QueryHandlerClasses.Length) {
		log(" * Adding UTAN webadmin query handler...", 'UTAN');
		class'UTServerAdmin'.default.QueryHandlerClasses[class'UTServerAdmin'.default.QueryHandlerClasses.Length] = string(class'UTANQueryHandler');
	}

	if (Level.Game.GameReplicationInfo != None) {
		if (bShowInServerName && InStr(Level.Game.GameReplicationInfo.ServerName, "[UTAN]") == -1) {
			// server name does not include the UTAN tag, add it in front of the name
			Level.Game.GameReplicationInfo.ServerName = "[UTAN]" @ Level.Game.GameReplicationInfo.ServerName;
			Level.Game.GameReplicationInfo.SaveConfig();
		}
		else if (!bShowInServerName && InStr(Level.Game.GameReplicationInfo.ServerName, "[UTAN]") != -1) {
			// server name still includes the UTAN tag
			Level.Game.GameReplicationInfo.ServerName = Repl(Level.Game.GameReplicationInfo.ServerName, "[UTAN] ", "");
			Level.Game.GameReplicationInfo.ServerName = Repl(Level.Game.GameReplicationInfo.ServerName, " [UTAN]", "");
			Level.Game.GameReplicationInfo.ServerName = Repl(Level.Game.GameReplicationInfo.ServerName, "[UTAN]", "");
			Level.Game.GameReplicationInfo.SaveConfig();
		}
	}
	else {
		if (bShowInServerName && InStr(class'GameReplicationInfo'.default.ServerName, "[UTAN]") == -1) {
			// server name does not include the UTAN tag, add it in front of the name
			class'GameReplicationInfo'.default.ServerName = "[UTAN]" @ class'GameReplicationInfo'.default.ServerName;
			class'GameReplicationInfo'.static.StaticSaveConfig();
		}
		else if (!bShowInServerName && InStr(class'GameReplicationInfo'.default.ServerName, "[UTAN]") != -1) {
			// server name still includes the UTAN tag
			class'GameReplicationInfo'.default.ServerName = Repl(class'GameReplicationInfo'.default.ServerName, "[UTAN] ", "");
			class'GameReplicationInfo'.default.ServerName = Repl(class'GameReplicationInfo'.default.ServerName, " [UTAN]", "");
			class'GameReplicationInfo'.default.ServerName = Repl(class'GameReplicationInfo'.default.ServerName, "[UTAN]", "");
			class'GameReplicationInfo'.static.StaticSaveConfig();
		}
	}

	// load or create the UTAN ban database
	log(" * Ban database name:" @ BanDatabaseName $ Eval(bStoreDatabaseInINI, ".ini", ".uvx"), 'UTAN');
	if (bStoreDatabaseInINI) {
		// ensure no default values set
		if (class'BanDatabase'.default.LastUpdate != 0 || class'BanDatabase'.default.Entry.Length > 0) {
			class'BanDatabase'.default.LastUpdate = 0;
			class'BanDatabase'.default.Entry.Length = 0;
		}
		// PerObjectConfig objects get their INI name from their Outer if declared within a class other than Object
		BanDB = new(None, BanDatabaseName) class'UTANBanDatabase';
		BanDB = new(BanDB, "UTAN") class'BanDatabase';
		if (BanDB.LastUpdate == 0 && BanDB.GetNumEntries() == 0 && bForceCreateDatabaseFile) {
			bInitializeNewDB = True;
		}
	}
	else {
		BanDB = Level.Game.LoadDataObject(class'UTANBanDatabase', "UTANBanDatabase", BanDatabaseName);
		if ( BanDB == None ) {
			BanDB = Level.Game.CreateDataObject(class'UTANBanDatabase', "UTANBanDatabase", BanDatabaseName);
			if (bForceCreateDatabaseFile) {
				bInitializeNewDB = True;
			}
			else {
				LogLine("Could not find ban database file. Check the database name or force creating a new database file.", LL_Warning);
			}
		}
	}
	if (BanDB != None) {
		if (bInitializeNewDB) {
			// initialize the empty DB
			LogLine("Initializing new ban database file...", LL_Status);
			BanDB.ClearEntries();
			// UTAN's UT2004 demo GUID ban:
			BanDB.AddEntry(DefaultBan);
			BanDB.LastUpdate = 1;
			if (!BanDB.SaveDatabase(Level, BanDatabaseName)) {
				LogLine("Error saving ban database file. Please make sure the Saves directory exists and your server has write permissions for it.", LL_Error);
			}
			else {
				bForceCreateDatabaseFile = False;
				bGetFreshList = True; // LastUpdate was generated locally, so resync with server if using remote updates
				SaveConfig();
			}
		}
		n = BanDB.GetNumEntries();
		for (i = 0; i < n; ++i) {
			NewEntry = BanDB.GetEntry(i);

			// find insert index
			Low = 0;
			High = BanList.Length;
			while (Low < High) {
				Middle = (High + Low) / 2; // the engine would crash long before this overflows
				if (BanList[Middle] < NewEntry)
					Low = Middle + 1;
				else
					High = Middle;
			}
			// found insert location
			BanList.Insert(Low, 1);
			BanList[Low] = NewEntry;
		}
		for (i = 0; i < BanList.Length; ++i) {
			HashBan(i);
		}
		CompactIPBans();

		if (BanList.Length > 0)
			LogLine("Local UTAN ban database contains" @ BanList.Length @ Plural("ban", BanList.Length), LL_Status);
		else
			LogLine("Local UTAN ban database is empty", LL_Status);
	}
	else
		LogLine("Failed to initialize the local UTAN ban database!", LL_Error);

	if (MasterserverHost == "") {
		LogLine("No masterserver host configured, won't check for remote updates.", LL_Status);
	}
	else if (MasterserverPort == 0 || MasterserverPort != (MasterserverPort & 0xffff)) {
		LogLine("Invalid masterserver port number specified: " $ MasterserverPort, LL_Error);
	}
	else {
		if (bTrackPlayerJoins && MasterserverTrackURL == "") {
			LogLine("No masterserver tracking URL specified, won't send tracking data.", LL_Error);
			bTrackPlayerJoins = False;
		}
		if (Left(MasterserverTrackURL, 1) != "/")
			MasterserverTrackURL = "/" $ MasterserverTrackURL;

		if (MasterserverUpdateURL != "") {
			if (Left(MasterserverUpdateURL, 1) != "/")
				MasterserverUpdateURL = "/" $ MasterserverUpdateURL;

			Uplink = Spawn(class'UTANUplink', Self);
			Uplink.AuthMethod = AM_Basic;

			Uplink.setFormData("ServerIP", GetServerIP());
			Uplink.setFormData("ServerPort", Level.Game.GetServerPort());
			Uplink.setFormData("GameMode", Level.Game.Name);
			Uplink.setFormData("MapName", Outer);
			if (!bGetFreshList && BanDB != None && BanDB.LastUpdate > 0)
				Uplink.setFormData("LastUpdate", BanDB.LastUpdate);
			/*
			UpdateURL = Repl(MasterserverUpdateURL, "%s", GetServerIP());
			UpdateURL = Repl(UpdateURL, "%p", Level.Game.GetServerPort());
			UpdateURL = Repl(UpdateURL, "%m", URLEncode(Outer, bSendNamesAsUTF8));
			UpdateURL = Repl(UpdateURL, "%g", URLEncode(Level.Game.Name, bSendNamesAsUTF8));
			if (!bGetFreshList && BanDB != None && BanDB.LastUpdate > 0)
				UpdateURL = Repl(UpdateURL, "%l", BanDB.LastUpdate);
			else
				UpdateURL = Repl(UpdateURL, "%l", "");
			*/
			if (MasterserverAuthUser != "" && MasterserverAuthPass != "") {
				LogLine("Contacting '" $ MasterserverAuthUser $ "@" $ MasterserverHost $ ":" $ MasterserverPort $ "' to check for ban updates...", LL_Status);
				Uplink.post("http://" $ URLEncode(MasterserverAuthUser, bSendNamesAsUTF8) $ ":" $ URLEncode(MasterserverAuthPass, bSendNamesAsUTF8) $ "@" $ MasterserverHost $ ":" $ MasterserverPort $ MasterserverUpdateURL);
			}
			else {
				LogLine("Contacting '" $ MasterserverHost $ ":" $ MasterserverPort $ "' to check for ban updates...", LL_Status);
				Uplink.post("http://" $ MasterserverHost $ ":" $ MasterserverPort $ MasterserverUpdateURL);
			}
		}
		else if (bTrackPlayerJoins) {
			Uplink = Spawn(class'UTANUplink', Self);
			Uplink.AuthMethod = AM_Basic;
		}
	}

	log(" * Banned players are instructed to '" $ Repl(AppealContactInfo, "%%admin%%", GetAdminContact()) $ "'", 'UTAN');
	log("   for more information regarding their ban", 'UTAN');
	SetTimer(0.5, true);
	log("", 'UTAN');
}


/**
Adds the specified ban entry to the corresponding quick-access lists.
*/
function HashBan(int Index)
{
	local int Hash, Low, High, Middle;
	local GUID NullGUID;

	if (BanList[Index].bIsExclude) {
		// hash exclude
		Hash = HashGUID(BanList[Index].GUID);
		BanList[Index].HashNext = ExcludesHash[Hash];
		ExcludesHash[Hash] = ~Index;
		return; // done, IP range will be compared separately on GUID match
	}
	if (BanList[Index].GUID != NullGUID) {
		// hash GUID ban
		Hash = HashGUID(BanList[Index].GUID);
		BanList[Index].HashNext = GUIDsHash[Hash];
		GUIDsHash[Hash] = ~Index;
	}
	if (BanList[Index].IP.IP != 0 && !BanList[Index].bIsDisabled) {
		// add to sorted list of banned IP ranges
		High = BannedIPs.Length;
		while (Low < High) {
			Middle = (High + Low) / 2; // the engine would crash long before this overflows
			if (<BannedIPs[Middle].IP < <BanList[Index].IP)
				Low = Middle + 1;
			else
				High = Middle;
		}
		// found insert location (don't care for duplicates at this point)
		BannedIPs.Insert(Low, 1);
		BannedIPs[Low].IP = BanList[Index].IP;
		BannedIPs[Low].Index = Index;
	}
}


/**
Removes redundant IP bans from the quick-access list.
*/
function CompactIPBans()
{
	local int i;

	// only makes sense if more than one range is in the list
	if (BannedIPs.Length > 1) {
		i = 0;
		do {
			/*
			Due to CIDR notation, ranges can't overlap partially. Thus only
			A in B and B in A needs to be checked, and equality is covered
			automatically by the first of these checks.
			*/
			if (BannedIPs[i].IP ~= BannedIPs[i+1].IP) {
				// next range is included in or equal to this range
				BannedIPs.Remove(i+1, 1);
			}
			else if (BannedIPs[i+1].IP ~= BannedIPs[i].IP) {
				// next range includes this range
				BannedIPs.Remove(i, 1);
			}
			else {
				// ranges are not redundant
				i++;
			}
		} until (i >= BannedIPs.Length - 1);
	}
	/*
	for (i = 0; i < Banlist.Length; i++)
		log("Ban"@i@Banlist[i].ID@Banlist[i].IP.IP@Banlist[i].IP.Prefix);

	for (i = 0; i < BannedIPs.Length; i++)
		log("Banned IP"@i@BannedIPs[i].Index@BannedIPs[i].IP.IP@BannedIPs[i].IP.Prefix);
	*/
}


/**
Return the ban list entry covering the specified IP, or -1 if the IP isn't banned.
*/
function int FindIPBan(int IP)
{
	local int Low, Middle, High;

	// find in sorted list of banned IP ranges
	High = BannedIPs.Length;
	while (Low < High) {
		Middle = (High + Low) / 2; // the engine would crash long before this overflows
		if (<BannedIPs[Middle].IP < IP)
			Low = Middle + 1;
		else
			High = Middle;
	}
	if (Low < BannedIPs.Length && BannedIPs[Low].IP ~= IP)
		return BannedIPs[Low].Index;
	if (Low > 0 && BannedIPs[Low-1].IP ~= IP)
		return BannedIPs[Low-1].Index;
	return -1;
}


/**
Process the data received from the UTAN database.
*/
function ProcessDatabaseUpdate()
{
	local int i;
	local int NumGUIDs, NumIPs, NumExcludes;
	local CIDR NullCIDR;
	local GUID NullGUID;

	if (!Uplink.bChanged) {
		LogLine("Update did not change anything, ban list still contains" @ NumGUIDs @ Plural("banned GUID", NumGUIDs) $ "," @ NumIPs @ Plural("banned IP range", NumIPs) @ "and" @ NumExcludes @ Plural("ban exclude", NumExcludes), LL_Status);
		bReceivedInitialUpdate = True;
		return;
	}

	BanList = Uplink.NewBanList;
	if (BanDB != None) {
		if (Uplink.bCleared && bGetFreshList) {
			bGetFreshList = False;
			default.bGetFreshList = False;
			Class.static.StaticSaveConfig();
		}
		BanDB.LastUpdate = Uplink.LastUpdate;
		BanDB.ClearEntries();
		for (i = 0; i < BanList.Length; ++i)
			BanDB.AddEntry(BanList[i]);
		if (!BanDB.SaveDatabase(Level, BanDatabaseName))
			LogLine("Failed to save local UTAN ban database. Ban data will be lost at mapchange!", LL_Warning);
	}
	else {
		LogLine("Local UTAN ban database not initialized. Ban data will be lost at mapchange!", LL_Warning);
	}

	// reset hash tables
	for (i = 0; i < HASH_SIZE; ++i) {
		GUIDsHash[i] = 0;
		ExcludesHash[i] = 0;
	}
	BannedIPs.Length = 0;

	NumExcludes = 0;
	NumGUIDs    = 0;
	NumIPs      = 0;
	BannedIPs.Length = 0;
	for (i = 0; i < BanList.Length; ++i) {
		BanList[i].HashNext = 0;
		HashBan(i);

		// count entries
		if (BanList[i].bIsExclude)
			NumExcludes++;
		else {
			if (BanList[i].GUID != NullGUID)
				NumGUIDs++;
			if (BanList[i].IP != NullCIDR)
				NumIPs++;
		}
	}
	CompactIPBans();
	LogLine("Updated ban list now contains" @ NumGUIDs @ Plural("banned GUID", NumGUIDs) $ "," @ NumIPs @ Plural("banned IP range", NumIPs) @ "and" @ NumExcludes @ Plural("ban exclude", NumExcludes), LL_Status);

	// rescan players in case of update
	RecheckForUTANBans();
	bReceivedInitialUpdate = True;
}


function string GetAdminContact()
{
	local string AdminName;
	local string AdminEmail;

	AdminName = class'GameReplicationInfo'.default.AdminName;
	AdminEmail = class'GameReplicationInfo'.default.AdminEmail;
	if (AdminEmail != "") {
		if (AdminName != "")
			return AdminName $ " <" $ AdminEmail $ ">";
		return AdminEmail;
	}
	else if (AdminName != "")
		return AdminName;
	return "the server admin";
}

/**
From wUtils.wTime
See http://wiki.beyondunreal.com/Legacy:WUtils
*/
/*static final function int mktime(int year, int mon, int day, int hour, int min, int sec)
{
	mon -= 2;
	if (mon <= 0) {	/* 1..12 -> 11,12,1..10 */
		mon += 12;	/* Puts Feb last since it has leap day */
		year -= 1;
	}
	return (((
		(year/4 - year/100 + year/400 + 367*mon/12 + day) +
	   year*365 - 719499
	  )*24 + (hour-1) /* now have hours */
	 )*60 + min  /* now have minutes */
	)*60 + sec; /* finally seconds */
}*/


/**
Checks for new players.
*/
event Tick(float DeltaTime)
{
	local int i;
	local Controller C;

	for (C = Level.ControllerList; C != None; C = C.NextController) {
		if (PlayerController(C) != None && NetConnection(PlayerController(C).Player) != None) {
			for (i = 0; i < Players.Length; i++) {
				if (Players[i] == C)
					break;
				if (Players[i] == None)
					Players.Remove(i--, 1);
			}
			if (i == Players.Length) {
				Players[i] = PlayerController(C);
				PostLogin(PlayerController(C));
			}
		}
	}

	if ( !bLogFileSaved && LogFile != None && LastLogWriteTime >= LastLogSaveTime && LastLogSaveTime + 5 < Level.TimeSeconds && LastLogWriteTime < Level.TimeSeconds ) {
		LogFile.CloseLog();
		if ( CurrentLogFileName != "" )
			bLogFileSaved = True;
		LastLogSaveTime = Level.TimeSeconds;
	}
}


/**
Called after a player has connected to the server.
*/
function PostLogin(PlayerController Login)
{
	local int i;

	if ( Login == None )
		return;

	if (bTrackPlayerJoins) {
		i = QueuedTrackReports.Length;
		QueuedTrackReports.Length = i + 1;
		QueuedTrackReports[i].PlayerName = StripInvalidChars(Login.GetHumanReadableName());
		QueuedTrackReports[i].PlayerGUID = Login.GetPlayerIDHash();
		QueuedTrackReports[i].PlayerIP = Login.GetPlayerNetworkAddress();
		QueuedTrackReports[i].PlayerIP = Left(QueuedTrackReports[i].PlayerIP, InStr(QueuedTrackReports[i].PlayerIP, ":"));
	}
	CheckForUTANBan(Login);
}


/**
Repeats the ban check for all players already verified before.
*/
function RecheckForUTANBans()
{
	local int i;

	for (i = 0; i < Players.Length; i++) {
		if (Players[i] == None || Players[i].bPendingDelete || NetConnection(Players[i].Player) == None)
			Players.Remove(i--, 1);
		else
			CheckForUTANBan(Players[i]);
	}
}


/**
Check, whether the player is banned.
*/
private function CheckForUTANBan(PlayerController Login)
{
	local int i, IP, hGUID;
	local GUID PlayerGUID;
	local string PlayerID, PlayerIP, PlayerName;
	local bool bIPBan;
	local string Message;

	PlayerName = StripInvalidChars(Login.GetHumanReadableName());
	PlayerID = Login.GetPlayerIDHash();
	PlayerIP = Login.GetPlayerNetworkAddress();
	PlayerIP = Left(PlayerIP, InStr(PlayerIP, ":"));

	PlayerGUID = StringToGUID(PlayerID);
	IP = StringToIP(PlayerIP);
	hGUID = HashGUID(PlayerGUID);

	// check for excludes first
	for (i = ~ExcludesHash[hGUID]; i != -1; i = ~BanList[i].HashNext) {
		if (BanList[i].GUID == PlayerGUID && BanList[i].IP ~= IP && !BanList[i].bIsDisabled)
			return; // player matches exclude entry
	}

	for (i = ~GUIDsHash[hGUID]; i != -1; i = ~BanList[i].HashNext) {
		if (BanList[i].GUID == PlayerGUID && !BanList[i].bIsDisabled)
			break; // found GUID ban
	}
	if (i == -1) {
		i = FindIPBan(IP);
		bIPBan = True; // regardless whether it's actually banned; doesn't matter if not
	}

	if (i != -1) {
		LogLine(PlayerName @ "[" @ PlayerID @ "]" @ PlayerIP @ "- Matching UTAN BanID #" $ BanList[i].ID, LL_Kick);
		Message = Repl(BanMessage, "%%idtype%%", Eval(bIPBan, BanMessageIP, BanMessageGUID));
		Message = Repl(Message, "%%id%%", BanList[i].ID);
		Message = Repl(Message, "%%guid%%", PlayerID);
		Message = Repl(Message, "%%ip%%", PlayerIP);
		Message = Repl(Message, "%%contact%%", Repl(AppealContactInfo, "%%admin%%", GetAdminContact()));
		Login.ClientNetworkMessage("AC_Kicked", Message $ FriendlyName);

		// add session ban
		if ( (bIPBan || !Level.Game.AccessControl.bBanByID) && Level.Game.AccessControl.CheckIPPolicy(PlayerIP, True) == 0 )
			Level.Game.AccessControl.SessionIPPolicies[Level.Game.AccessControl.SessionIPPolicies.Length] = "DENY;" $ PlayerIP;
		if ( !bIPBan && Level.Game.AccessControl.CheckID(PlayerID) == 0 )
			Level.Game.AccessControl.SessionBannedIDs[Level.Game.AccessControl.SessionBannedIDs.Length] = PlayerID $ "|" $ PlayerName @ "(UTAN Ban #" $ BanList[i].ID $ ")";

		// notify mutators
		Level.Game.BaseMutator.Mutate("KickedBy UTAN" $ Chr(254) $ PlayerName $ Chr(254) $ "UTAN - Ban ID: " $ BanList[i].ID $ Chr(254) $ Eval(bIPBan, "IP", "GUID"), None);

		// kick the player
		PendingKicks[PendingKicks.Length] = Login;
	}
}


/**
Send pending track and kick reports and kick banned players.
*/
event Timer()
{
	local string PlayerName;
	local int i;

	while (PendingKicks.Length > 0) {
		if ( PendingKicks[0] != None )
			PendingKicks[0].Destroy();
		PendingKicks.Remove(0, 1);
	}

	if (QueuedTrackReports.Length > 0 && Uplink != None && Uplink.Ready()) {
		Uplink.ClearRequestData();
		Uplink.setFormData("ServerIP", GetServerIP());
		Uplink.setFormData("ServerPort", Level.Game.GetServerPort());

		do {
			if (bSendNamesAsUTF8)
				PlayerName = UTF8Encode(QueuedTrackReports[i].PlayerName);
			else
				PlayerName = QueuedTrackReports[i].PlayerName;
			Uplink.setFormData("PlayerName[]", PlayerName);
			Uplink.setFormData("PlayerGUID[]", QueuedTrackReports[i].PlayerGUID);
			Uplink.setFormData("PlayerIP[]", QueuedTrackReports[i].PlayerIP);
		} until (++i == QueuedTrackReports.Length);

		/*
		TrackURL = Repl(MasterserverTrackURL, "%s", GetServerIP());
		TrackURL = Repl(TrackURL, "%p", Level.Game.GetServerPort());
		TrackURL = Repl(TrackURL, "%n", URLEncode(QueuedTrackReports[0].PlayerName, bSendNamesAsUTF8));
		TrackURL = Repl(TrackURL, "%g", QueuedTrackReports[0].PlayerGUID);
		TrackURL = Repl(TrackURL, "%i", QueuedTrackReports[0].PlayerIP);
		*/

		if (MasterserverAuthUser != "" && MasterserverAuthPass != "") {
			LogLine("Contacting '" $ MasterserverAuthUser $ "@" $ MasterserverHost $ ":" $ MasterserverPort $ "' to send tracking data for " $ i @ Plural("player", i) $ "...", LL_Status);
			Uplink.post("http://" $ URLEncode(MasterserverAuthUser, bSendNamesAsUTF8) $ ":" $ URLEncode(MasterserverAuthPass, bSendNamesAsUTF8) $ "@" $ MasterserverHost $ ":" $ MasterserverPort $ MasterserverTrackURL);
		}
		else {
			LogLine("Contacting '" $ MasterserverHost $ ":" $ MasterserverPort $ "' to send tracking data for " $ i @ Plural("player", i) $ "...", LL_Status);
			Uplink.post("http://" $ MasterserverHost $ ":" $ MasterserverPort $ MasterserverTrackURL);
		}
		QueuedTrackReports.Length = 0;
	}
}


/**

*/
function Mutate(string MutateString, PlayerController Sender)
{
	local int i;
	local string Kicker, KickedPlayer;
	local UTANBanDatabase ExportBanDB;

	Super.Mutate(MutateString, Sender);

	if (Sender == None && Left(MutateString, 8) ~= "KickedBy") {
		// universal kick notice by mods like UTAN and Anti TCC
		MutateString = Mid(MutateString, 9);
		if (Divide(MutateString, Chr(254), Kicker, MutateString) && Kicker != "UTAN") {
			if (!Divide(MutateString, Chr(254), KickedPlayer, MutateString)) {
				KickedPlayer = MutateString;
				MutateString = "";
			}
			if (KickedPlayer != "")
				LogLine(Kicker @ "has kicked" @ KickedPlayer $ Eval(MutateString != "", " (" $ Repl(MutateString, Chr(254), " ") $ ")", ""), LL_ExternalKick);
		}
		return;
	}
	if ( Sender != None && MutateString ~= "DumpUTANBans" && (Level.NetMode == NM_Standalone || Level.Game.AccessControl != None && Level.Game.AccessControl.IsAdmin(Sender) || Level.Game.AccessControl == None && Sender.PlayerReplicationInfo.bAdmin) ) {
		LogLine("Dumping ban list with " $ BanList.Length $ " entries to ExportedBans.ini...", LL_Status);
		ExportBanDB = new(None, "ExportedBans") class'UTANBanDatabase';
		ExportBanDB = new(ExportBanDB, "Exported") class'BanDatabase';
		ExportBanDB.ClearEntries();
		ExportBanDB.LastUpdate = BanDB.LastUpdate;
		for (i = 0; i < BanList.Length; i++) {
			ExportBanDB.Addentry(BanList[i]);
		}
		ExportBanDB.SaveConfig();
	}
}


/**
Add the configuration options to the PlayInfo.
*/
static function FillPlayInfo(PlayInfo PlayInfo)
{
	Super.FillPlayInfo(PlayInfo);

	PlayInfo.AddSetting(default.FriendlyName, "BanDatabaseName",          default.lblBanDatabaseName,         255, 1, "Text", "40");
	PlayInfo.AddSetting(default.FriendlyName, "bForceCreateDatabaseFile", default.lblForceCreateDatabaseFile, 255, 2, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "bStoreDatabaseInINI",      default.lblStoreDatabaseInINI,      255, 2, "Check");

	PlayInfo.AddSetting(default.FriendlyName, "LogFileNameMask",  default.lblLogFileNameMask,  255, 3, "Text", "50");
	PlayInfo.AddSetting(default.FriendlyName, "LogFileTimeStamp", default.lblLogFileTimeStamp, 255, 4, "Text", "50");

	PlayInfo.AddSetting(default.FriendlyName, "bShowInServerName", default.lblShowInServerName,  255, 5, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "AppealContactInfo", default.lblAppealContactInfo, 255, 6, "Text", "100");


	PlayInfo.AddSetting(default.FriendlyName, "MasterserverHost", default.lblMasterserverHost, 255, 11, "Text", "40");
	PlayInfo.AddSetting(default.FriendlyName, "MasterserverPort", default.lblMasterserverPort, 255, 12, "Text", "6;1:65535");

	PlayInfo.AddSetting(default.FriendlyName, "MasterserverAuthUser", default.lblMasterserverAuthUser, 255, 13, "Text", "40");
	PlayInfo.AddSetting(default.FriendlyName, "MasterserverAuthPass", default.lblMasterserverAuthPass, 255, 14, "Text", "40");

	PlayInfo.AddSetting(default.FriendlyName, "MasterserverUpdateURL", default.lblMasterserverUpdateURL, 255, 15, "Text", "100");
	PlayInfo.AddSetting(default.FriendlyName, "MasterserverTrackURL",  default.lblMasterserverTrackURL,  255, 16, "Text", "100");
	PlayInfo.AddSetting(default.FriendlyName, "bTrackPlayerJoins",     default.lblTrackPlayerJoins,      255, 17, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "bGetFreshList",         default.lblGetFreshList,          255, 18, "Check");
}


/**
Returns a description for the specified configuration option.
*/
static event string GetDescriptionText(string PropName)
{
	switch (PropName) {
		case "BanDatabaseName":          return default.descBanDatabaseName;
		case "bForceCreateDatabaseFile": return default.descForceCreateDatabaseFile;
		case "bStoreDatabaseInINI":      return default.descStoreDatabaseInINI;
		case "LogFileNameMask":          return default.descLogFileNameMask;
		case "LogFileTimeStamp":         return default.descLogFileTimeStamp;
		case "bShowInServerName":        return default.descShowInServerName;
		case "AppealContactInfo":        return default.descAppealContactInfo;

		case "MasterserverHost":      return default.descMasterserverHost;
		case "MasterserverPort":      return default.descMasterserverPort;
		case "MasterserverAuthUser":  return default.descMasterserverAuthUser;
		case "MasterserverAuthPass":  return default.descMasterserverAuthPass;
		case "MasterserverUpdateURL": return default.descMasterserverUpdateURL;
		case "MasterserverTrackURL":  return default.descMasterserverTrackURL;
		case "bTrackPlayerJoins":     return default.descTrackPlayerJoins;
		case "bGetFreshList":         return default.descGetFreshList;
	}

	return Super.GetDescriptionText(PropName);
}


protected function string FillMaskValues(string str)
{
	local int i;

	str = Repl(str, "%y", Right("0000" $ Level.Year, 4));
	str = Repl(str, "%m", Right("00" $ Level.Month, 2));
	str = Repl(str, "%d", Right("00" $ Level.Day, 2));
	if (InStr(str, "am") == -1 && InStr(str, "pm") == -1)
		str = Repl(str, "%h", Right("00" $ Level.Hour, 2));
	else {
		i = Level.Hour;
		if (i == 0 || i > 12) {
			if (i == 0)
				i = 12;
			else
				i -= 12;
			str = Repl(str, "am", "pm");
		}
		else
			str = Repl(str, "pm", "am");
		str = Repl(str, "%h", Right("00" $ i, 2));
	}
	str = Repl(str, "%n", Right("00" $ Level.Minute, 2));
	str = Repl(str, "%s", Right("00" $ Level.Second, 2));

	if (InStr(str, "%i") != -1) {
		str = Repl(str, "%i", Repl(GetServerIP(), ".", "-"));
	}
	if (InStr(str, "%p") != -1) {
		str = Repl(str, "%p", Level.Game.GetServerPort());
	}
	str = Repl(str, "%l", string(Outer));
	str = Repl(str, "%g", string(Level.Game.Class.Name));
	return str;
}


protected function string GetServerIP()
{
	local InternetLink ILink;
	local InternetLink.IpAddr LocalAddress;
	local string LocalAddressString;
	local int i;

	foreach DynamicActors(class'InternetLink', ILink) {
		ILink.GetLocalIP(LocalAddress);
		LocalAddressString = ILink.IpAddrToString(LocalAddress);
		i = InStr(LocalAddressString, ":");
		if ( Left(LocalAddressString, i) != "0.0.0.0" && Left(LocalAddressString, i) != "127.0.0.1" ) {
			return Left(LocalAddressString, i);
		}
	}

	return "0.0.0.0";
}


protected function OpenLog()
{
	local int i;

	if ( CurrentLogFileName == "" || LogFile != None )
		return;

	LogFile = Spawn(class'FileLog', self);
	if ( LogFile != None ) {
		LogFile.OpenLog(CurrentLogFileName);
		LogFile.Logf("");
		LogFile.Logf("Start log session for" @ Level.Game.Class.Name @ "on" @ Outer @ "at" @ FillMaskValues("%y-%m-%d, %h:%n:%s"));
		LogFile.Logf(GetVersionString() @ Copyright);
		LogFile.Logf("Match started at" @ MatchStartTime);
		bLogFileOpened = true;
		LastLogSaveTime = Level.TimeSeconds;
		while (i < DelayedLogs.Length) {
			LogFile.Logf(DelayedLogs[i++]);
		}
	}
	else {
		log("ERROR: Could not create custom log file" @ CurrentLogFileName, 'UTAN');
		CurrentLogFileName = "";
	}
}


function LogLine(string Text, ELogLevel LogLevel)
{
	switch (LogLevel) {
	case LL_Update:
		Text = "[UPDATE]" @ Text;
		break;
	case LL_Message:
		Text = "[MESSAGE]" @ Text;
		break;
	case LL_Warning:
		Text = "[WARNING]" @ Text;
		break;
	case LL_Kick:
	case LL_ExternalKick:
		Text = "[KICK]" @ Text;
		break;
	case LL_Error:
		Text = "[ERROR]" @ Text;
		break;
	}

	if (LogLevel == LL_Status)
		log(" *" @ Text, 'UTAN');
	else if (LogLevel != LL_Update && LogLevel != LL_DumpBans && LogLevel != LL_ExternalKick)
		log(Text, 'UTAN');

	if ( LogFileTimeStamp != "" && LogLevel != LL_DumpBans )
		Text = FillMaskValues(LogFileTimeStamp) @ Text;
	if ( bLogFileSaved && CurrentLogFileName != "" && LogFile != None ) {
		bLogFileSaved = False;
		LogFile.OpenLog(CurrentLogFileName);
		LastLogSaveTime = Level.TimeSeconds;
	}
	else if ( CurrentLogFileName != "" && LogFile == None ) {
		if ( LogLevel > LL_Status && !bLogFileOpened )
			OpenLog();
		else {
			DelayedLogs[DelayedLogs.Length] = Text;
			return;
		}
	}
	DelayedLogs[DelayedLogs.Length] = Text;
	LastLogWriteTime = Level.TimeSeconds;
	if ( LogFile != None )
		LogFile.Logf(Text);
}


function array<string> GetCurrentLog(optional out string LogFileName, optional out string StartTime)
{
	LogFileName = CurrentLogFileName;
	StartTime = MatchStartTime;
	return DelayedLogs;
}


static function string GetVersionString(optional bool bNoBuild)
{
	if ( bNoBuild )
		return default.FriendlyName;
	else
		return default.FriendlyName @ "build" @ default.Build;
}

/**
Strips control codes and colors from player names.
*/
static function string StripInvalidChars(string PlayerName)
{
	local string NextChar;
	local string StrippedName;
	local int NameLength;

	while (PlayerName != "" && NameLength < 20) {
		NextChar = Left(PlayerName, 1);
		if ( NextChar == Chr(27) )
			PlayerName = Mid(PlayerName, 4);
		else {
			PlayerName = Mid(PlayerName, 1);
			if ( Asc(NextChar) < 32 || Asc(NextChar) == 127 ) {
				StrippedName $= "_";
				NameLength++;
			}
			else {
				StrippedName $= NextChar;
				NameLength++;
			}
		}
	}
	return StrippedName;
}


/**
Converts an IP string to a CIDR value.
*/
static final function CIDR StringToCidr(string IP)
{
	local array<string> Parts;
	local CIDR Result;

	if (Split(IP, ".", Parts) == 4) {
		if (InStr(IP, "/") > 0) {
			Result.Prefix = int(Mid(IP, InStr(IP, "/") + 1));
			if (Result.Prefix >= 32)
				Result.Prefix = 0; // means a.b.c.d/32
		}
		Result.IP = (int(Parts[0]) << 24 | int(Parts[1]) << 16 | int(Parts[2]) << 8 | int(Parts[3])) & -1 << -Result.Prefix;
		return Result;
	}
	// else invalid input -> return null
}

/**
Converts a CIDR value to an IP string.
*/
static final function string CidrToString(CIDR IP)
{
	if (IP.Prefix > 0 && IP.Prefix < 32)
		return IpToString(IP.IP & -1 << -IP.Prefix) $ "/" $ IP.Prefix;
	return IpToString(IP.IP);
}

/**
Converts an IP string to a int value.
*/
static final function int StringToIP(string IP)
{
	local array<string> Parts;

	if (Split(IP, ".", Parts) == 4) {
		return int(Parts[0]) << 24 | int(Parts[1]) << 16 | int(Parts[2]) << 8 | int(Parts[3]);
	}
	// else invalid input -> return null
}

/**
Converts an int value to an IP string.
*/
static final function string IpToString(int IP)
{
	return ((IP >>> 24) & 0xFF) $ "." $ ((IP >>> 16) & 0xFF) $ "." $ ((IP >>> 8) & 0xFF) $ "." $ (IP & 0xFF);
}


/**
Converts a 32-digit hexadecimal string to a GUID struct.
*/
static final function GUID StringToGuid(string ID)
{
	local GUID Result;

	Result.A = HexToInt(Mid(ID,  0, 8));
	Result.B = HexToInt(Mid(ID,  8, 8));
	Result.C = HexToInt(Mid(ID, 16, 8));
	Result.D = HexToInt(Mid(ID, 24, 8));

	return Result;
}

/**
Reads a GUID and returns a PlayerID string.
*/
static final function string GuidToString(GUID ID)
{
	return (IntToHex(ID.A) $ IntToHex(ID.B)) $ (IntToHex(ID.C) $ IntToHex(ID.D));
}


/**
Converts a hexadecimal string to integer.
*/
static final function int HexToInt(string HexNumber)
{
	const HexDigits = "0123456789ABCDEF";

	HexNumber = Right("00000000" $ Caps(HexNumber), 8);

	return InStr(HexDigits, Mid(HexNumber, 0, 1)) << 28 | InStr(HexDigits, Mid(HexNumber, 1, 1)) << 24 | InStr(HexDigits, Mid(HexNumber, 2, 1)) << 20 | InStr(HexDigits, Mid(HexNumber, 3, 1)) << 16 | InStr(HexDigits, Mid(HexNumber, 4, 1)) << 12 | InStr(HexDigits, Mid(HexNumber, 5, 1)) << 8 | InStr(HexDigits, Mid(HexNumber, 6, 1)) << 4 | InStr(HexDigits, Mid(HexNumber, 7, 1));
}

/**
Converts an integer to hexadecimal string.
*/
static final function string IntToHex(int i)
{
	return Mid(HexDigits, i >> 28 & 0xF, 1) $ Mid(HexDigits, i >> 24 & 0xF, 1) $ Mid(HexDigits, i >> 20 & 0xF, 1) $ Mid(HexDigits, i >> 16 & 0xF, 1) $ Mid(HexDigits, i >> 12 & 0xF, 1) $ Mid(HexDigits, i >> 8 & 0xF, 1) $ Mid(HexDigits, i >> 4 & 0xF, 1) $ Mid(HexDigits, i & 0xF, 1);
}


/**
Generates an 11 bit hash value from a GUID value
for use in the excludes and GUID ban hashes.
*/
static final function int HashGUID(GUID g)
{
	local int h;

	h = g.a ^ g.b ^ g.c ^ g.d;
	return (h ^ h >> 11 ^ h >> 22) & 0x7FF;
}


/** Returns the smallest IP in the range. */
static final preoperator int < (CIDR A)
{
	return A.IP & -1 << -A.Prefix;
}

/** Returns the largest IP in the range. */
static final preoperator int > (CIDR A)
{
	switch (A.Prefix) {
	case 0:
		return A.IP;
	default:
		return A.IP | -1 >>> A.Prefix;
	}
}

/** Returns True if IP range B is included in IP range A. */
static final operator(24) bool ~= (CIDR A, CIDR B)
{
	return B.Prefix == 0 && A ~= B.IP || B.Prefix <= A.Prefix && A ~= <B && A ~= >B;
}

/** Returns True if IP B is included in IP range A. */
static final operator(24) bool ~= (CIDR A, int B)
{
	return ((A.IP ^ B) & (-1 << -A.Prefix)) == 0;
}

/**
Returns True if GUID value A comes before B. Components are treated as unsigned ints
with A being more significant that B, etc.
*/
static final operator(24) bool < (GUID A, GUID B)
{
	if (A.A != B.A || A == B) // A == B means False will be returned here
		return (A.A < 0) == (B.A < 0) && A.A < B.A || A.A >= 0 && B.A < 0;

	if (A.B != B.B)
		return (A.B < 0) == (B.B < 0) && A.B < B.B || A.B >= 0 && B.B < 0;

	if (A.C != B.C)
		return (A.C < 0) == (B.C < 0) && A.C < B.C || A.C >= 0 && B.C < 0;

	return (A.D < 0) == (B.D < 0) && A.D < B.D || A.D >= 0 && B.D < 0;
}


/**
Returns True if A should come before B.
*/
static final operator(24) bool < (MutUTAN.TListEntry A, MutUTAN.TListEntry B)
{
	if (A.ID < B.ID)
		return true;
	if (A.ID > B.ID)
		return false;

	if (A.GUID < B.GUID)
		return true;
	if (A.GUID != B.GUID)
		return false;

	return <A.IP < <B.IP;
}


/**
Encodes illegal characters in a string so it can be used in a HTTP request URL.
Non-ASCII characters may first be converted to UTF-8 bytes and then URL-encoded.
*/
static final function string URLEncode(coerce string InputString, bool bEncodeAsUTF8)
{
	const VALID_URL_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.!~*'()";
	const HEX_DIGITS = "0123456789ABCDEF";
	local string OutputString, Char;
	local int CharCode, i, strLen;

	if (InputString == "")
		return "";

	if (bEncodeAsUTF8)
		InputString = UTF8Encode(InputString);

	strLen = Len(InputString);
	do {
		Char = Mid(InputString, i, 1);
		if (InStr(VALID_URL_CHARS, Char) != -1)
			OutputString $= Char;
		else {
			CharCode = Asc(Char);
			if (CharCode > 255)
				CharCode = Asc("?");
			OutputString $= "%" $ Mid(HEX_DIGITS, CharCode >>> 4, 1) $ Mid(HEX_DIGITS, CharCode & 0xF, 1);
		}
	} until (++i == strLen);

	return OutputString;
}


static final function string CharToUTF8(int Code)
{
	if (Code <= 0x7f)
		return Chr(Code);
	if (Code <= 0x7ff)
		return Chr(0xC0 | Code >> 6) $ Chr(0x80 | (Code & 0x3f));
	//if (Code <= 0xffff) - always since strings can only contain 16 bit chars
	return Chr(0xE0 | Code >> 12) $ Chr(0x80 | (Code >> 6 & 0x3f)) $ Chr(0x80 | (Code & 0x3f));
}


static final function string UTF8Encode(string str)
{
	local string Result;
	local int i, strLen;

	if (str == "")
		return "";

	strLen = Len(str);
	do {
		Result $= CharToUTF8(Asc(Mid(str, i, 1)));
	} until (++i == strLen);
	return Result;
}


// Gawd, Zed, you're such a PITA :P
static final function string Plural(string Word, int Num)
{
	if (Num == 1)
		return Word;
	return Word $ "s";
}


//=============================================================================
// Default properties
//=============================================================================

defaultproperties
{
	Build="%%%%-%%-%% %%:%%"
	Copyright="Copyright (c) 2003-2006 UTAN, 2009-2011 Wormbo"
	FriendlyName  = "UTAN Ban Manager v1.04"
	Description   = "The UTAN Ban Manager enforces bans stored in a special ban database.|This version can either load ban updates from a UTAN-compatible masterserver, or rely upon the UTAN Ban List Editor (UBLE) to modify the binary ban database file directly, or load bans from an INI file that can be edited manually with any plain text editor."
	bAlwaysTick   = True

	DefaultBan = (ID=1,GUID=(A=850354575,B=1000468354,C=1694031599,D=-1829262653),bIsDisabled=True) // 32af618f3ba1ef8264f8deefed08553c

	BanDatabaseName     = ""
	bStoreDatabaseInINI = True
	LogFileNameMask     = "UTAN_%i_%p_%y-%m-%d_%h-%n-%s_%g_%l"
	LogFileTimeStamp    = "[%y-%m-%d %h:%n:%s] -"
	bShowInServerName   = False
	AppealContactInfo   = "contact %%admin%%"

	MasterserverHost      = ""
	MasterserverPort      = 80
	MasterserverAuthUser  = ""
	MasterserverAuthPass  = ""
	MasterserverUpdateURL = "/utanupdate.php" //?server=%s&port=%p&map=%m&game=%g&lastupdate=%l"
	MasterserverTrackURL  = "/utantrack.php" //?server=%s&port=%p&pname=%n&pguid=%g&pip=%i"
	bTrackPlayerJoins     = True
	bSendNamesAsUTF8      = True

	lblBanDatabaseName         = "Ban database name"
	lblForceCreateDatabaseFile = "Force creation of ban database"
	lblStoreDatabaseInINI      = "Store database in INI"
	lblLogFileNameMask         = "Log file name mask"
	lblLogFileTimeStamp        = "Time stamp mask"
	lblShowInServerName        = "Show in server name"
	lblAppealContactInfo       = "Appeal contact info"

	lblMasterserverHost      = "Masterserver host name or IP"
	lblMasterserverPort      = "Masterserver port number"
	lblMasterserverAuthUser  = "Masterserver auth username"
	lblMasterserverAuthPass  = "Masterserver auth password"
	lblMasterserverUpdateURL = "Masterserver update URL"
	lblMasterserverTrackURL  = "Masterserver tracker URL"
	lblTrackPlayerJoins      = "Track player joins"
	lblGetFreshList          = "Get fresh ban list"
	lblSendNamesAsUTF8       = "Send data as UTF-8"

	descBanDatabaseName         = "The package/INI name to use for the ban data base. Only change this if you run multiple servers from the same directory."
	descForceCreateDatabaseFile = "If the ban database file does not exist yet, create a new file for the empty database at map change. (turns off automatically)"
	descStoreDatabaseInINI      = "Store the ban database as text in a separate INI file. An INI file will be considerably larger than a binary database file, but can be edited with a simple text editor."
	descLogFileNameMask         = "A mask for the log file name. %y=year, %m=month, %d=day, %h=hour (include am or pm for 12 hours format), %n=minute, %s=second, %i=IP, %p=port, %g=gametype, %l=level"
	descLogFileTimeStamp        = "A mask for the log file name. %y=year, %m=month, %d=day, %h=hour (include am or pm for 12 hours format), %n=minute, %s=second"
	descShowInServerName        = "Add the [UTAN] tag to the server name."
	descAppealContactInfo       = "Banned players see 'Please <AppealContactInfo> for details about this ban', with %%admin%% being replaced by the server admin name and email."

	descMasterserverHost      = "The host name or IP of a HTTP server to load ban list updates from and send player tracking data to. Leave empty to disable remote updating."
	descMasterserverPort      = "The port at which the HTTP server is listening for ban list requests."
	descMasterserverAuthUser  = "The user name for HTTP authentification at the masterserver, if required."
	descMasterserverAuthPass  = "The password for HTTP authentification at the masterserver, if required."
	descMasterserverUpdateURL = "The URL to request initial ban list updates from."
	descMasterserverTrackURL  = "The URL to send player tracking data to."
	descTrackPlayerJoins      = "Whether to send player tracking data to the masterserver."
	descGetFreshList          = "Request a fresh ban list instead of only the diff on next update. (automatically unchecked after receiving a fresh list)"
	descSendNamesAsUTF8       = "Encode player names as UTF-8 instead of ISO-8859-1."

	BanMessage = "Your %%idtype%% matches ban #%%id%%.||Please %%contact%% for details about this ban, providing your GUID (%%guid%%), IP (%%ip%%) and the ban number.||"
	BanMessageIP = "IP"
	BanMessageGUID = "GUID"
}