Exemplo n.º 1
0
bool ClientSession::checkMsgForCommand(std::string msg, WorldPacket & recv_data)
{
    if (msg.c_str()[0] == '!' || msg.c_str()[0] == '.')
    {
        if (strContains(msg, ".mute", false) || strContains(msg, ".unmute", false))
        {
            if (ChatHandler(this).ParseDotCommands(msg.c_str()) > 0)
                SendPacketToNode(&recv_data);
        }
        else if (strContains(msg, ".ticket", false))
            ChatHandler(this).ParseDotCommands(msg.c_str());
        else
            SendPacketToNode(&recv_data);
        return true;
    }
    return false;
}
Exemplo n.º 2
0
	std::string rangeFromOverflow(const std::string &prefix, const std::string &done){
		if (strContains(overflow, prefix)){
			if (strEndsWith(overflow, prefix)) return prefix;
			v1.clear();
			std::string tmp = overflow.substr(overflow.find(prefix) + prefix.length());
			auto pos = tmp.find(done);
			if (pos != std::string::npos){
				overflow = tmp.substr(pos);
				return prefix + tmp.substr(0,pos);
			}
			else return prefix + tmp;
		}
		return "";
	}
Exemplo n.º 3
0
	std::string reallyRead(const std::string &prefix, const std::string &done) {
		std::string acc = rangeFromOverflow(prefix, done);
		std::stringstream racc;
		racc << acc;
		if (strContains(overflow,done)) return post_substr(acc,prefix);
		while (r.good()){
			std::getline(r,acc);
			std::string::size_type split = acc.find(done);
			if (split != std::string::npos){
				overflow = acc.substr(split);
				racc << acc.substr(0,split);
				std::string ret_w_prefix = racc.str();
				return post_substr(ret_w_prefix,prefix);
			}
			else racc << acc;
		}
		
		throw call_cont<std::string> (post_substr(racc.str(),prefix));
	}
Exemplo n.º 4
0
void ClientSession::HandleMessagechatOpcode(WorldPacket & recv_data)
{
    uint32 type;
    uint32 lang;

    recv_data >> type;
    recv_data >> lang;

    if (type >= MAX_CHAT_MSG_TYPE)
    {
        sLog->outError("CHAT: Wrong message type received: %u", type);
        recv_data.rfinish();
        return;
    }

    Player* sender = GetPlayer();

    // prevent talking at unknown language (cheating)
    LanguageDesc const* langDesc = GetLanguageDescByID(lang);
    if (!langDesc)
    {
        SendNotification(LANG_UNKNOWN_LANGUAGE);
        recv_data.rfinish();
        return;
    }

    bool ignoreChecks = false;
    if (lang == LANG_ADDON)
    {
        // LANG_ADDON is only valid for the following message types
        switch (type)
        {
            case CHAT_MSG_PARTY:
            case CHAT_MSG_RAID:
            case CHAT_MSG_GUILD:
            case CHAT_MSG_BATTLEGROUND:
            case CHAT_MSG_WHISPER:
                ignoreChecks = true;
                break;
            default:
                sLog->outError("Player %s (GUID: %u) sent a chatmessage with an invalid language/message type combination",
                    GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());

                recv_data.rfinish();
                return;
        }
    }

    std::string to, channel, msg, temp;
    switch (type)
    {
        case CHAT_MSG_SAY:
        case CHAT_MSG_EMOTE:
        case CHAT_MSG_YELL:
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_GUILD:
        case CHAT_MSG_OFFICER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_RAID_WARNING:
        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
            recv_data >> msg;
            break;
        case CHAT_MSG_WHISPER:
            recv_data >> to;
            recv_data >> msg;
            break;
        case CHAT_MSG_CHANNEL:
            recv_data >> channel;
            recv_data >> msg;
            break;
        case CHAT_MSG_AFK:
        case CHAT_MSG_DND:
            recv_data >> msg;
            if (checkMsgForCommand(msg, recv_data) || checkMsgForMute(sender, recv_data))
                return;
            ignoreChecks = true;
            break;
    }

    if (!ignoreChecks)
    {
        if (msg.empty())
            return;

        if (checkMsgForCommand(msg, recv_data) || checkMsgForMute(sender, recv_data))
        {
            if (!AccountMgr::IsVIPorPlayer(GetSecurity()))
            {
                /*if (Player* pPlayer = sender->GetSelectedPlayer())
                    sGMQualityManager->OnGMChat(CHAT_MSG_SYSTEM, sender, msg, pPlayer->GetName());
                else*/
                    sGMQualityManager->OnGMChat(CHAT_MSG_SYSTEM, sender, msg);
            }
            return;
        }

        StripLineInvisibleChars(msg);
    }

    switch (type)
    {
        case CHAT_MSG_SAY:
        case CHAT_MSG_EMOTE:
        case CHAT_MSG_YELL:
            if (lang != LANG_ADDON)
            {
                if (!AccountMgr::IsVIPorPlayer(GetSecurity()))
                    sGMQualityManager->OnGMChat(ChatMsg(type), sender, msg);
                else
                    sGMQualityManager->OnPlayerChat(ChatMsg(type), sender, msg);
            }
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_GUILD:
        case CHAT_MSG_OFFICER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_RAID_WARNING:
        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
        {
            if (GetAntiSpamCounter() > LOGON_DOS_STRIKE_LIMIT || sLogon->CheckForSpam(msg))
            {
                IncAntiSpamCounter();
                SendFakeChatNotification(type, msg, lang);
                return;
            }

            SendPacketToNode(&recv_data);
            break;
        }
        case CHAT_MSG_WHISPER:
        {
            if (GetAntiSpamCounter() > LOGON_DOS_STRIKE_LIMIT || sLogon->CheckForSpam(msg))
            {
                IncAntiSpamCounter();
                SendFakeChatNotification(type, msg, lang);
                return;
            }

            if (sender->getLevel() < sLogon->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ))
            {
                SendNotification(GetTrinityString(LANG_WHISPER_REQ), sLogon->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ));
                return;
            }

            if (!normalizePlayerName(to))
            {
                SendPlayerNotFoundNotice(to);
                return;
            }

            Player* receiver = sObjectMgr->FindPlayerByName(to.c_str());
            bool senderIsPlayer = AccountMgr::IsPlayerAccount(GetSecurity());
            bool receiverIsPlayer = AccountMgr::IsPlayerAccount(receiver ? receiver->GetSession()->GetSecurity() : SEC_PLAYER);

            if (!receiver || (senderIsPlayer && !receiverIsPlayer && !receiver->isAcceptWhispers() && !receiver->IsInWhisperWhiteList(sender->GetGUID())))
            {
                SendPlayerNotFoundNotice(to);
                return;
            }

            if (!sLogon->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && senderIsPlayer && receiverIsPlayer)
                if (GetPlayer()->GetTeam() != receiver->GetTeam())
                {
                    SendWrongFactionNotice();
                    return;
                }

            if (!GetPlayer()->CanSpeak() && !receiver->isGameMaster())
            {
                SendNotification(GetTrinityString(LANG_GM_SILENCE), GetPlayer()->GetName());
                return;
            }

            // If player is a Gamemaster and doesn't accept whisper, we auto-whitelist every player that the Gamemaster is talking to
            if (!senderIsPlayer && !sender->isAcceptWhispers() && !sender->IsInWhisperWhiteList(receiver->GetGUID()))
                sender->AddWhisperWhiteList(receiver->GetGUID());

            GetPlayer()->Whisper(msg, lang, receiver->GetGUID());

            if (sLogon->getBoolConfig(CONFIG_CHATLOG_WHISPER))
                sLog->outChat("[WHISPER] Player %s tells %s: %s", GetPlayer()->GetName(), receiver ? receiver->GetName() : "<unknown>", msg.c_str());

            if (lang != LANG_ADDON)
            {
                if (!AccountMgr::IsVIPorPlayer(GetSecurity()))
                    sGMQualityManager->OnGMChat(ChatMsg(type), sender, msg, to);
                else
                    sGMQualityManager->OnPlayerChat(ChatMsg(type), sender, msg, to);
            }
            break;
        }
        case CHAT_MSG_CHANNEL:
        {
            if ((channel.compare("GLaDOS") == 0) || (channel.compare("GM") == 0))
            {
                if (AccountMgr::IsVIPorPlayer(GetSecurity()))
                    return;

                if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
                    return;
            }
            else
            {
                if (GetPlayer() && GetPlayer()->getLevel() < 10)
                    return;

                if (GetAntiSpamCounter() > LOGON_DOS_STRIKE_LIMIT || sLogon->CheckForSpam(msg))
                {
                    IncAntiSpamCounter();
                    SendFakeChannelNotification(channel, msg, lang);
                    return;
                }

                if (sLogon->getBoolConfig(CONFIG_CHATLOG_CHANNEL))
                    sLog->outChat("[CHANNEL] Player %s tells Channel [%s]: %s", GetPlayer()->GetName(), channel.c_str(), msg.c_str());

                if (strContains(channel, " - ", false) || strContains(channel, "SucheNachGruppe", false))
                {
                    SendPacketToNode(&recv_data); //Send if the Channel is not on our LogonServer
                    return;
                }

                if (ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
                {
                    if (Channel* chn = cMgr->GetChannel(channel, _player))
                        chn->Say(_player->GetGUID(), msg.c_str(), lang);
                }
            }

            break;
        }
        case CHAT_MSG_AFK:
        {
            if ((msg.empty() || !_player->isAFK())) //&& !_player->isInCombat())
            {
                if (!_player->isAFK())
                {
                    if (msg.empty())
                        msg = GetTrinityString(LANG_PLAYER_AFK_DEFAULT);
                    _player->afkMsg = msg;
                }
                _player->ToggleAFK();
                if (_player->isAFK() && _player->isDND())
                    _player->ToggleDND();
            }

            break;
        }
        case CHAT_MSG_DND:
        {
            if (msg.empty() || !_player->isDND())
            {
                if (!_player->isDND())
                {
                    if (msg.empty())
                        msg = GetTrinityString(LANG_PLAYER_DND_DEFAULT);
                    _player->dndMsg = msg;
                }
                _player->ToggleDND();
                if (_player->isDND() && _player->isAFK())
                    _player->ToggleAFK();
            }

            break;
        }
        default:
            sLog->outError("CHAT: unknown message type %u, lang: %u", type, lang);
            break;
    }
}