bool WorldSocket::Update() { EncryptablePacket* queued; MessageBuffer buffer; while (_bufferQueue.Dequeue(queued)) { ServerPktHeader header(queued->size() + 2, queued->GetOpcode()); if (queued->NeedsEncryption()) _authCrypt.EncryptSend(header.header, header.getHeaderLength()); if (buffer.GetRemainingSpace() < queued->size() + header.getHeaderLength()) { QueuePacket(std::move(buffer)); buffer.Resize(4096); } if (buffer.GetRemainingSpace() >= queued->size() + header.getHeaderLength()) { buffer.Write(header.header, header.getHeaderLength()); if (!queued->empty()) buffer.Write(queued->contents(), queued->size()); } else // single packet larger than 4096 bytes { MessageBuffer packetBuffer(queued->size() + header.getHeaderLength()); packetBuffer.Write(header.header, header.getHeaderLength()); if (!queued->empty()) packetBuffer.Write(queued->contents(), queued->size()); QueuePacket(std::move(packetBuffer)); } delete queued; } if (buffer.GetActiveSize() > 0) QueuePacket(std::move(buffer)); if (!BaseSocket::Update()) return false; if (_queryFuture.valid() && _queryFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { auto callback = _queryCallback; _queryCallback = nullptr; callback(_queryFuture.get()); } return true; }
void WorldSocket::Start() { AsyncRead(); MessageBuffer initializer; ServerPktHeader header(ServerConnectionInitialize.size(), 0); initializer.Write(header.header, header.getHeaderLength() - 2); initializer.Write(ServerConnectionInitialize.c_str(), ServerConnectionInitialize.length()); std::unique_lock<std::mutex> dummy(_writeLock, std::defer_lock); QueuePacket(std::move(initializer), dummy); }
void AuthSession::SendPacket(ByteBuffer& packet) { if (!IsOpen()) return; if (!packet.empty()) { MessageBuffer buffer; buffer.Write(packet.contents(), packet.size()); QueuePacket(std::move(buffer)); } }
void AuthSession::SendPacket(ByteBuffer& packet) { if (!IsOpen()) return; if (!packet.empty()) { MessageBuffer buffer; buffer.Write(packet.contents(), packet.size()); std::unique_lock<std::mutex> guard(_writeLock); QueuePacket(std::move(buffer), guard); } }
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 Battlenet::Session::SendResponse(uint32 token, uint32 status) { Header header; header.set_token(token); header.set_status(status); header.set_service_id(0xFE); uint16 headerSize = header.ByteSize(); EndianConvertReverse(headerSize); MessageBuffer packet; packet.Write(&headerSize, sizeof(headerSize)); uint8* ptr = packet.GetWritePointer(); packet.WriteCompleted(header.ByteSize()); header.SerializeToArray(ptr, header.ByteSize()); AsyncWrite(&packet); }
void Socket::WritePacketToBuffer(Packet const& packet, MessageBuffer& buffer) { ServerHeader header; uint32 sizeOfHeader = SizeOfServerHeader; uint32 opcode = packet.GetOpcode(); uint32 packetSize = packet.size(); // Reserve space for buffer uint8* headerPos = buffer.GetWritePointer(); buffer.WriteCompleted(sizeOfHeader); if (!packet.empty()) buffer.Write(packet.contents(), packet.size()); header.Size = packetSize; header.Command = opcode; memcpy(headerPos, &header, sizeOfHeader); }
void Battlenet::Session::AsyncWrite(ServerPacket* packet) { if (!IsOpen()) { delete packet; return; } TC_LOG_DEBUG("session.packets", "%s Sending %s", GetClientInfo().c_str(), PacketToStringHelper(packet).c_str()); packet->Write(); MessageBuffer buffer; buffer.Write(packet->GetData(), packet->GetSize()); delete packet; std::unique_lock<std::mutex> guard(_writeLock); _crypt.EncryptSend(buffer.GetReadPointer(), buffer.GetActiveSize()); QueuePacket(std::move(buffer), guard); }
void Battlenet::Session::SendRequest(uint32 serviceHash, uint32 methodId, pb::Message const* request) { Header header; header.set_service_id(0); header.set_service_hash(serviceHash); header.set_method_id(methodId); header.set_size(request->ByteSize()); header.set_token(_requestToken++); uint16 headerSize = header.ByteSize(); EndianConvertReverse(headerSize); MessageBuffer packet; packet.Write(&headerSize, sizeof(headerSize)); uint8* ptr = packet.GetWritePointer(); packet.WriteCompleted(header.ByteSize()); header.SerializeToArray(ptr, header.ByteSize()); ptr = packet.GetWritePointer(); packet.WriteCompleted(request->ByteSize()); request->SerializeToArray(ptr, request->ByteSize()); AsyncWrite(&packet); }