ChatHandler Class Reference

#include <Chat.h>

Public Member Functions
WorldSession *	GetSession ()
	ChatHandler (WorldSession *session)
virtual	~ChatHandler ()
virtual char const *	GetTrinityString (uint32 entry) const
virtual void	SendSysMessage (char const *str, bool escapeCharacters=false)
void	SendSysMessage (uint32 entry)
template<typename... Args>
void	PSendSysMessage (const char *fmt, Args &&...args)
template<typename... Args>
void	PSendSysMessage (uint32 entry, Args &&...args)
template<typename... Args>
std::string	PGetParseString (uint32 entry, Args &&...args) const
bool	ParseCommands (const char *text)
bool	isValidChatMessage (const char *msg)
void	SendGlobalSysMessage (const char *str)
bool	hasStringAbbr (const char *name, const char *part)
virtual bool	isAvailable (ChatCommand const &cmd) const
virtual bool	HasPermission (uint32 permission) const
virtual std::string	GetNameLink () const
virtual bool	needReportToTarget (Player *chr) const
virtual LocaleConstant	GetSessionDbcLocale () const
virtual int	GetSessionDbLocaleIndex () const
bool	HasLowerSecurity (Player *target, ObjectGuid guid, bool strong=false)
bool	HasLowerSecurityAccount (WorldSession *target, uint32 account, bool strong=false)
void	SendGlobalGMSysMessage (const char *str)
Player *	getSelectedPlayer ()
Creature *	getSelectedCreature ()
Unit *	getSelectedUnit ()
WorldObject *	getSelectedObject ()
Player *	getSelectedPlayerOrSelf ()
char *	extractKeyFromLink (char *text, char const *linkType, char **something1=NULL)
char *	extractKeyFromLink (char *text, char const *const *linkTypes, int *found_idx, char **something1=NULL)
void	extractOptFirstArg (char *args, char **arg1, char **arg2)
char *	extractQuotedArg (char *args)
uint32	extractSpellIdFromLink (char *text)
ObjectGuid	extractGuidFromLink (char *text)
GameTele const *	extractGameTeleFromLink (char *text)
bool	GetPlayerGroupAndGUIDByName (const char *cname, Player *&player, Group *&group, ObjectGuid &guid, bool offline=false)
std::string	extractPlayerNameFromLink (char *text)
bool	extractPlayerTarget (char *args, Player **player, ObjectGuid *player_guid=NULL, std::string *player_name=NULL)
std::string	playerLink (std::string const &name) const
std::string	GetNameLink (Player *chr) const
GameObject *	GetNearbyGameObject ()
GameObject *	GetObjectGlobalyWithGuidOrNearWithDbGuid (ObjectGuid::LowType lowguid, uint32 entry)
bool	HasSentErrorMessage () const
void	SetSentErrorMessage (bool val)
bool	ShowHelpForCommand (std::vector< ChatCommand > const &table, const char *cmd)

Static Public Member Functions
static char *	LineFromMessage (char *&pos)
static std::vector < ChatCommand > const &	getCommandTable ()
static bool	LoadCommandTable ()
static void	SetLoadCommandTable (bool val)

Protected Member Functions
	ChatHandler ()
bool	ExecuteCommandInTable (std::vector< ChatCommand > const &table, const char *text, std::string const &fullcmd)
bool	ShowHelpForSubCommands (std::vector< ChatCommand > const &table, char const *cmd, char const *subcmd)

Static Protected Member Functions
static bool	SetDataForCommandInTable (std::vector< ChatCommand > &table, const char *text, uint32 permission, std::string const &help, std::string const &fullcommand)

Private Attributes
WorldSession *	m_session
bool	sentErrorMessage

Static Private Attributes
static bool	load_command_table = true

Constructor & Destructor Documentation

ChatHandler::ChatHandler ( WorldSession *  session )

inlineexplicit

: m_session(session), sentErrorMessage(false) { }

virtual ChatHandler::~ChatHandler ( )

inlinevirtual

{ }

ChatHandler::ChatHandler ( )

inlineexplicitprotected

: m_session(NULL), sentErrorMessage(false) { } // for CLI subclass

Member Function Documentation

bool ChatHandler::ExecuteCommandInTable ( std::vector< ChatCommand > const &  table, const char *  text, std::string const &  fullcmd  )

protected

{
 char const* oldtext = text;
 std::string cmd = "";

 while (*text != ' ' && *text != '\0')
 {
 cmd += *text;
 ++text;
 }

 while (*text == ' ') ++text;

 for (uint32 i = 0; i < table.size(); ++i)
 {
 if (!hasStringAbbr(table[i].Name, cmd.c_str()))
 continue;

 bool match = false;
 if (strlen(table[i].Name) > cmd.length())
 {
 for (uint32 j = 0; j < table.size(); ++j)
 {
 if (!hasStringAbbr(table[j].Name, cmd.c_str()))
 continue;

 if (strcmp(table[j].Name, cmd.c_str()) == 0)
 {
 match = true;
 break;
 }
 }
 }
 if (match)
 continue;

 // select subcommand from child commands list
 if (!table[i].ChildCommands.empty())
 {
 if (!ExecuteCommandInTable(table[i].ChildCommands, text, fullcmd))
 {
 if (text[0] != '\0')
 SendSysMessage(LANG_NO_SUBCMD);
 else
 SendSysMessage(LANG_CMD_SYNTAX);

 ShowHelpForCommand(table[i].ChildCommands, text);
 }

 return true;
 }

 // must be available and have handler
 if (!table[i].Handler || !isAvailable(table[i]))
 continue;

 SetSentErrorMessage(false);
 // table[i].Name == "" is special case: send original command to handler
 if ((table[i].Handler)(this, table[i].Name[0] != '\0' ? text : oldtext))
 {
 if (!m_session) // ignore console
 return true;

 Player* player = m_session->GetPlayer();
 if (!AccountMgr::IsPlayerAccount(m_session->GetSecurity()))
 {
 ObjectGuid guid = player->GetTarget();
 uint32 areaId = player->GetAreaId();
 std::string areaName = "Unknown";
 std::string zoneName = "Unknown";
 if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
 {
 areaName = area->AreaName_lang;
 if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
 zoneName = zone->AreaName_lang;
 }

 sLog->outCommand(m_session->GetAccountId(), "Command: %s [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
 fullcmd.c_str(), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
 m_session->GetAccountId(), player->GetPositionX(), player->GetPositionY(),
 player->GetPositionZ(), player->GetMapId(),
 player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
 areaId, areaName.c_str(), zoneName.c_str(),
 (player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
 guid.ToString().c_str());
 }
 }
 // some commands have custom error messages. Don't send the default one in these cases.
 else if (!HasSentErrorMessage())
 {
 if (!table[i].Help.empty())
 SendSysMessage(table[i].Help.c_str());
 else
 SendSysMessage(LANG_CMD_SYNTAX);
 }

 return true;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GameTele const * ChatHandler::extractGameTeleFromLink

(

char *

text

)

{
 // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
 char* cId = extractKeyFromLink(text, "Htele");
 if (!cId)
 return NULL;

 // id case (explicit or from shift link)
 if (cId[0] >= '0' || cId[0] >= '9')
 if (uint32 id = atoi(cId))
 return sObjectMgr->GetGameTele(id);

 return sObjectMgr->GetGameTele(cId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid ChatHandler::extractGuidFromLink

(

char *

text

)

{
 int type = 0;

 // |color|Hcreature:creature_guid|h[name]|h|r
 // |color|Hgameobject:go_guid|h[name]|h|r
 // |color|Hplayer:name|h[name]|h|r
 char* idS = extractKeyFromLink(text, guidKeys, &type);
 if (!idS)
 return ObjectGuid::Empty;

 switch (type)
 {
 case SPELL_LINK_PLAYER:
 {
 std::string name = idS;
 if (!normalizePlayerName(name))
 return ObjectGuid::Empty;

 if (Player* player = ObjectAccessor::FindPlayerByName(name))
 return player->GetGUID();

 return ObjectMgr::GetPlayerGUIDByName(name);
 }
 case SPELL_LINK_CREATURE:
 {
 ObjectGuid::LowType lowguid = strtoull(idS, nullptr, 10);

 if (CreatureData const* data = sObjectMgr->GetCreatureData(lowguid))
 return ObjectGuid::Create<HighGuid::Creature>(data->mapid, data->id, lowguid);
 else
 return ObjectGuid::Empty;
 }
 case SPELL_LINK_GAMEOBJECT:
 {
 ObjectGuid::LowType lowguid = strtoull(idS, nullptr, 10);

 if (GameObjectData const* data = sObjectMgr->GetGOData(lowguid))
 return ObjectGuid::Create<HighGuid::GameObject>(data->mapid, data->id, lowguid);
 else
 return ObjectGuid::Empty;
 }
 }

 // unknown type?
 return ObjectGuid::Empty;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * ChatHandler::extractKeyFromLink	(	char *	text,
		char const *	linkType,
		char **	something1 = NULL
	)

{
 // skip empty
 if (!text)
 return NULL;

 // skip spaces
 while (*text == ' '||*text == '\t'||*text == '\b')
 ++text;

 if (!*text)
 return NULL;

 // return non link case
 if (text[0] != '|')
 return strtok(text, " ");

 // [name] Shift-click form |color|linkType:key|h[name]|h|r
 // or
 // [name] Shift-click form |color|linkType:key:something1:...:somethingN|h[name]|h|r

 char* check = strtok(text, "|"); // skip color
 if (!check)
 return NULL; // end of data

 char* cLinkType = strtok(NULL, ":"); // linktype
 if (!cLinkType)
 return NULL; // end of data

 if (strcmp(cLinkType, linkType) != 0)
 {
 strtok(NULL, " "); // skip link tail (to allow continue strtok(NULL, s) use after retturn from function
 SendSysMessage(LANG_WRONG_LINK_TYPE);
 return NULL;
 }

 char* cKeys = strtok(NULL, "|"); // extract keys and values
 char* cKeysTail = strtok(NULL, "");

 char* cKey = strtok(cKeys, ":|"); // extract key
 if (something1)
 *something1 = strtok(NULL, ":|"); // extract something

 strtok(cKeysTail, "]"); // restart scan tail and skip name with possible spaces
 strtok(NULL, " "); // skip link tail (to allow continue strtok(NULL, s) use after return from function
 return cKey;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * ChatHandler::extractKeyFromLink	(	char *	text,
		char const *const *	linkTypes,
		int *	found_idx,
		char **	something1 = NULL
	)

{
 // skip empty
 if (!text)
 return NULL;

 // skip spaces
 while (*text == ' '||*text == '\t'||*text == '\b')
 ++text;

 if (!*text)
 return NULL;

 // return non link case
 if (text[0] != '|')
 return strtok(text, " ");

 // [name] Shift-click form |color|linkType:key|h[name]|h|r
 // or
 // [name] Shift-click form |color|linkType:key:something1:...:somethingN|h[name]|h|r
 // or
 // [name] Shift-click form |linkType:key|h[name]|h|r

 char* tail;

 if (text[1] == 'c')
 {
 char* check = strtok(text, "|"); // skip color
 if (!check)
 return NULL; // end of data

 tail = strtok(NULL, ""); // tail
 }
 else
 tail = text+1; // skip first |

 char* cLinkType = strtok(tail, ":"); // linktype
 if (!cLinkType)
 return NULL; // end of data

 for (int i = 0; linkTypes[i]; ++i)
 {
 if (strcmp(cLinkType, linkTypes[i]) == 0)
 {
 char* cKeys = strtok(NULL, "|"); // extract keys and values
 char* cKeysTail = strtok(NULL, "");

 char* cKey = strtok(cKeys, ":|"); // extract key
 if (something1)
 *something1 = strtok(NULL, ":|"); // extract something

 strtok(cKeysTail, "]"); // restart scan tail and skip name with possible spaces
 strtok(NULL, " "); // skip link tail (to allow continue strtok(NULL, s) use after return from function
 if (found_idx)
 *found_idx = i;
 return cKey;
 }
 }

 strtok(NULL, " "); // skip link tail (to allow continue strtok(NULL, s) use after return from function
 SendSysMessage(LANG_WRONG_LINK_TYPE);
 return NULL;
}

Here is the call graph for this function:

void ChatHandler::extractOptFirstArg	(	char *	args,
		char **	arg1,
		char **	arg2
	)

{
 char* p1 = strtok(args, " ");
 char* p2 = strtok(NULL, " ");

 if (!p2)
 {
 p2 = p1;
 p1 = NULL;
 }

 if (arg1)
 *arg1 = p1;

 if (arg2)
 *arg2 = p2;
}

Here is the caller graph for this function:

std::string ChatHandler::extractPlayerNameFromLink

(

char *

text

)

{
 // |color|Hplayer:name|h[name]|h|r
 char* name_str = extractKeyFromLink(text, "Hplayer");
 if (!name_str)
 return "";

 std::string name = name_str;
 if (!normalizePlayerName(name))
 return "";

 return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::extractPlayerTarget	(	char *	args,
		Player **	player,
		ObjectGuid *	player_guid = NULL,
		std::string *	player_name = NULL
	)

{
 if (args && *args)
 {
 std::string name = extractPlayerNameFromLink(args);
 if (name.empty())
 {
 SendSysMessage(LANG_PLAYER_NOT_FOUND);
 SetSentErrorMessage(true);
 return false;
 }

 Player* pl = ObjectAccessor::FindPlayerByName(name);

 // if allowed player pointer
 if (player)
 *player = pl;

 // if need guid value from DB (in name case for check player existence)
 ObjectGuid guid = !pl && (player_guid || player_name) ? ObjectMgr::GetPlayerGUIDByName(name) : ObjectGuid::Empty;

 // if allowed player guid (if no then only online players allowed)
 if (player_guid)
 *player_guid = pl ? pl->GetGUID() : guid;

 if (player_name)
 *player_name = pl || !guid.IsEmpty() ? name : "";
 }
 else
 {
 Player* pl = getSelectedPlayerOrSelf();
 // if allowed player pointer
 if (player)
 *player = pl;
 // if allowed player guid (if no then only online players allowed)
 if (player_guid)
 *player_guid = pl ? pl->GetGUID() : ObjectGuid::Empty;

 if (player_name)
 *player_name = pl ? pl->GetName() : "";
 }

 // some from req. data must be provided (note: name is empty if player not exist)
 if ((!player || !*player) && (!player_guid || !*player_guid) && (!player_name || player_name->empty()))
 {
 SendSysMessage(LANG_PLAYER_NOT_FOUND);
 SetSentErrorMessage(true);
 return false;
 }

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * ChatHandler::extractQuotedArg

(

char *

args

)

{
 if (!args || !*args)
 return NULL;

 if (*args == '"')
 return strtok(args+1, "\"");
 else
 {
 // skip spaces
 while (*args == ' ')
 {
 args += 1;
 continue;
 }

 // return NULL if we reached the end of the string
 if (!*args)
 return NULL;

 // since we skipped all spaces, we expect another token now
 if (*args == '"')
 {
 // return an empty string if there are 2 "" in a row.
 // strtok doesn't handle this case
 if (*(args + 1) == '"')
 {
 strtok(args, " ");
 static char arg[1];
 arg[0] = '\0';
 return arg;
 }
 else
 return strtok(args + 1, "\"");
 }
 else
 return NULL;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 ChatHandler::extractSpellIdFromLink

(

char *

text

)

{
 // number or [name] Shift-click form |color|Henchant:recipe_spell_id|h[prof_name: recipe_name]|h|r
 // number or [name] Shift-click form |color|Hglyph:glyph_slot_id:glyph_prop_id|h[%s]|h|r
 // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
 // number or [name] Shift-click form |color|Htalent:talent_id, rank|h[name]|h|r
 // number or [name] Shift-click form |color|Htrade:spell_id, skill_id, max_value, cur_value|h[name]|h|r
 int type = 0;
 char* param1_str = NULL;
 char* idS = extractKeyFromLink(text, spellKeys, &type, &param1_str);
 if (!idS)
 return 0;

 uint32 id = atoul(idS);

 switch (type)
 {
 case SPELL_LINK_SPELL:
 return id;
 case SPELL_LINK_TALENT:
 {
 // talent
 TalentEntry const* talentEntry = sTalentStore.LookupEntry(id);
 if (!talentEntry)
 return 0;

 return talentEntry->SpellID;
 }
 case SPELL_LINK_ENCHANT:
 case SPELL_LINK_TRADE:
 return id;
 case SPELL_LINK_GLYPH:
 {
 uint32 glyph_prop_id = param1_str ? atoul(param1_str) : 0;

 GlyphPropertiesEntry const* glyphPropEntry = sGlyphPropertiesStore.LookupEntry(glyph_prop_id);
 if (!glyphPropEntry)
 return 0;

 return glyphPropEntry->SpellID;
 }
 }

 // unknown type?
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< ChatCommand > const & ChatHandler::getCommandTable ( )

static

{
 static std::vector<ChatCommand> commandTableCache;

 if (LoadCommandTable())
 {
 SetLoadCommandTable(false);

 std::vector<ChatCommand> cmds = sScriptMgr->GetChatCommands();
 commandTableCache.swap(cmds);

 PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS);
 PreparedQueryResult result = WorldDatabase.Query(stmt);
 if (result)
 {
 do
 {
 Field* fields = result->Fetch();
 std::string name = fields[0].GetString();

 SetDataForCommandInTable(commandTableCache, name.c_str(), fields[1].GetUInt16(), fields[2].GetString(), name);
 }
 while (result->NextRow());
 }
 }

 return commandTableCache;
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual std::string ChatHandler::GetNameLink ( ) const

inlinevirtual

Reimplemented in CliHandler.

{ return GetNameLink(m_session->GetPlayer()); }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string ChatHandler::GetNameLink

(

Player *

chr

)

const

{
 return playerLink(chr->GetName());
}

Here is the call graph for this function:

GameObject * ChatHandler::GetNearbyGameObject

(

)

{
 if (!m_session)
 return NULL;

 Player* pl = m_session->GetPlayer();
 GameObject* obj = NULL;
 Trinity::NearestGameObjectCheck check(*pl);
 Trinity::GameObjectLastSearcher<Trinity::NearestGameObjectCheck> searcher(pl, obj, check);
 pl->VisitNearbyGridObject(SIZE_OF_GRIDS, searcher);
 return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GameObject * ChatHandler::GetObjectGlobalyWithGuidOrNearWithDbGuid	(	ObjectGuid::LowType	lowguid,
		uint32	entry
	)

{
 if (!m_session)
 return NULL;

 Player* pl = m_session->GetPlayer();

 GameObject* obj = pl->GetMap()->GetGameObject(ObjectGuid::Create<HighGuid::GameObject>(pl->GetMapId(), entry, lowguid));

 if (!obj && sObjectMgr->GetGOData(lowguid)) // guid is DB guid of object
 {
 auto bounds = pl->GetMap()->GetGameObjectBySpawnIdStore().equal_range(lowguid);
 if (bounds.first == bounds.second)
 return nullptr;

 return bounds.first->second;
 }

 return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::GetPlayerGroupAndGUIDByName	(	const char *	cname,
		Player *&	player,
		Group *&	group,
		ObjectGuid &	guid,
		bool	offline = false
	)

{
 player = NULL;
 guid.Clear();

 if (cname)
 {
 std::string name = cname;
 if (!name.empty())
 {
 if (!normalizePlayerName(name))
 {
 PSendSysMessage(LANG_PLAYER_NOT_FOUND);
 SetSentErrorMessage(true);
 return false;
 }

 player = ObjectAccessor::FindPlayerByName(name);
 if (offline)
 guid = ObjectMgr::GetPlayerGUIDByName(name.c_str());
 }
 }

 if (player)
 {
 group = player->GetGroup();
 if (!guid || !offline)
 guid = player->GetGUID();
 }
 else
 {
 if (getSelectedPlayer())
 player = getSelectedPlayer();
 else
 player = m_session->GetPlayer();

 if (!guid || !offline)
 guid = player->GetGUID();
 group = player->GetGroup();
 }

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Creature * ChatHandler::getSelectedCreature

(

)

{
 if (!m_session)
 return NULL;

 return ObjectAccessor::GetCreatureOrPetOrVehicle(*m_session->GetPlayer(), m_session->GetPlayer()->GetTarget());
}

Here is the call graph for this function:

Here is the caller graph for this function:

WorldObject * ChatHandler::getSelectedObject

(

)

{
 if (!m_session)
 return NULL;

 ObjectGuid guid = m_session->GetPlayer()->GetTarget();

 if (!guid)
 return GetNearbyGameObject();

 return ObjectAccessor::GetUnit(*m_session->GetPlayer(), guid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Player * ChatHandler::getSelectedPlayer

(

)

{
    if (!m_session)
        return NULL;

    ObjectGuid selected = m_session->GetPlayer()->GetTarget();
    if (!selected)
        return m_session->GetPlayer();

    return ObjectAccessor::FindConnectedPlayer(selected);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Player * ChatHandler::getSelectedPlayerOrSelf

(

)

{
    if (!m_session)
        return NULL;

    ObjectGuid selected = m_session->GetPlayer()->GetTarget();
    if (!selected)
        return m_session->GetPlayer();

    // first try with selected target
    Player* targetPlayer = ObjectAccessor::FindConnectedPlayer(selected);
    // if the target is not a player, then return self
    if (!targetPlayer)
        targetPlayer = m_session->GetPlayer();

    return targetPlayer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Unit * ChatHandler::getSelectedUnit

(

)

{
    if (!m_session)
        return NULL;

    if (Unit* selected = m_session->GetPlayer()->GetSelectedUnit())
        return selected;

    return m_session->GetPlayer();
}

Here is the call graph for this function:

Here is the caller graph for this function:

WorldSession* ChatHandler::GetSession ( )

inline

{ return m_session; }

LocaleConstant ChatHandler::GetSessionDbcLocale ( ) const

virtual

Reimplemented in CliHandler.

{
    return m_session->GetSessionDbcLocale();
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ChatHandler::GetSessionDbLocaleIndex ( ) const

virtual

Reimplemented in CliHandler.

{
    return m_session->GetSessionDbLocaleIndex();
}

Here is the call graph for this function:

Here is the caller graph for this function:

char const * ChatHandler::GetTrinityString ( uint32  entry ) const

virtual

Reimplemented in CliHandler.

{
    return m_session->GetTrinityString(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::HasLowerSecurity	(	Player *	target,
		ObjectGuid	guid,
		bool	strong = false
	)

{
    WorldSession* target_session = NULL;
    uint32 target_account = 0;

    if (target)
        target_session = target->GetSession();
    else if (!guid.IsEmpty())
        target_account = ObjectMgr::GetPlayerAccountIdByGUID(guid);

    if (!target_session && !target_account)
    {
        SendSysMessage(LANG_PLAYER_NOT_FOUND);
        SetSentErrorMessage(true);
        return true;
    }

    return HasLowerSecurityAccount(target_session, target_account, strong);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::HasLowerSecurityAccount	(	WorldSession *	target,
		uint32	account,
		bool	strong = false
	)

{
    uint32 target_sec;

    // allow everything from console and RA console
    if (!m_session)
        return false;

    // ignore only for non-players for non strong checks (when allow apply command at least to same sec level)
    if (m_session->HasPermission(rbac::RBAC_PERM_CHECK_FOR_LOWER_SECURITY) && !strong && !sWorld->getBoolConfig(CONFIG_GM_LOWER_SECURITY))
        return false;

    if (target)
        target_sec = target->GetSecurity();
    else if (target_account)
        target_sec = AccountMgr::GetSecurity(target_account, realm.Id.Realm);
    else
        return true;                                        // caller must report error for (target == NULL && target_account == 0)

    AccountTypes target_ac_sec = AccountTypes(target_sec);
    if (m_session->GetSecurity() < target_ac_sec || (strong && m_session->GetSecurity() <= target_ac_sec))
    {
        SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
        SetSentErrorMessage(true);
        return true;
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool ChatHandler::HasPermission ( uint32  permission ) const

inlinevirtual

Reimplemented in CliHandler.

{ return m_session->HasPermission(permission); }

Here is the caller graph for this function:

bool ChatHandler::HasSentErrorMessage ( ) const

inline

{ return sentErrorMessage; }

Here is the caller graph for this function:

bool ChatHandler::hasStringAbbr	(	const char *	name,
		const char *	part
	)

{
    // non "" command
    if (*name)
    {
        // "" part from non-"" command
        if (!*part)
            return false;

        while (true)
        {
            if (!*part)
                return true;
            else if (!*name)
                return false;
            else if (tolower(*name) != tolower(*part))
                return false;
            ++name; ++part;
        }
    }
    // allow with any for ""

    return true;
}

Here is the caller graph for this function:

bool ChatHandler::isAvailable ( ChatCommand const &  cmd ) const

virtual

Reimplemented in CliHandler.

{
    return HasPermission(cmd.Permission);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::isValidChatMessage

(

const char *

msg

)

{
/*
Valid examples:
|cffa335ee|Hitem:812:0:0:0:0:0:0:0:70|h[Glowing Brightwood Staff]|h|r
|cff808080|Hquest:2278:47|h[The Platinum Discs]|h|r
|cffffd000|Htrade:4037:1:150:1:6AAAAAAAAAAAAAAAAAAAAAAOAADAAAAAAAAAAAAAAAAIAAAAAAAAA|h[Engineering]|h|r
|cff4e96f7|Htalent:2232:-1|h[Taste for Blood]|h|r
|cff71d5ff|Hspell:21563|h[Command]|h|r
|cffffd000|Henchant:3919|h[Engineering: Rough Dynamite]|h|r
|cffffff00|Hachievement:546:0000000000000001:0:0:0:-1:0:0:0:0|h[Safe Deposit]|h|r
|cff66bbff|Hglyph:21:762|h[Glyph of Bladestorm]|h|r

| will be escaped to ||
*/

    if (strlen(message) > 255)
        return false;

    // more simple checks
    if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY) < 3)
    {
        const char validSequence[6] = "cHhhr";
        const char* validSequenceIterator = validSequence;
        const std::string validCommands = "cHhr|";

        while (*message)
        {
            // find next pipe command
            message = strchr(message, '|');

            if (!message)
                return true;

            ++message;
            char commandChar = *message;
            if (validCommands.find(commandChar) == std::string::npos)
                return false;

            ++message;
            // validate sequence
            if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY) == 2)
            {
                if (commandChar == *validSequenceIterator)
                {
                    if (validSequenceIterator == validSequence + 4)
                        validSequenceIterator = validSequence;
                    else
                        ++validSequenceIterator;
                }
                else
                    return false;
            }
        }
        return true;
    }

    return LinkExtractor(message).IsValidMessage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* ChatHandler::LineFromMessage ( char *&  pos )

inlinestatic

{ char* start = strtok(pos, "\n"); pos = NULL; return start; }

Here is the caller graph for this function:

static bool ChatHandler::LoadCommandTable ( )

inlinestatic

{ return load_command_table; }

Here is the caller graph for this function:

bool ChatHandler::needReportToTarget ( Player *  chr ) const

virtual

Reimplemented in CliHandler.

{
    Player* pl = m_session->GetPlayer();
    return pl != chr && pl->IsVisibleGloballyFor(chr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::ParseCommands

(

const char *

text

)

chat case (.command or !command format)

ignore single . and ! in line

ignore messages staring from many dots.

skip first . or ! (in console allowed use command with . and ! and without its)

{
    ASSERT(text);
    ASSERT(*text);

    std::string fullcmd = text;

    if (m_session)
    {
        if (text[0] != '!' && text[0] != '.')
            return false;
    }

    if (strlen(text) < 2)
        return false;
    // original `text` can't be used. It content destroyed in command code processing.

    if ((text[0] == '.' && text[1] == '.') || (text[0] == '!' && text[1] == '!'))
        return false;

    if (text[0] == '!' || text[0] == '.')
        ++text;

    if (!ExecuteCommandInTable(getCommandTable(), text, fullcmd))
    {
        if (m_session && !m_session->HasPermission(rbac::RBAC_PERM_COMMANDS_NOTIFY_COMMAND_NOT_FOUND_ERROR))
            return false;

        SendSysMessage(LANG_NO_CMD);
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename... Args>

std::string ChatHandler::PGetParseString ( uint32  entry, Args &&...  args  ) const

inline

        {
            return Trinity::StringFormat(GetTrinityString(entry), std::forward<Args>(args)...);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string ChatHandler::playerLink ( std::string const &  name ) const

inline

{ return m_session ? "|cffffffff|Hplayer:"+name+"|h["+name+"]|h|r" : name; }

Here is the caller graph for this function:

template<typename... Args>

void ChatHandler::PSendSysMessage ( const char *  fmt, Args &&...  args  )

inline

        {
            SendSysMessage(Trinity::StringFormat(fmt, std::forward<Args>(args)...).c_str());
        }

Here is the call graph for this function:

template<typename... Args>

void ChatHandler::PSendSysMessage ( uint32  entry, Args &&...  args  )

inline

        {
            SendSysMessage(PGetParseString(entry, std::forward<Args>(args)...).c_str());
        }

void ChatHandler::SendGlobalGMSysMessage

(

const char *

str

)

{
    // Chat output
    WorldPackets::Chat::Chat packet;

    // need copy to prevent corruption by strtok call in LineFromMessage original string
    char* buf = strdup(str);
    char* pos = buf;

    while (char* line = LineFromMessage(pos))
    {
        packet.Initialize(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, line);
        sWorld->SendGlobalGMMessage(packet.Write());
    }

    free(buf);
}

Here is the call graph for this function:

void ChatHandler::SendGlobalSysMessage

(

const char *

str

)

{
    // Chat output
    WorldPackets::Chat::Chat packet;

    // need copy to prevent corruption by strtok call in LineFromMessage original string
    char* buf = strdup(str);
    char* pos = buf;

    while (char* line = LineFromMessage(pos))
    {
        packet.Initialize(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, line);
        sWorld->SendGlobalMessage(packet.Write());
    }

    free(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ChatHandler::SendSysMessage ( char const *  str, bool  escapeCharacters = false  )

virtual

Reimplemented in CliHandler.

{
    WorldPackets::Chat::Chat packet;

    // need copy to prevent corruption by strtok call in LineFromMessage original string
    char* buf;
    char* pos;

    if (escapeCharacters && strchr(str, '|'))
    {
        size_t startPos = 0;
        std::ostringstream o;
        while (const char* charPos = strchr(str + startPos, '|'))
        {
            o.write(str + startPos, charPos - str - startPos);
            o << "||";
            startPos = charPos - str + 1;
        }
        o.write(str + startPos, strlen(str) - startPos);
        buf = strdup(o.str().c_str());
    }
    else
    {
        buf = strdup(str);
    }

    pos = buf;

    while (char* line = LineFromMessage(pos))
    {
        packet.Initialize(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, line);
        m_session->SendPacket(packet.Write());
    }

    free(buf);
}

Here is the call graph for this function:

void ChatHandler::SendSysMessage

(

uint32

entry

)

{
    SendSysMessage(GetTrinityString(entry));
}

Here is the call graph for this function:

bool ChatHandler::SetDataForCommandInTable ( std::vector< ChatCommand > &  table, const char *  text, uint32  permission, std::string const &  help, std::string const &  fullcommand  )

staticprotected

{
    std::string cmd = "";

    while (*text != ' ' && *text != '\0')
    {
        cmd += *text;
        ++text;
    }

    while (*text == ' ') ++text;

    for (uint32 i = 0; i < table.size(); i++)
    {
        // for data fill use full explicit command names
        if (table[i].Name != cmd)
            continue;

        // select subcommand from child commands list (including "")
        if (!table[i].ChildCommands.empty())
        {
            if (SetDataForCommandInTable(table[i].ChildCommands, text, permission, help, fullcommand))
                return true;
            else if (*text)
                return false;

            // fail with "" subcommands, then use normal level up command instead
        }
        // expected subcommand by full name DB content
        else if (*text)
        {
            TC_LOG_ERROR("sql.sql", "Table `command` have unexpected subcommand '%s' in command '%s', skip.", text, fullcommand.c_str());
            return false;
        }

        if (table[i].Permission != permission)
            TC_LOG_INFO("misc", "Table `command` overwrite for command '%s' default permission (%u) by %u", fullcommand.c_str(), table[i].Permission, permission);

        table[i].Permission = permission;
        table[i].Help          = help;
        return true;
    }

    // in case "" command let process by caller
    if (!cmd.empty())
    {
        if (&table == &getCommandTable())
            TC_LOG_ERROR("sql.sql", "Table `command` have not existed command '%s', skip.", cmd.c_str());
        else
            TC_LOG_ERROR("sql.sql", "Table `command` have not existed subcommand '%s' in command '%s', skip.", cmd.c_str(), fullcommand.c_str());
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ChatHandler::SetLoadCommandTable ( bool  val )

inlinestatic

{ load_command_table = val; }

Here is the caller graph for this function:

void ChatHandler::SetSentErrorMessage ( bool  val )

inline

{ sentErrorMessage = val; }

bool ChatHandler::ShowHelpForCommand	(	std::vector< ChatCommand > const &	table,
		const char *	cmd
	)

{
    if (*cmd)
    {
        for (uint32 i = 0; i < table.size(); ++i)
        {
            // must be available (ignore handler existence for show command with possible available subcommands)
            if (!isAvailable(table[i]))
                continue;

            if (!hasStringAbbr(table[i].Name, cmd))
                continue;

            // have subcommand
            char const* subcmd = (*cmd) ? strtok(NULL, " ") : "";

            if (!table[i].ChildCommands.empty() && subcmd && *subcmd)
            {
                if (ShowHelpForCommand(table[i].ChildCommands, subcmd))
                    return true;
            }

            if (!table[i].Help.empty())
                SendSysMessage(table[i].Help.c_str());

            if (!table[i].ChildCommands.empty())
                if (ShowHelpForSubCommands(table[i].ChildCommands, table[i].Name, subcmd ? subcmd : ""))
                    return true;

            return !table[i].Help.empty();
        }
    }
    else
    {
        for (uint32 i = 0; i < table.size(); ++i)
        {
            // must be available (ignore handler existence for show command with possible available subcommands)
            if (!isAvailable(table[i]))
                continue;

            if (strlen(table[i].Name))
                continue;

            if (!table[i].Help.empty())
                SendSysMessage(table[i].Help.c_str());

            if (!table[i].ChildCommands.empty())
                if (ShowHelpForSubCommands(table[i].ChildCommands, "", ""))
                    return true;

            return !table[i].Help.empty();
        }
    }

    return ShowHelpForSubCommands(table, "", cmd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ChatHandler::ShowHelpForSubCommands ( std::vector< ChatCommand > const &  table, char const *  cmd, char const *  subcmd  )

protected

{
    std::string list;
    for (uint32 i = 0; i < table.size(); ++i)
    {
        // must be available (ignore handler existence for show command with possible available subcommands)
        if (!isAvailable(table[i]))
            continue;

        // for empty subcmd show all available
        if (*subcmd && !hasStringAbbr(table[i].Name, subcmd))
            continue;

        if (m_session)
            list += "\n    ";
        else
            list += "\n\r    ";

        list += table[i].Name;

        if (!table[i].ChildCommands.empty())
            list += " ...";
    }

    if (list.empty())
        return false;

    if (&table == &getCommandTable())
    {
        SendSysMessage(LANG_AVIABLE_CMD);
        PSendSysMessage("%s", list.c_str());
    }
    else
        PSendSysMessage(LANG_SUBCMDS_LIST, cmd, list.c_str());

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool ChatHandler::load_command_table = true

staticprivate

WorldSession* ChatHandler::m_session

private

bool ChatHandler::sentErrorMessage

private

---

The documentation for this class was generated from the following files:

• src/server/game/Chat/Chat.h
• src/server/game/Chat/Chat.cpp