[cpp]
//~zeile 184

void CheckWhiteList(int ClientID);
[/cpp]

[cpp]
//Benötigte includes:
#include <string>
#include <fstream>

[.....]

//~zeile 691

void CServer::CheckWhiteList(int ClientID)
{
char aBuf[256];
bool bPlayerIsOnWl = false;
std::string sEnteredPlayer = ClientName(ClientID);
std::string sPlayersOnWl[256]; //number of max. players (256) you can change it
short shL=0;
std::string sOneLine;
std::ifstream wlFile (g_Config.m_SvWhiteListPath);

if (wlFile.is_open())
{
while (! wlFile.eof() )
{
getline (wlFile, sOneLine);
sPlayersOnWl[shL] = sOneLine;

if(sPlayersOnWl[shL] == sEnteredPlayer)
{
//player is on whitelist, let him join
bPlayerIsOnWl = true;
break;
}
else
{
bPlayerIsOnWl = false;
}
shL++;
}
wlFile.close();

if(bPlayerIsOnWl == false)
{
//player is not whitelisted, kick
Kick(ClientID, "You are not on the Whitelist on this server!");
}
}

//can't find whitelist-path
else
{
str_format(aBuf, sizeof(aBuf), "Can not open Whitelist, check path! (given path: %s)", g_Config.m_SvWhiteListPath);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}


[.....]


else if(Msg == NETMSG_ENTERGAME)
{
[....]
//~zeile 849

if(g_Config.m_SvWhiteList == 1)
{
CheckWhiteList(ClientID);
}
else
{
str_format(aBuf, sizeof(aBuf), "Whitelist is OFF, player can join");
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}

[...]
//~zeile 1076

//if whitelist is on hide playernames
if(g_Config.m_SvWhiteList == 1)
{
p.AddString("Whitelist is ON", MAX_NAME_LENGTH); // if whitelist is on (1), hide players
}
else
{
for(i = 0; i < MAX_CLIENTS; i++)
{
if(m_aClients.m_State != CClient::STATE_EMPTY)
{
p.AddString(ClientName(i), MAX_NAME_LENGTH); // client name
p.AddString(ClientClan(i), MAX_CLAN_LENGTH); // client clan
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Country); p.AddString(aBuf, 6); // client country
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Score); p.AddString(aBuf, 6); // client score
str_format(aBuf, sizeof(aBuf), "%d", GameServer()->IsClientPlayer(i)?1:0); p.AddString(aBuf, 2); // is player?
}
}
}
[/cpp]

[cpp]
//if whitelist is on hide playernames
if(g_Config.m_SvWhiteList == 1)
{
p.AddString("Whitelist is ON", MAX_NAME_LENGTH); // if whitelist is on (1), hide players
}
else
{
for(i = 0; i < MAX_CLIENTS; i++)
{
if(m_aClients.m_State != CClient::STATE_EMPTY)
{
p.AddString(ClientName(i), MAX_NAME_LENGTH); // client name
p.AddString(ClientClan(i), MAX_CLAN_LENGTH); // client clan
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Country); p.AddString(aBuf, 6); // client country
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Score); p.AddString(aBuf, 6); // client score
str_format(aBuf, sizeof(aBuf), "%d", GameServer()->IsClientPlayer(i)?1:0); p.AddString(aBuf, 2); // is player?
}
}
}


[/cpp]

SvWhiteList

• Kommando: sv_whitelist
  
• Beschreibung/Funktion: Whitelist ein bzw. ausschalten (0 = aus, 1 = ein)
  
• Verwendung: sv_whitelist int_value

SvWhiteListPath

• Kommando: sv_whitelistpath
  
• Beschreibung/Funktion: Pfad zur Whitelist (Beispiel: /home/teeworlds/ctf/whitelist.txt)
  
• Verwendung: sv_whitelistpath "Pfad/zur/Whitelist"

WlAdd

• Kommando: wl_add
• Beschreibung/Funktion: Spieler zur Whitelist hinzufügen
• Verwendung: wl_add "Spielername"

WlRemove

• Kommando: wl_remove
  
• Beschreibung/Funktion: Spieler von der Whitelist entfernen
  
• Verwendung: wl_remove "Spielername"

SvBlackList

• Kommando: sv_blacklist
  
• Beschreibung/Funktion: Blacklist ein bzw. ausschalten (0 = aus, 1 = ein)
  
• Verwendung: sv_blacklist int_value

SvBlackListPath

• Kommando: sv_blacklistpath
  
• Beschreibung/Funktion: Pfad zur Blacklist (Beispiel: /home/teeworlds/ctf/blacklist.txt)
  
• Verwendung: sv_whitelistpath "Pfad/zur/Blacklist"

BlAdd

• Kommando: bl_add
• Beschreibung/Funktion: Spieler zur Blacklist hinzufügen
• Verwendung: bl_add "Spielername"

BlRemove

• Kommando: bl_remove
  
• Beschreibung/Funktion: Spieler von der Blacklist entfernen
  
• Verwendung: bl_remove "Spielername"

TrIPRemove

• Kommando: tr_ip_remove
• Beschreibung/Funktion: Vertraute IP entfernen
• Verwendung tr_ip_remove "Spielername"

TrIPTime

• Kommando: tr_ip_time
  
• Beschreibung/Funktion: noch keine (später: Zeit (in Stunden) wie lange einer IP vertraut werden soll)
  
• Verwendung: tr_ip_time int_value

[cpp]
// beginnend ab zeile 76

// whitelistcmds
MACRO_CONFIG_STR(WlAdd, wl_add, 128, "", CFGFLAG_SERVER, "Add player to Whitelist")
MACRO_CONFIG_STR(WlRemove, wl_remove, 128, "", CFGFLAG_SERVER, "Remove player from Whitelist")
MACRO_CONFIG_INT(SvWhiteList, sv_whitelist, 0, 0, 0, CFGFLAG_SERVER, "Turn whitelist on/off (0=off, 1=on)")
MACRO_CONFIG_STR(SvWhiteListPath, sv_whitelistpath, 512, "whitelist.txt", CFGFLAG_SERVER, "Path to Whitelistfile (use absolute path! e.g.: /home/server/whitelist.txt)")

// blacklistcmds
MACRO_CONFIG_STR(BlAdd, bl_add, 128, "", CFGFLAG_SERVER, "Add player to Blacklist")
MACRO_CONFIG_STR(BlRemove, bl_remove, 128, "", CFGFLAG_SERVER, "Remove player from Blacklist")
MACRO_CONFIG_INT(SvBlackList, sv_blacklist, 0, 0, 0, CFGFLAG_SERVER, "Turn blacklist on/off (0=off, 1=on)")
MACRO_CONFIG_STR(SvBlackListPath, sv_blacklistpath, 512, "blacklist.txt", CFGFLAG_SERVER, "Path to Blacklistfile (use absolute path! e.g.: /home/server/whitelist.txt)")

// trusted ip cmds
MACRO_CONFIG_STR(TrIPRemove, tr_ip_remove, 128, "", CFGFLAG_SERVER, "Remove trusted IP (usage: tr_ip_remove \"playername\")")
MACRO_CONFIG_INT(TrIPTime, tr_ip_time, 2, 0, 0, CFGFLAG_SERVER, "How long should i trust a IP? (value = hours)")
[/cpp]

[cpp]
// beginnend ab zeile 184

// whitelist
void CheckWhiteList(int ClientID);
void AddToWhiteList();
void RemoveFromWhiteList();

// blacklist
void CheckBlackList(int ClientID);
void AddToBlackList();
void RemoveFromBlackList();

// save, delete and check trusted IPs
void SaveAndTrustIP(int ClientID, NETADDR Addr);
void DeleteTrustedIP(int ClientID, std::string sSubCmd);
void AutoDeleteTrustedIP(int ClientID, std::string sSubCmd);
void CheckIfIPIsTrusted(NETADDR Addr);
[/cpp]

[cpp]
// beginnend ab zeile 4

//needed for the whitelist <string> <fstream> <stdio.h>
#include <string>
#include <fstream>
#include <stdio.h>
[/cpp]

[cpp]
// beginnend ab zeile 37

#if defined(CONF_FAMILY_WINDOWS)
#define _WIN32_WINNT 0x0501
#define WIN32_LEAN_AND_MEAN
#define ON_WIN // CreateDirectory()
#include <windows.h> // CreateDirectory()
#else
#include <sys/stat.h> // mkdir()
#include <dirent.h> // list directory
#endif
[/cpp]

[cpp]
// beginnend ab zeile 47

// public vars for White and Blacklist
bool bPub_PlayerIsOnWl = false, bPub_PlayerIsOnBl = false, bPub_IPIsTrusted = false;
[/cpp]

[cpp]
// beginnend ab zeile 699

// TODO: fix blank/empty lines in created files
// whitelist begin
void CServer::CheckWhiteList(int ClientID)
{
char aBuf[512]; // higher buffer, maybe path is long
bool bPlayerIsOnWl = false;
std::string sEnteredPlayer = ClientName(ClientID);
std::string sPlayersOnWl[256]; // number of max. players (256) you can change it
short shL = 0;
std::string sOneLine;
std::ifstream wlFile (g_Config.m_SvWhiteListPath);

if (wlFile.is_open())
{
while (! wlFile.eof() )
{
getline (wlFile, sOneLine);
sPlayersOnWl[shL] = sOneLine;

if(sPlayersOnWl[shL] == sEnteredPlayer)
{
// player is on whitelist, let him join
bPlayerIsOnWl = true;
break;
}
else
{
bPlayerIsOnWl = false;
}
shL++;
}
wlFile.close();

if(bPlayerIsOnWl == false)
{
// player is not whitelisted, kick
Kick(ClientID, "You are not on the Whitelist on this server!");
bPub_PlayerIsOnWl = false;
}
else
{
bPub_PlayerIsOnWl = true;
}

}

// can't find whitelist-file
else
{
str_format(aBuf, sizeof(aBuf), "Can not open Whitelist, check path! (given path: %s)", g_Config.m_SvWhiteListPath);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 753

void CServer::AddToWhiteList()
{
std::ofstream writeFile(g_Config.m_SvWhiteListPath, std::ios::app);
if(writeFile.is_open())
{
writeFile << "\n" << g_Config.m_WlAdd;

// give user feedback
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' successfully added to Whitelist", g_Config.m_WlAdd);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
// can't open file
else
{
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "Can not open Whitelist, check path! (given path: %s)", g_Config.m_SvWhiteListPath);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 774

void CServer::RemoveFromWhiteList()
{
std::ifstream readFile(g_Config.m_SvWhiteListPath);
std::string sFileLine[256]; // max players on whitelist
std::string sOneLine;
std::string sSearchFor = g_Config.m_WlRemove;
short shL = 0; // loopvar
bool bChangeFile = false;

if(readFile.is_open())
{
while(!readFile.eof())
{
getline(readFile, sOneLine);
sFileLine[shL] = sOneLine;
if(sFileLine[shL] == sSearchFor)
{
// player found in whitelist, clear line in array
sFileLine[shL].clear();
bChangeFile = true;
}
shL++;
}
}
readFile.close();

if(bChangeFile) // only write new file, when player was found on the list
{
// now write new file
std::ofstream writeFile(g_Config.m_SvWhiteListPath);
for(int i = 0; i < shL; i++)
{
writeFile << sFileLine << std::endl;
}
DeleteTrustedIP(-1, g_Config.m_WlRemove);

char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' successfully removed from Whitelist", g_Config.m_WlRemove);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
// player not found on whitelist
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' not found on Whitelist", g_Config.m_WlRemove);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 823

// blacklist begin
void CServer::CheckBlackList(int ClientID)
{
char aBuf[512];
bool bPlayerIsOnBl = false;
std::string sEnteredPlayer = ClientName(ClientID);
std::string sPlayersOnBl[256]; //number of max. players (256) you can change it
short shL = 0;
std::string sOneLine;
std::ifstream blFile (g_Config.m_SvBlackListPath);

if (blFile.is_open())
{
while (!blFile.eof())
{
getline (blFile, sOneLine);
sPlayersOnBl[shL] = sOneLine;

if(sPlayersOnBl[shL] == sEnteredPlayer)
{
//player is on blacklist
bPlayerIsOnBl = true;
break;
}
else
{
bPlayerIsOnBl = false;
}
shL++;
}
blFile.close();

if(bPlayerIsOnBl)
{
//player is on blacklist, kick
Kick(ClientID, "You are on the Blacklist on this server!");
bPub_PlayerIsOnBl = true;
}
else
{
bPub_PlayerIsOnBl = false;
}
}

//can't find blacklist-file
else
{
str_format(aBuf, sizeof(aBuf), "Can not open Blacklist, check path! (given path: %s)", g_Config.m_SvBlackListPath);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 875

void CServer::AddToBlackList()
{
std::ofstream writeFile(g_Config.m_SvBlackListPath, std::ios::app);
if(writeFile.is_open())
{
writeFile << "\n" << g_Config.m_BlAdd;
DeleteTrustedIP(-1, g_Config.m_BlAdd);

// give user feedback
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' successfully added to Blacklist", g_Config.m_BlAdd);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
// can't open blacklist
else
{
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "Can not open Blacklist, check path! (given path: %s)", g_Config.m_SvBlackListPath);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 897

void CServer::RemoveFromBlackList()
{
std::ifstream readFile(g_Config.m_SvBlackListPath);
std::string sFileLine[256]; // max players on blacklist
std::string sOneLine;
std::string sSearchFor = g_Config.m_BlRemove;
short shL = 0; // loopvar
bool bChangeFile = false;

if(readFile.is_open())
{
while(!readFile.eof())
{
getline(readFile, sOneLine);
sFileLine[shL] = sOneLine;
if(sFileLine[shL] == sSearchFor)
{
// player found in blacklist, clear line in array
sFileLine[shL].clear();
bChangeFile = true;
}
shL++;
}
}
readFile.close();

if(bChangeFile) // only write new file, when player was found on the list
{
// now write new file
std::ofstream writeFile(g_Config.m_SvBlackListPath);
for(int i = 0; i < shL; i++)
{
writeFile << sFileLine << std::endl;
}

char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' successfully removed from blacklist", g_Config.m_BlRemove);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
// player is not on blacklist
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' not found on blacklist", g_Config.m_BlRemove);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
[/cpp]

[cpp]
// beginnend ab zeile 945

void CServer::SaveAndTrustIP(int ClientID, NETADDR Addr)
{
char aBuf[1024];
char cCurDir[1024];
char aAddrStr[NETADDR_MAXSTRSIZE];
net_addr_str(&Addr, aAddrStr, sizeof(aAddrStr));
std::string sCurDir, sPlayerName, sCurDirAndIP;
fs_getcwd(cCurDir, sizeof(cCurDir)); // get currdir
// full path to "trusted_ips"-folder
sCurDir = (std::string)cCurDir+"/trusted_ips/"; // TODO: any idea how it could work without cast ? (std::string)
sPlayerName = ClientName(ClientID);
sCurDirAndIP = sCurDir + aAddrStr;

#if defined(ON_WIN) // on windows

// TODO: make it work for windows
const char* ccWinPath = sCurDir;
// create dir if there is no error
if(CreateDirectory((LPCWSTR)ccWinPath, NULL) == 0)
{
if (GetLastError() == 183)
{
// dir exists, don't override
}
else if (GetLastError() == 3)
{
// path not found
}
}

#else // not on windows

struct stat stCheckForDir;
if(stat(sCurDir.c_str(),&stCheckForDir) == 0)
{
// dir exists, don't override
str_format(aBuf, sizeof(aBuf), "Directory '%s' already exists, don't override it", sCurDir.c_str());
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
// no error, create dir
mkdir(sCurDir.c_str(), 0755);
str_format(aBuf, sizeof(aBuf), "Successfully createt '%s'", sCurDir.c_str());
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}

// add player ip to trusted ips, if already exists override it
std::ofstream writeFile(sCurDirAndIP.c_str());
writeFile << sPlayerName;

// finally check if file was created
std::ifstream checkIfCreated(sCurDirAndIP.c_str());
if(checkIfCreated.good())
{
str_format(aBuf, sizeof(aBuf), "Player IP successfully added to trusted ips");
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
str_format(aBuf, sizeof(aBuf), "Error while adding player IP to trusted IPs, maybe there are no permissions");
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}

#endif
}
[/cpp]

[cpp]
// beginnend ab zeile 1012

void CServer::DeleteTrustedIP(int ClientID, std::string sSubCmd)
{
char aBuf[1024];
char cCurDir[1024];
int iL = 0; // loopvar
std::string sCurDir, sPlayerName, sCurDirAndPlayerName, sOneLine, sCompletePath;
bool bPlayerIPIsOnList = false;
fs_getcwd(cCurDir, sizeof(cCurDir)); // get currdir
// full path to "trusted_ips"-folder
sCurDir = (std::string)cCurDir+"/trusted_ips/"; // TODO: any idea how it could work without cast ? (std::string)

NETADDR Addr;
Addr = m_NetServer.ClientAddr(ClientID);
char aAddrStr[NETADDR_MAXSTRSIZE];
net_addr_str(&Addr, aAddrStr, sizeof(aAddrStr));

#if defined(ON_WIN) // on windows
// TODO: make it work on windows


#else // not on windows

// do this, when no ClientID is available (e.g. when cmd 'tr_ip_remove' is entered)
if(sSubCmd != "" && ClientID == -1)
{
std::string sPlayerToRemove = sCurDir + aAddrStr;
DIR* dir;
dirent* pDir;

dir = opendir(sCurDir.c_str());
while((pDir = readdir(dir))) // double brackets fix compiler-warning
{
iL++;
}
std::string saAllIPs[iL];
std::string saAllNames[iL];
iL = 0;
closedir(dir);

dir = opendir(sCurDir.c_str());
while((pDir = readdir(dir))) // double brackets fix compiler-warning
{
saAllIPs[iL] = pDir->d_name;

// check if player ip is trusted
sCompletePath = sCurDir+saAllIPs[iL];
std::ifstream readFile(sCompletePath.c_str());

getline(readFile, sOneLine);
saAllNames[iL] = sOneLine;

if(saAllNames[iL] == sSubCmd)
{
// player was found, delete
bPlayerIPIsOnList = true;
if(remove(sCompletePath.c_str()) != 0)
{
str_format(aBuf, sizeof(aBuf), "Error while removing player IP from trusted IPs, maybe there are no permissions");
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
str_format(aBuf, sizeof(aBuf), "'%s''s IP successfully removed from trusted IP list", sSubCmd.c_str());
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}
iL++;
}
if(!bPlayerIPIsOnList)
{
str_format(aBuf, sizeof(aBuf), "'%s''s IP is not on the trusted IPs list", sSubCmd.c_str());
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
}

// don't need this anymore i think

// do this, when there is a ClientID available
// if(ClientID >= 0 && sSubCmd == "")
// {
// std::string sPlayerToRemove = sCurDir + sPlayerName;
// sPlayerName = ClientName(ClientID);
// sCurDirAndPlayerName = sCurDir + sPlayerName;

// DIR* dir;
// dirent* pDir;

// dir = opendir(sCurDir.c_str());
// while((pDir = readdir(dir))) // double brackets fix compiler-warning
// {
// iL++;
// }
// std::string saAllPlayers[iL];
// iL = 0;
// closedir(dir);

// dir = opendir(sCurDir.c_str());
// while((pDir = readdir(dir))) // double brackets fix compiler-warning
// {
// saAllPlayers[iL] = pDir->d_name;

// // check if player ip is trusted
// if(saAllPlayers[iL] == sPlayerName)
// {
// // player was found, delete
// if(remove(sPlayerToRemove.c_str()) != 0)
// {
// str_format(aBuf, sizeof(aBuf), "Error while removing player ip from trusted ips, maybe there are no permissions");
// Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
// }
// else
// {
// str_format(aBuf, sizeof(aBuf), "'%s''s ip successfully removed from trusted ip list", sPlayerName.c_str());
// Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
// }
// }
// iL++;
// }
// }


#endif
}
[/cpp]

[cpp]
// beginnend ab zeile 1136

void CServer::AutoDeleteTrustedIP(int ClientID, std::string sSubCmd)
{
// TODO: check and auto-delete IPs every X hours(?)
}
[/cpp]

[cpp]
// beginnend ab zeile 1141

void CServer::CheckIfIPIsTrusted(NETADDR Addr)
{
char aBuf[1024];
char cCurDir[1024];
bool bIPIsTrusted = false;
char aAddrStr[NETADDR_MAXSTRSIZE];
net_addr_str(&Addr, aAddrStr, sizeof(aAddrStr));
int iL = 0; // loopvar
std::string sCurDir, sCurDirAndIP;
fs_getcwd(cCurDir, sizeof(cCurDir)); // get currdir
// full path to "trusted_ips"-folder
sCurDir = (std::string)cCurDir+"/trusted_ips/"; // TODO: any idea how it could work without cast ? (std::string)
sCurDirAndIP = sCurDir + aAddrStr;

DIR* dir;
dirent* pDir;
dir = opendir(sCurDir.c_str());
while((pDir = readdir(dir))) // double brackets fix compiler-warning
{
iL++;
}
std::string saAllIPs[iL];
iL = 0;
closedir(dir);

dir = opendir(sCurDir.c_str());
while((pDir = readdir(dir))) // double brackets fix compiler-warning
{
saAllIPs[iL] = pDir->d_name;

// check if ip is trusted
if(saAllIPs[iL] == aAddrStr)
{
// ip is trusted
bIPIsTrusted = true;
break;
}
else
{
bIPIsTrusted = false;
}
}

if(bIPIsTrusted)
{
bPub_IPIsTrusted = true;
str_format(aBuf, sizeof(aBuf), "'%s' is trusted, don't check White or Blacklist", aAddrStr);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
else
{
bPub_IPIsTrusted = false;
str_format(aBuf, sizeof(aBuf), "'%s' is not trusted, check white or blackist", aAddrStr);
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}

}
[/cpp]