/* * Copyright (C) 2005-2011 MaNGOS * Copyright (C) 2009-2011 MaNGOSZero * Copyright (C) 2011-2016 Nostalrius * Copyright (C) 2016-2017 Elysium Project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /** \file \ingroup mangosd */ #include "Common.h" #include "Database/DatabaseEnv.h" #include "Log.h" #include "ChatSocket.h" #include "World.h" #include "Config/Config.h" #include "Util.h" #include "SharedDefines.h" #include "ObjectAccessor.h" #include "PlayerBotMgr.h" #include "ObjectMgr.h" #include "AccountMgr.h" #include "Chat.h" #define DEBUG_OUT_CHAT(...) //sLog.outString(__VA_ARGS__) class OfflineChatCommandsHandler: public ChatHandler { public: OfflineChatCommandsHandler(WorldSession* session, std::stringstream& buf) : ChatHandler(session), m_buff(buf) { } virtual ~OfflineChatCommandsHandler() {} void SendSysMessage(const char *str) { m_buff << str << std::endl; } protected: std::stringstream& m_buff; }; /// OfflineChatSocket constructor OfflineChatSocket::OfflineChatSocket() : OfflineChatHandler(), pendingCommands(0, USYNC_THREAD, "pendingCommands"), outActive(false), inputBufferLen(0), outputBufferLen(0), stage(NONE) { reference_counting_policy ().value (ACE_Event_Handler::Reference_Counting_Policy::ENABLED); } /// OfflineChatSocket destructor OfflineChatSocket::~OfflineChatSocket() { peer().close(); } /// Accept an incoming connection int OfflineChatSocket::open(void* ) { if (reactor ()->register_handler(this, ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK) == -1) { sLog.outError ("OfflineChatSocket::open: unable to register client handler errno = %s", ACE_OS::strerror (errno)); return -1; } ACE_INET_Addr remote_addr; if (peer ().get_remote_addr (remote_addr) == -1) { sLog.outError ("OfflineChatSocket::open: peer ().get_remote_addr errno = %s", ACE_OS::strerror (errno)); return -1; } return 0; } int OfflineChatSocket::close(int) { if(closing_) return -1; shutdown(); closing_ = true; remove_reference(); return 0; } int OfflineChatSocket::handle_close (ACE_HANDLE h, ACE_Reactor_Mask) { if(closing_) return -1; ACE_GUARD_RETURN (ACE_Thread_Mutex, Guard, outBufferLock, -1); closing_ = true; if (h == ACE_INVALID_HANDLE) peer ().close_writer (); remove_reference(); return 0; } int OfflineChatSocket::handle_output (ACE_HANDLE) { ACE_GUARD_RETURN (ACE_Thread_Mutex, Guard, outBufferLock, -1); if(closing_) return -1; if (!outputBufferLen) { if(reactor()->cancel_wakeup(this, ACE_Event_Handler::WRITE_MASK) == -1) { sLog.outError ("OfflineChatSocket::handle_output: error while cancel_wakeup"); return -1; } outActive = false; return 0; } #ifdef MSG_NOSIGNAL ssize_t n = peer ().send (outputBuffer, outputBufferLen, MSG_NOSIGNAL); #else ssize_t n = peer ().send (outputBuffer, outputBufferLen); #endif // MSG_NOSIGNAL if(n<=0) return -1; ACE_OS::memmove(outputBuffer, outputBuffer+n, outputBufferLen-n); outputBufferLen -= n; return 0; } /// Read data from the network std::string TrimLeft(const std::string& s) { size_t startpos = s.find_first_not_of(" "); return (startpos == std::string::npos) ? "" : s.substr(startpos); } int OfflineChatSocket::handle_input(ACE_HANDLE) { DEBUG_LOG("OfflineChatSocket::handle_input"); if (closing_) { sLog.outError("Called OfflineChatSocket::handle_input with closing_ = true"); return -1; } int readBytes = peer().recv(inputBuffer+inputBufferLen, OFFCHAT_BUFF_SIZE-inputBufferLen-1); if (readBytes <= 0) { DEBUG_LOG("read %i bytes in OfflineChatSocket::handle_input", readBytes); return -1; } DEBUG_OUT_CHAT("OfflineChatSocket::handle_input %i bytes read", readBytes); ///- Discard data after line break or line feed bool endofpacket = false; for (; readBytes > 0 ; --readBytes) { char c = inputBuffer[inputBufferLen]; if (c == '\r'|| c == '\n') { endofpacket = true; break; } ++inputBufferLen; } if (!endofpacket) return -1; inputBuffer[inputBufferLen] = '\0'; inputBufferLen = 0; // Entree (texte) : plguid msgtype chanordest message /* Input (text): - Sessionkey - UserIP [to check IP ban] - PlayerGuid - Type [Cf enum ChatMsg, -1 = ExecuteCommand, -2 = Get chat messages in queue] [- Channel if pertinent] - Message */ std::stringstream oss(inputBuffer); uint32 playerGuid = 0; int32 messageType = 0; std::string chanOrDest; std::string sessionKey; std::string userIP; std::string message; oss >> sessionKey; oss >> userIP; oss >> playerGuid; oss >> messageType; switch (messageType) { case CHAT_MSG_CHANNEL: case CHAT_MSG_CHANNEL_JOIN: case CHAT_MSG_CHANNEL_LEAVE: case CHAT_MSG_WHISPER: oss >> chanOrDest; break; } getline(oss, message); message = TrimLeft(message); DEBUG_OUT_CHAT("Raw='%s' SessionKey=%s Guid=%u MsgType=%i Chan=%s Msg=\"%s\"", inputBuffer, sessionKey.c_str(), playerGuid, messageType, chanOrDest.c_str(), message.c_str()); // Let's login the player, if not already online uint32 acc = sObjectMgr.GetPlayerAccountIdByGUID(playerGuid); QueryResult* auth = LoginDatabase.PQuery("SELECT 1 FROM account WHERE id=%u AND sessionkey=\"%s\"", acc, sessionKey.c_str()); if (!auth) { sendf("err_auth\n"); return 0; } delete auth; WorldSession* sess = sWorld.FindSession(acc); if (sess && sess->GetSocket()) { sendf("err_online\n"); return 0; } // Check ban if (sAccountMgr.IsAccountBanned(acc) || sAccountMgr.IsIPBanned(userIP)) { sendf("err_banned\n"); return 0; } std::stringstream out; out << "ok\n"; Player* player = sObjectAccessor.FindPlayer(ObjectGuid(playerGuid)); if (!player) { if (sess && sess->PlayerLoading()) { sendf("err_loading\n"); return 0; } if (!sPlayerBotMgr.addBot(playerGuid, true)) { sendf("err_internal\n"); return 0; } } else { sPlayerBotMgr.AddTempBot(player->GetSession()->GetAccountId(), 20000); // Retrieve messages in queue if (messageType == OFFLINE_CHAT_GET_MESSAGES) { out << player->GetSession()->_chatBotHistory.str(); player->GetSession()->_chatBotHistory.str(""); } else if (messageType == OFFLINE_CHAT_GM_COMMAND) { if (message == "") { sendf("err_empty\n"); return 0; } // Disabled. Needs to be thread safe! //OfflineChatCommandsHandler(player->GetSession(), out).ParseCommands(message.c_str()); } else { // Or just queue a normal chat packet WorldPacket* data = new WorldPacket(CMSG_MESSAGECHAT, 100); uint32 lang = player->GetTeam() == ALLIANCE ? LANG_COMMON : LANG_ORCISH; *data << messageType; *data << lang; switch (messageType) { case CHAT_MSG_CHANNEL: case CHAT_MSG_WHISPER: *data << chanOrDest; case CHAT_MSG_YELL: case CHAT_MSG_SAY: case CHAT_MSG_GUILD: case CHAT_MSG_OFFICER: case CHAT_MSG_PARTY: *data << message; break; case CHAT_MSG_CHANNEL_JOIN: data->Initialize(CMSG_JOIN_CHANNEL, 20); *data << chanOrDest; *data << ""; // Password break; case CHAT_MSG_CHANNEL_LEAVE: data->Initialize(CMSG_LEAVE_CHANNEL, 20); *data << chanOrDest; break; default: DEBUG_OUT_CHAT(">> Packet err"); sendf("err_packet\n"); return 0; } player->GetSession()->QueuePacket(data); DEBUG_OUT_CHAT(">> Queue packet."); } } out << "end\n"; sendf(out.str().c_str()); return 0; } /// Output function int OfflineChatSocket::sendf(const char* msg) { ACE_GUARD_RETURN (ACE_Thread_Mutex, Guard, outBufferLock, -1); if (closing_) return -1; int msgLen = strlen(msg); if (msgLen+outputBufferLen > OFFCHAT_BUFF_SIZE) return -1; ACE_OS::memcpy(outputBuffer+outputBufferLen, msg, msgLen); outputBufferLen += msgLen; if (!outActive) { if (reactor ()->schedule_wakeup (this, ACE_Event_Handler::WRITE_MASK) == -1) { sLog.outError ("OfflineChatSocket::sendf error while schedule_wakeup"); return -1; } outActive = true; } DEBUG_OUT_CHAT("Sending: \"%s\"", msg); return 0; }