void WorldSocket::SendPacket(WorldPacket const& packet) { if (!IsOpen()) return; if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(packet, SERVER_TO_CLIENT, GetRemoteIpAddress(), GetRemotePort()); ServerPktHeader header(packet.size() + 2, packet.GetOpcode()); std::unique_lock<std::mutex> guard(_writeLock); _authCrypt.EncryptSend(header.header, header.getHeaderLength()); #ifndef TC_SOCKET_USE_IOCP if (_writeQueue.empty() && _writeBuffer.GetRemainingSpace() >= header.getHeaderLength() + packet.size()) { _writeBuffer.Write(header.header, header.getHeaderLength()); if (!packet.empty()) _writeBuffer.Write(packet.contents(), packet.size()); } else #endif { MessageBuffer buffer(header.getHeaderLength() + packet.size()); buffer.Write(header.header, header.getHeaderLength()); if (!packet.empty()) buffer.Write(packet.contents(), packet.size()); QueuePacket(std::move(buffer), guard); } }
void WorldSocket::SendPacket(WorldPacket& packet) { if (!IsOpen()) return; if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(packet, SERVER_TO_CLIENT, GetRemoteIpAddress(), GetRemotePort()); TC_LOG_TRACE("network.opcode", "S->C: %s %s", (_worldSession ? _worldSession->GetPlayerInfo() : GetRemoteIpAddress().to_string()).c_str(), GetOpcodeNameForLogging(packet.GetOpcode()).c_str()); ServerPktHeader header(packet.size() + 2, packet.GetOpcode()); std::unique_lock<std::mutex> guard(_writeLock); _authCrypt.EncryptSend(header.header, header.getHeaderLength()); #ifndef TC_SOCKET_USE_IOCP if (_writeQueue.empty() && _writeBuffer.GetRemainingSpace() >= header.getHeaderLength() + packet.size()) { _writeBuffer.Write(header.header, header.getHeaderLength()); if (!packet.empty()) _writeBuffer.Write(packet.contents(), packet.size()); } else #endif { MessageBuffer buffer(header.getHeaderLength() + packet.size()); buffer.Write(header.header, header.getHeaderLength()); if (!packet.empty()) buffer.Write(packet.contents(), packet.size()); QueuePacket(std::move(buffer), guard); } }
int WorldSocket::SendPacket(WorldPacket const& pct) { ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1); if (closing_) return -1; // Dump outgoing packet. if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(pct, SERVER_TO_CLIENT); // Create a copy of the original packet; this is to avoid issues if a hook modifies it. sScriptMgr->OnPacketSend(this, WorldPacket(pct)); Flexi::ServerPktHeader header(pct.size()+2, pct.GetOpcode()); m_Crypt.EncryptSend ((uint8*)header.header, header.getHeaderLength()); if (m_OutBuffer->space() >= pct.size() + header.getHeaderLength() && msg_queue()->is_empty()) { // Put the packet on the buffer. if (m_OutBuffer->copy((char*) header.header, header.getHeaderLength()) == -1) ACE_ASSERT (false); if (!pct.empty()) if (m_OutBuffer->copy((char*) pct.contents(), pct.size()) == -1) ACE_ASSERT (false); } else { // Enqueue the packet. ACE_Message_Block* mb; ACE_NEW_RETURN(mb, ACE_Message_Block(pct.size() + header.getHeaderLength()), -1); mb->copy((char*) header.header, header.getHeaderLength()); if (!pct.empty()) mb->copy((const char*)pct.contents(), pct.size()); if (msg_queue()->enqueue_tail(mb, (ACE_Time_Value*)&ACE_Time_Value::zero) == -1) { sLog->outError("WorldSocket::SendPacket enqueue_tail failed"); mb->release(); return -1; } } return 0; }
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recv_data) { Group* group = GetPlayer()->GetGroup(); if (!group) return; if (recv_data.empty()) // request { /** error handling **/ if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID())) return; /********************/ // everything is fine, do it WorldPacket data(MSG_RAID_READY_CHECK, 8); data << GetPlayer()->GetGUID(); group->BroadcastPacket(&data, false, -1); group->OfflineReadyCheck(); } else // answer { uint8 state; recv_data >> state; // everything is fine, do it WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9); data << GetPlayer()->GetGUID(); data << state; group->BroadcastReadyCheck(&data); } }
void WorldSocket::AsyncWrite(WorldPacket const& packet) { if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(packet, SERVER_TO_CLIENT); TC_LOG_TRACE("network.opcode", "S->C: %s %s", (_worldSession ? _worldSession->GetPlayerInfo() : GetRemoteIpAddress()).c_str(), GetOpcodeNameForLogging(packet.GetOpcode()).c_str()); ServerPktHeader header(packet.size() + 2, packet.GetOpcode()); std::vector<uint8> data(header.getHeaderLength() + packet.size()); std::memcpy(data.data(), header.header, header.getHeaderLength()); if (!packet.empty()) std::memcpy(&data[header.getHeaderLength()], packet.contents(), packet.size()); std::lock_guard<std::mutex> guard(_writeLock); bool needsWriteStart = _writeQueue.empty(); _authCrypt.EncryptSend(data.data(), header.getHeaderLength()); _writeQueue.push(std::move(data)); if (needsWriteStart) AsyncWrite(_writeQueue.front()); }
void WorldSession::HandleRaidReadyCheckOpcode( WorldPacket & recv_data ) { Group *group = GetPlayer()->GetGroup(); if(!group) return; if(recv_data.empty()) // request { /** error handling **/ if(!group->IsLeader(GetPlayer()->GetGUID())) return; /********************/ // everything's fine, do it WorldPacket data(MSG_RAID_READY_CHECK, 0); group->BroadcastPacket(&data, -1, GetPlayer()->GetGUID()); } else // answer { uint8 state; recv_data >> state; /** error handling **/ /********************/ // everything's fine, do it Player *leader = objmgr.GetPlayer(group->GetLeaderGUID()); if(leader && leader->GetSession()) { WorldPacket data(MSG_RAID_READY_CHECK, 9); data << GetPlayer()->GetGUID(); data << state; leader->GetSession()->SendPacket(&data); } } }
bool WorldSocket::SendPacket(const WorldPacket& pct) { if (IsClosed()) return false; // Dump outgoing packet. sLog.outWorldPacketDump(native_handle(), pct.GetOpcode(), pct.GetOpcodeName(), &pct, false); ServerPktHeader header(pct.size() + 2, pct.GetOpcode()); crypt_.EncryptSend((uint8*) header.header, header.getHeaderLength()); GuardType Guard(out_buffer_lock_); if (out_buffer_->space() >= pct.size() + header.getHeaderLength()) { // Put the packet on the buffer. if (!out_buffer_->Write(header.header, header.getHeaderLength())) MANGOS_ASSERT(false); if (!pct.empty() && !out_buffer_->Write(pct.contents(), pct.size())) MANGOS_ASSERT(false); } else { // Enqueue the packet. throw std::exception("network write buffer is too small to accommodate packet"); } StartAsyncSend(); return true; }
void PacketLog::LogPacket(WorldPacket const& packet, Direction direction, boost::asio::ip::address const& addr, uint16 port) { std::lock_guard<std::mutex> lock(_logPacketLock); PacketHeader header; *reinterpret_cast<uint32*>(header.Direction) = direction == CLIENT_TO_SERVER ? 0x47534d43 : 0x47534d53; header.ConnectionId = 0; header.ArrivalTicks = getMSTime(); header.OptionalDataSize = sizeof(header.OptionalData); memset(header.OptionalData.SocketIPBytes, 0, sizeof(header.OptionalData.SocketIPBytes)); if (addr.is_v4()) { auto bytes = addr.to_v4().to_bytes(); memcpy(header.OptionalData.SocketIPBytes, bytes.data(), bytes.size()); } else if (addr.is_v6()) { auto bytes = addr.to_v6().to_bytes(); memcpy(header.OptionalData.SocketIPBytes, bytes.data(), bytes.size()); } header.OptionalData.SocketPort = port; header.Length = packet.size() + sizeof(header.Opcode); header.Opcode = packet.GetOpcode(); fwrite(&header, sizeof(header), 1, _file); if (!packet.empty()) fwrite(packet.contents(), 1, packet.size(), _file); fflush(_file); }
int WorldSocket::iSendPacket(const WorldPacket& pct) { if (m_OutBuffer->space() < pct.size() + sizeof(ServerPktHeader)) { errno = ENOBUFS; return -1; } ServerPktHeader header; header.cmd = pct.GetOpcode(); header.size = (uint16) pct.size() + 2; EndianConvertReverse(header.size); EndianConvert(header.cmd); m_Crypt.EncryptSend((uint8*) & header, sizeof(header)); if (m_OutBuffer->copy((char*) & header, sizeof(header)) == -1) { ACE_ASSERT(false); } if (!pct.empty()) if (m_OutBuffer->copy((char*) pct.contents(), pct.size()) == -1) { ACE_ASSERT(false); } return 0; }
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recvData) { TC_LOG_DEBUG(LOG_FILTER_NETWORKIO, "WORLD: Received MSG_RAID_READY_CHECK"); Group* group = GetPlayer()->GetGroup(); if (!group) return; if (recvData.empty()) // request { /** error handling **/ if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID())) return; /********************/ // everything's fine, do it WorldPacket data(MSG_RAID_READY_CHECK, 8); data << GetPlayer()->GetGUID(); group->BroadcastPacket(&data, false, -1); group->OfflineReadyCheck(); } else // answer { uint8 state; recvData >> state; // everything's fine, do it WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9); data << uint64(GetPlayer()->GetGUID()); data << uint8(state); group->BroadcastReadyCheck(&data); } }
void WorldSession::HandleGuildMOTDOpcode(WorldPacket& recvPacket) { DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_MOTD"); std::string MOTD; if (!recvPacket.empty()) { recvPacket >> MOTD; }
void WorldSession::HandleGuildMOTDOpcode(WorldPacket& recvPacket) { sLog.outDebug("WORLD: Received CMSG_GUILD_MOTD"); std::string MOTD; if(!recvPacket.empty()) recvPacket >> MOTD; else
void WorldSocket::WritePacketToBuffer(WorldPacket const& packet, MessageBuffer& buffer) { ServerPktHeader header; uint32 sizeOfHeader = SizeOfServerHeader[_authCrypt.IsInitialized()]; uint32 opcode = packet.GetOpcode(); uint32 packetSize = packet.size(); // Reserve space for buffer uint8* headerPos = buffer.GetWritePointer(); buffer.WriteCompleted(sizeOfHeader); if (packetSize > 0x400) { CompressedWorldPacket cmp; cmp.UncompressedSize = packetSize + 4; cmp.UncompressedAdler = adler32(adler32(0x9827D8F1, (Bytef*)&opcode, 4), packet.contents(), packetSize); // Reserve space for compression info - uncompressed size and checksums uint8* compressionInfo = buffer.GetWritePointer(); buffer.WriteCompleted(sizeof(CompressedWorldPacket)); uint32 compressedSize = CompressPacket(buffer.GetWritePointer(), packet); cmp.CompressedAdler = adler32(0x9827D8F1, buffer.GetWritePointer(), compressedSize); memcpy(compressionInfo, &cmp, sizeof(CompressedWorldPacket)); buffer.WriteCompleted(compressedSize); packetSize = compressedSize + sizeof(CompressedWorldPacket); opcode = SMSG_COMPRESSED_PACKET; } else if (!packet.empty()) buffer.Write(packet.contents(), packet.size()); if (_authCrypt.IsInitialized()) { header.Normal.Size = packetSize; header.Normal.Command = opcode; _authCrypt.EncryptSend((uint8*)&header, sizeOfHeader); } else { header.Setup.Size = packetSize + 4; header.Setup.Command = opcode; } memcpy(headerPos, &header, sizeOfHeader); }
void WorldSession::HandleGuildMOTDOpcode(WorldPacket& recvPacket) { Guild *guild; std::string MOTD; //sLog.outDebug("WORLD: Received CMSG_GUILD_MOTD"); guild = objmgr.GetGuildById(GetPlayer()->GetGuildId()); if(!guild) { SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD); return; } if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_SETMOTD)) { SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS); return; } if(!recvPacket.empty()) recvPacket >> MOTD; else
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recv_data) { if (recv_data.empty()) // request { Group* group = GetPlayer()->GetGroup(); if (!group) return; /** error handling **/ if (!group->IsLeader(GetPlayer()->GetObjectGuid()) && !group->IsAssistant(GetPlayer()->GetObjectGuid())) return; /********************/ // everything is fine, do it WorldPacket data(SMSG_READY_CHECK_STARTED, 8); data << ObjectGuid(GetPlayer()->GetObjectGuid()); group->BroadcastPacket(&data, false, -1); group->OfflineReadyCheck(); } else // answer { uint8 state; recv_data >> state; Group* group = GetPlayer()->GetGroup(); if (!group) return; // everything is fine, do it WorldPacket data(SMSG_READY_CHECK_COMPLETED, 9); data << GetPlayer()->GetObjectGuid(); data << uint8(state); group->BroadcastReadyCheck(&data); } }
void WorldSession::HandleWardenDataOpcode(WorldPacket& recvData) { if (!_warden || recvData.empty()) return; _warden->DecryptData(recvData.contents(), recvData.size()); uint8 opcode; recvData >> opcode; TC_LOG_DEBUG("warden", "Got packet, opcode %02X, size %u", opcode, uint32(recvData.size())); recvData.hexlike(); switch (opcode) { case WARDEN_CMSG_MODULE_MISSING: _warden->SendModuleToClient(); break; case WARDEN_CMSG_MODULE_OK: _warden->RequestHash(); break; case WARDEN_CMSG_CHEAT_CHECKS_RESULT: _warden->HandleData(recvData); break; case WARDEN_CMSG_MEM_CHECKS_RESULT: TC_LOG_DEBUG("warden", "NYI WARDEN_CMSG_MEM_CHECKS_RESULT received!"); break; case WARDEN_CMSG_HASH_RESULT: _warden->HandleHashResult(recvData); _warden->InitializeModule(); break; case WARDEN_CMSG_MODULE_FAILED: TC_LOG_DEBUG("warden", "NYI WARDEN_CMSG_MODULE_FAILED received!"); break; default: TC_LOG_DEBUG("warden", "Got unknown warden opcode %02X of size %u.", opcode, uint32(recvData.size() - 1)); break; } }
void WorldSession::HandleRolePollBeginOpcode(WorldPacket& recvData) { TC_LOG_DEBUG("network", "WORLD: Received CMSG_ROLE_POLL_BEGIN"); Group* group = GetPlayer()->GetGroup(); if (!group) return; if (recvData.empty()) { if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID())) return; ObjectGuid guid = GetPlayer()->GetGUID(); WorldPacket data(SMSG_ROLE_POLL_BEGIN, 8); data.WriteBit(guid[1]); data.WriteBit(guid[5]); data.WriteBit(guid[7]); data.WriteBit(guid[3]); data.WriteBit(guid[2]); data.WriteBit(guid[4]); data.WriteBit(guid[0]); data.WriteBit(guid[6]); data.WriteByteSeq(guid[4]); data.WriteByteSeq(guid[7]); data.WriteByteSeq(guid[0]); data.WriteByteSeq(guid[5]); data.WriteByteSeq(guid[1]); data.WriteByteSeq(guid[6]); data.WriteByteSeq(guid[2]); data.WriteByteSeq(guid[3]); GetPlayer()->GetGroup()->BroadcastPacket(&data, true); } }