/// Ban an account, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban
BanReturn BanManager::BanAccount(std::string const& AccountName, std::string const& Duration, std::string const& Reason, std::string const& Author)
{
if (AccountName.empty() || Duration.empty())
return BAN_SYNTAX_ERROR;
uint32 DurationSecs = TimeStringToSecs(Duration);
uint32 AccountID = AccountMgr::GetId(AccountName);
if (!AccountID)
return BAN_NOTFOUND;
///- Disconnect all affected players (for IP it can be several)
SQLTransaction trans = LoginDatabase.BeginTransaction();
// pussywizard: check existing ban to prevent overriding by a shorter one! >_>
PreparedStatement* stmtAccountBanned = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BANNED);
stmtAccountBanned->setUInt32(0, AccountID);
PreparedQueryResult banresult = LoginDatabase.Query(stmtAccountBanned);
if (banresult && ((*banresult)[0].GetUInt32() == (*banresult)[1].GetUInt32() || ((*banresult)[1].GetUInt32() > time(nullptr) + DurationSecs && DurationSecs)))
return BAN_LONGER_EXISTS;
// make sure there is only one active ban
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_NOT_BANNED);
stmt->setUInt32(0, AccountID);
trans->Append(stmt);
// No SQL injection with prepared statements
stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_BANNED);
stmt->setUInt32(0, AccountID);
stmt->setUInt32(1, DurationSecs);
stmt->setString(2, Author);
stmt->setString(3, Reason);
trans->Append(stmt);
if (WorldSession* session = sWorld->FindSession(AccountID))
if (session->GetPlayerName() != Author)
session->KickPlayer("Ban Account at condition 'FindSession(account)->GetPlayerName() != author'");
if (WorldSession* session = sWorld->FindOfflineSession(AccountID))
if (session->GetPlayerName() != Author)
session->KickPlayer("Ban Account at condition 'FindOfflineSession(account)->GetPlayerName() != author'");
LoginDatabase.CommitTransaction(trans);
if (sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
{
bool IsPermanetly = true;
if (TimeStringToSecs(Duration) > 0)
IsPermanetly = false;
if (!IsPermanetly)
sWorld->SendWorldText(LANG_BAN_ACCOUNT_YOUBANNEDMESSAGE_WORLD, Author.c_str(), AccountName.c_str(), secsToTimeString(TimeStringToSecs(Duration), true).c_str(), Reason.c_str());
else
sWorld->SendWorldText(LANG_BAN_ACCOUNT_YOUPERMBANNEDMESSAGE_WORLD, Author.c_str(), AccountName.c_str(), Reason.c_str());
}
return BAN_SUCCESS;
}
/// Ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban
BanReturn BanManager::BanIP(std::string const& IP, std::string const& Duration, std::string const& Reason, std::string const& Author)
{
if (IP.empty() || Duration.empty())
return BAN_SYNTAX_ERROR;
uint32 DurationSecs = TimeStringToSecs(Duration);
// No SQL injection with prepared statements
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_IP);
stmt->setString(0, IP);
PreparedQueryResult resultAccounts = LoginDatabase.Query(stmt);
stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_IP_BANNED);
stmt->setString(0, IP);
stmt->setUInt32(1, DurationSecs);
stmt->setString(2, Author);
stmt->setString(3, Reason);
LoginDatabase.Execute(stmt);
if (sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
{
bool IsPermanetly = true;
if (TimeStringToSecs(Duration) > 0)
IsPermanetly = false;
if (IsPermanetly)
sWorld->SendWorldText(LANG_BAN_IP_YOUPERMBANNEDMESSAGE_WORLD, Author.c_str(), IP.c_str(), Reason.c_str());
else
sWorld->SendWorldText(LANG_BAN_IP_YOUBANNEDMESSAGE_WORLD, Author.c_str(), IP.c_str(), secsToTimeString(TimeStringToSecs(Duration), true).c_str(), Reason.c_str());
}
if (!resultAccounts)
return BAN_SUCCESS;
///- Disconnect all affected players (for IP it can be several)
SQLTransaction trans = LoginDatabase.BeginTransaction();
do
{
Field* fields = resultAccounts->Fetch();
uint32 AccountID = fields[0].GetUInt32();
if (WorldSession* session = sWorld->FindSession(AccountID))
if (session->GetPlayerName() != Author)
session->KickPlayer("Ban IP at condition 'FindSession(account)->GetPlayerName() != author'");
if (WorldSession* session = sWorld->FindOfflineSession(AccountID))
if (session->GetPlayerName() != Author)
session->KickPlayer("Ban IP at condition 'FindOfflineSession(account)->GetPlayerName() != author'");
} while (resultAccounts->NextRow());
LoginDatabase.CommitTransaction(trans);
return BAN_SUCCESS;
}
void PunishMgr::_HandleBan(Player *pl, ValueState *state, const char *arg)
{
std::string cp(arg); // copy original arg, because the ChatHandler functions modify their input!
char *ptr = (char*)cp.c_str();
char* duration = ChatHandler::ExtractArg(&ptr); // time string
if(!duration)
{
sLog.outError("PunishMgr::_HandleBan(): Invalid arg '%s'", arg);
return;
}
int32 duration_secs;
// use atoi first, because TimeStringToSecs("-1") returns 0 !
duration_secs = atoi(duration);
if(duration_secs >= 0)
duration_secs = TimeStringToSecs(duration);
// if already perm banned, do nothing anymore
if(duration_secs >= 0 && state->banTime >= 0)
{
if(duration_secs > state->banTime)
state->banTime = duration_secs;
}
else
state->banTime = -1;
}
/// Ban an character, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban
BanReturn BanManager::BanCharacter(std::string const& CharacterName, std::string const& Duration, std::string const& Reason, std::string const& Author)
{
Player* target = ObjectAccessor::FindPlayerByName(CharacterName, false);
uint32 DurationSecs = TimeStringToSecs(Duration);
uint32 TargetGUID = 0;
/// Pick a player to ban if not online
if (!target)
{
TargetGUID = sWorld->GetGlobalPlayerGUID(CharacterName);
if (!TargetGUID)
return BAN_NOTFOUND;
}
else
TargetGUID = target->GetGUIDLow();
// make sure there is only one active ban
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_BAN);
stmt->setUInt32(0, TargetGUID);
CharacterDatabase.Execute(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHARACTER_BAN);
stmt->setUInt32(0, TargetGUID);
stmt->setUInt32(1, DurationSecs);
stmt->setString(2, Author);
stmt->setString(3, Reason);
CharacterDatabase.Execute(stmt);
if (target)
target->GetSession()->KickPlayer("Ban");
if (sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
{
bool IsPermanetly = true;
if (TimeStringToSecs(Duration) > 0)
IsPermanetly = false;
if (!IsPermanetly)
sWorld->SendWorldText(LANG_BAN_CHARACTER_YOUBANNEDMESSAGE_WORLD, Author.c_str(), CharacterName.c_str(), secsToTimeString(TimeStringToSecs(Duration), true).c_str(), Reason.c_str());
else
sWorld->SendWorldText(LANG_BAN_CHARACTER_YOUPERMBANNEDMESSAGE_WORLD, Author.c_str(), CharacterName.c_str(), Reason.c_str());
}
return BAN_SUCCESS;
}
bool WorldSession::Anti__ReportCheat(const char* Reason,float Speed,const char* Op,float Val1,uint32 Val2)
{
if(!Reason)
{
sLog.outError("Anti__ReportCheat: Missing Reason parameter!");
return false;
}
const char* Player=GetPlayer()->GetName();
uint32 Acc=GetPlayer()->GetSession()->GetAccountId();
uint32 Map=GetPlayer()->GetMapId();
if(!Player)
{
sLog.outError("Anti__ReportCheat: Player with no name?!?");
return false;
}
QueryResult *Res=CharacterDatabase.PQuery("SELECT speed,Val1 FROM cheaters WHERE player='%s' AND reason LIKE '%s' AND Map='%u' AND last_date >= NOW()-300",Player,Reason,Map);
if(Res)
{
Field* Fields = Res->Fetch();
std::stringstream Query;
Query << "UPDATE cheaters SET count=count+1,last_date=NOW()";
Query.precision(5);
if(Speed>0.0f && Speed > Fields[0].GetFloat())
{
Query << ",speed='";
Query << std::fixed << Speed;
Query << "'";
}
if(Val1>0.0f && Val1 > Fields[1].GetFloat())
{
Query << ",Val1='";
Query << std::fixed << Val1;
Query << "'";
}
Query << " WHERE player='" << Player << "' AND reason='" << Reason << "' AND Map='" << Map << "' AND last_date >= NOW()-300 ORDER BY entry DESC LIMIT 1";
CharacterDatabase.Execute(Query.str().c_str());
delete Res;
}
else
{
if(!Op)
{ Op=""; }
std::stringstream Pos;
Pos << "OldPos: " << GetPlayer()->GetPositionX() << " " << GetPlayer()->GetPositionY() << " "
<< GetPlayer()->GetPositionZ();
CharacterDatabase.PExecute("INSERT INTO cheaters (player,acctid,reason,speed,count,first_date,last_date,`Op`,Val1,Val2,Map,Pos,Level) "
"VALUES ('%s','%u','%s','%f','1',NOW(),NOW(),'%s','%f','%u','%u','%s','%u')",
Player,Acc,Reason,Speed,Op,Val1,Val2,Map,
Pos.str().c_str(),GetPlayer()->getLevel());
}
if(sWorld.GetMvAnticheatKill() && GetPlayer()->isAlive())
{
GetPlayer()->DealDamage(GetPlayer(), GetPlayer()->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
if(sWorld.GetMvAnticheatKick())
{
GetPlayer()->GetSession()->KickPlayer();
}
if(sWorld.GetMvAnticheatBan() & 1)
{
uint32 duration_secs = TimeStringToSecs(sWorld.GetMvAnticheatBanTime());
sWorld.BanAccount(BAN_CHARACTER,Player,duration_secs,(char*)"Cheat",(char*)"Anticheat");
}
if(sWorld.GetMvAnticheatBan() & 2)
{
QueryResult *result = LoginDatabase.PQuery("SELECT last_ip FROM account WHERE id=%u", Acc);
if(result)
{
Field *fields = result->Fetch();
std::string LastIP = fields[0].GetCppString();
if(!LastIP.empty())
{
uint32 duration_secs = TimeStringToSecs(sWorld.GetMvAnticheatBanTime());
sWorld.BanAccount(BAN_IP,LastIP,duration_secs,(char*)"Cheat",(char*)"Anticheat");
}
delete result;
}
}
return true;
}
static bool HandleBanCharacterCommand(ChatHandler* handler, char const* args)
{
if (!*args)
return false;
char* nameStr = strtok((char*)args, " ");
if (!nameStr)
return false;
std::string name = nameStr;
char* durationStr = strtok(NULL, " ");
if (!durationStr || !atoi(durationStr))
return false;
char* reasonStr = strtok(NULL, "");
if (!reasonStr)
return false;
if (!normalizePlayerName(name))
{
handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
handler->SetSentErrorMessage(true);
return false;
}
switch (sWorld->BanCharacter(name, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName().c_str() : ""))
{
case BAN_SUCCESS:
{
if (atoi(durationStr) > 0)
handler->PSendSysMessage(LANG_BAN_YOUBANNED, name.c_str(), secsToTimeString(TimeStringToSecs(durationStr), true).c_str(), reasonStr);
else
handler->PSendSysMessage(LANG_BAN_YOUPERMBANNED, name.c_str(), reasonStr);
break;
}
case BAN_NOTFOUND:
{
handler->PSendSysMessage(LANG_BAN_NOTFOUND, "character", name.c_str());
handler->SetSentErrorMessage(true);
return false;
}
default:
break;
}
return true;
}
static bool HandleBanHelper(BanMode mode, char const* args, ChatHandler* handler)
{
if (!*args)
return false;
char* cnameOrIP = strtok((char*)args, " ");
if (!cnameOrIP)
return false;
std::string nameOrIP = cnameOrIP;
char* durationStr = strtok(NULL, " ");
if (!durationStr || !atoi(durationStr))
return false;
char* reasonStr = strtok(NULL, "");
if (!reasonStr)
return false;
switch (mode)
{
case BAN_ACCOUNT:
if (!AccountMgr::normalizeString(nameOrIP))
{
handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, nameOrIP.c_str());
handler->SetSentErrorMessage(true);
return false;
}
break;
case BAN_CHARACTER:
if (!normalizePlayerName(nameOrIP))
{
handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
handler->SetSentErrorMessage(true);
return false;
}
break;
case BAN_IP:
if (!IsIPAddress(nameOrIP.c_str()))
return false;
break;
}
switch (sWorld->BanAccount(mode, nameOrIP, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName().c_str() : ""))
{
case BAN_SUCCESS:
if (atoi(durationStr) > 0)
handler->PSendSysMessage(LANG_BAN_YOUBANNED, nameOrIP.c_str(), secsToTimeString(TimeStringToSecs(durationStr), true).c_str(), reasonStr);
else
handler->PSendSysMessage(LANG_BAN_YOUPERMBANNED, nameOrIP.c_str(), reasonStr);
break;
case BAN_SYNTAX_ERROR:
return false;
case BAN_NOTFOUND:
switch (mode)
{
default:
handler->PSendSysMessage(LANG_BAN_NOTFOUND, "account", nameOrIP.c_str());
break;
case BAN_CHARACTER:
handler->PSendSysMessage(LANG_BAN_NOTFOUND, "character", nameOrIP.c_str());
break;
case BAN_IP:
handler->PSendSysMessage(LANG_BAN_NOTFOUND, "ip", nameOrIP.c_str());
break;
}
handler->SetSentErrorMessage(true);
return false;
}
return true;
}
static bool ShutdownServer(ChatHandler* handler, char const* args, uint32 shutdownMask, int32 defaultExitCode)
{
if (!*args)
return false;
if (strlen(args) > 255)
return false;
// #delay [#exit_code] [reason]
int32 delay = 0;
char* delayStr = strtok((char*)args, " ");
if (!delayStr)
return false;
if (isNumeric(delayStr))
{
delay = atoi(delayStr);
// Prevent interpret wrong arg value as 0 secs shutdown time
if ((delay == 0 && (delayStr[0] != '0' || delayStr[1] != '\0')) || delay < 0)
return false;
}
else
{
delay = TimeStringToSecs(std::string(delayStr));
if (delay == 0)
return false;
}
char* exitCodeStr = nullptr;
char reason[256] = { 0 };
while (char* nextToken = strtok(nullptr, " "))
{
if (isNumeric(nextToken))
exitCodeStr = nextToken;
else
{
strcat(reason, nextToken);
if (char* remainingTokens = strtok(nullptr, "\0"))
{
strcat(reason, " ");
strcat(reason, remainingTokens);
}
break;
}
}
int32 exitCode = defaultExitCode;
if (exitCodeStr)
if (!ParseExitCode(exitCodeStr, exitCode))
return false;
// Override parameter "delay" with the configuration value if there are still players connected and "force" parameter was not specified
if (delay < (int32)sWorld->getIntConfig(CONFIG_FORCE_SHUTDOWN_THRESHOLD) && !(shutdownMask & SHUTDOWN_MASK_FORCE) && !IsOnlyUser(handler->GetSession()))
{
delay = (int32)sWorld->getIntConfig(CONFIG_FORCE_SHUTDOWN_THRESHOLD);
handler->PSendSysMessage(LANG_SHUTDOWN_DELAYED, delay);
}
sWorld->ShutdownServ(delay, shutdownMask, static_cast<uint8>(exitCode), std::string(reason));
return true;
}
bool ChatHandler::HandleBanAutoCommand(char *args)
{
if (!*args)
return false;
char* cname = strtok ((char*)args, " ");
if (!cname)
return false;
std::string name = cname;
char* creason = strtok (NULL,"");
std::string banreason = creason ? creason : "";
QueryResult *result;
Field *fields;
result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'",name.c_str());
if(!result)
{
PSendSysMessage(LANG_BAN_NOTFOUND,"character",name.c_str());
return true;
}
fields = result->Fetch();
uint32 accId = fields->GetUInt32();
delete result;
std::string oldreason;
uint32 bandate, unbandate;
int32 bandiff;
uint32 max_banid = 0;
uint32 counted_extra_bans = 0;
result = LoginDatabase.PQuery("SELECT bandate,unbandate,banreason FROM account_banned WHERE id=%u", accId);
if(result)
{
do
{
fields = result->Fetch();
bandate = fields[0].GetUInt32();
unbandate = fields[1].GetUInt32();
oldreason = fields[2].GetCppString();
bandiff = unbandate - bandate;
if(oldreason.size() > 10 && oldreason.substr(0,10) == "[AutoBan #")
{
uint32 banid = atoi(oldreason.c_str() + 10);
max_banid = std::max(max_banid, banid);
}
else if(bandiff >= (int32)sWorld.getConfig(CONFIG_UINT32_AUTOBAN_MIN_COUNTED_BANTIME) || bandiff == 0)
{
++counted_extra_bans;
}
}
while (result->NextRow());
delete result;
}
max_banid = std::max(max_banid, counted_extra_bans);
std::string duration = sWorld.GetAutoBanTime(max_banid);
std::stringstream reason;
reason << "[AutoBan #" << (max_banid + 1) << "; " << duration << "] " << banreason;
uint32 duration_secs = TimeStringToSecs(duration);
switch(sWorld.BanAccount(BAN_CHARACTER, name, duration_secs, reason.str().c_str(), m_session ? m_session->GetPlayerName() : ""))
{
case BAN_SUCCESS:
if(atoi(duration.c_str())>0)
PSendSysMessage(LANG_BAN_YOUBANNED,name.c_str(),secsToTimeString(TimeStringToSecs(duration),true).c_str(),reason.str().c_str());
else
PSendSysMessage(LANG_BAN_YOUPERMBANNED,name.c_str(),reason.str().c_str());
break;
case BAN_SYNTAX_ERROR:
return false;
case BAN_NOTFOUND:
PSendSysMessage(LANG_BAN_NOTFOUND,"character",name.c_str());
SetSentErrorMessage(true);
return false;
}
return true;
}
static bool HandleBanCharacterCommand(ChatHandler* handler, char const* args)
{
if (!*args)
return false;
char* nameStr = strtok((char*)args, " ");
if (!nameStr)
return false;
std::string name = nameStr;
char* durationStr = strtok(NULL, " ");
if (!durationStr || !atoi(durationStr))
return false;
char* reasonStr = strtok(NULL, "");
if (!reasonStr)
return false;
if (!normalizePlayerName(name))
{
handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
handler->SetSentErrorMessage(true);
return false;
}
std::string author = handler->GetSession() ? handler->GetSession()->GetPlayerName() : "Server";
switch (sWorld->BanCharacter(name, durationStr, reasonStr, author))
{
case BAN_SUCCESS:
{
if (atoi(durationStr) > 0)
{
if (sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
sWorld->SendWorldText(LANG_BAN_CHARACTER_YOUBANNEDMESSAGE_WORLD, author.c_str(), name.c_str(), secsToTimeString(TimeStringToSecs(durationStr), true).c_str(), reasonStr);
else
handler->PSendSysMessage(LANG_BAN_YOUBANNED, name.c_str(), secsToTimeString(TimeStringToSecs(durationStr), true).c_str(), reasonStr);
}
else
{
if (sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
sWorld->SendWorldText(LANG_BAN_CHARACTER_YOUPERMBANNEDMESSAGE_WORLD, author.c_str(), name.c_str(), reasonStr);
else
handler->PSendSysMessage(LANG_BAN_YOUPERMBANNED, name.c_str(), reasonStr);
}
break;
}
case BAN_NOTFOUND:
{
handler->PSendSysMessage(LANG_BAN_NOTFOUND, "character", name.c_str());
handler->SetSentErrorMessage(true);
return false;
}
default:
break;
}
return true;
}
