void CheriaServer::sendClientConnect(ProtocolServer::ClientState* sourceCs,ProtocolServer::ClientState* destCs,Comm::NetPipe& pipe)
{
/* Get handles on the Cheria state objects: */
ClientState* mySourceCs=dynamic_cast<ClientState*>(sourceCs);
ClientState* myDestCs=dynamic_cast<ClientState*>(destCs);
if(mySourceCs==0||myDestCs==0)
Misc::throwStdErr("CheriaServer::sendClientConnect: Client state object has mismatching type");
#if DEBUGGING
std::cout<<"CheriaServer::sendClientConnect..."<<std::flush;
#endif
/* Create a temporary message buffer with the same endianness as the pipe's write end: */
MessageBuffer buffer;
buffer.setSwapOnWrite(pipe.mustSwapOnWrite());
/*********************************************************************
Assemble the update message in the temporary buffer:
*********************************************************************/
/* Send creation messages for the source client's devices to the destination client: */
for(ClientDeviceMap::Iterator cdIt=mySourceCs->clientDevices.begin();!cdIt.isFinished();++cdIt)
{
writeMessage(CREATE_DEVICE,buffer);
buffer.write<Card>(cdIt->getSource());
cdIt->getDest()->writeLayout(buffer);
}
/* Send creation messages for the source client's tools to the destination client: */
for(ClientToolMap::Iterator ctIt=mySourceCs->clientTools.begin();!ctIt.isFinished();++ctIt)
{
writeMessage(CREATE_TOOL,buffer);
buffer.write<Card>(ctIt->getSource());
ctIt->getDest()->write(buffer);
}
/* Send the current states of the source client's devices: */
writeMessage(DEVICE_STATES,buffer);
for(ClientDeviceMap::Iterator cdIt=mySourceCs->clientDevices.begin();!cdIt.isFinished();++cdIt)
{
/* Send a device state message: */
buffer.write<Card>(cdIt->getSource());
cdIt->getDest()->write(DeviceState::FULL_UPDATE,buffer);
}
buffer.write<Card>(0);
/*********************************************************************
Send the assembled message to the client in one go:
*********************************************************************/
#if DEBUGGING
std::cout<<" message size "<<buffer.getDataSize()<<std::endl;
#endif
/* Write the message's total size first: */
pipe.write<Card>(buffer.getDataSize());
/* Write the message itself: */
buffer.writeToSink(pipe);
}
inline bool PartialProcessPacket(Battlenet::Session* session, MessageBuffer& inputBuffer)
{
MessageBuffer& buffer = session->*outputBuffer;
// We have full read header, now check the data payload
if (buffer.GetRemainingSpace() > 0)
{
// need more data in the payload
std::size_t readDataSize = std::min(inputBuffer.GetActiveSize(), buffer.GetRemainingSpace());
buffer.Write(inputBuffer.GetReadPointer(), readDataSize);
inputBuffer.ReadCompleted(readDataSize);
}
if (buffer.GetRemainingSpace() > 0)
{
// Couldn't receive the whole data this time.
ASSERT(inputBuffer.GetActiveSize() == 0);
return false;
}
// just received fresh new payload
if (!(session->*processMethod)())
{
session->CloseSocket();
return false;
}
return true;
}
MessageBuffer *Session::ReadMessage() {
unsigned char len_buf[4];
unsigned char *buf = NULL;
unsigned long msg_len;
read_monitor.Enter();
try {
if (ReadData(len_buf, 0, 4) != 4)
throw MessageException("Unable to read data");
unsigned long msg_len_net = *((unsigned int *)len_buf);
msg_len = ntohl(msg_len_net);
buf = new unsigned char[msg_len];
if (ReadData(buf, 0, msg_len) != msg_len)
throw MessageException("Unable to read data");
} catch (...) {
read_monitor.Exit();
if (buf != NULL)
delete[] buf;
throw;
}
read_monitor.Exit();
MessageBuffer *rv = new MessageBuffer();
try {
rv->SetData(buf, msg_len);
} catch (...) {
delete[] buf;
delete rv;
throw;
}
delete[] buf;
return rv;
}
void TellMasterThatWorkerStartedAWorkUnit( MessageBuffer &mb, CDSInfo *pInfo, WUIndexType iWU )
{
mb.setLen( 0 );
PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WU_STARTED );
mb.write( &iWU, sizeof( iWU ) );
VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID, k_eVMPISendFlags_GroupPackets );
}
void PreDistributeWorkSync( CDSInfo *pInfo )
{
if ( g_bMPIMaster )
{
// Send a message telling all the workers we're ready to go on this DistributeWork call.
MessageBuffer mb;
PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_MASTER_READY );
VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT );
}
else
{
if ( g_iVMPIVerboseLevel >= 1 )
Msg( "PreDistributeWorkSync: waiting for master\n" );
// Wait for the master's message saying it's ready to go.
while ( g_iMasterReadyForDistributeWorkCall < g_iCurDSInfo )
{
VMPI_DispatchNextMessage();
}
if ( g_iVMPIVerboseLevel >= 1 )
Msg( "PreDistributeWorkSync: master ready\n" );
// Now tell the master we're ready.
MessageBuffer mb;
PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WORKER_READY );
VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID );
}
}
// Called when the metadata object is about to be written
// FIll the fields on the metadata
virtual void compute_info(const MessageBuffer& buffer)
{
ProcessingStep& p = *_processing_step;
p.set_name("root2a4");
p.set_walltime((chrono::steady_clock::now() - _start_wallclock).count());
p.set_cputime((chrono::thread_clock::now() - _start_cpuclock).count());
p.set_input_events(_input_events);
p.set_input_bytes_read(_input_bytes_read);
_metadata.set_event_count(buffer.size());
if (buffer.size() >= 1) {
if (_field_run) {
auto run_number = _refl->GetUInt32(*buffer[0], _field_run);
_metadata.add_run(run_number);
auto* full_period = get_period(run_number);
std::string period = full_period;
if (period != "UNK") {
period = period[0];
}
_metadata.add_period(period);
_metadata.add_subperiod(full_period);
}
if (_field_mc_channel && _refl->HasField(*buffer[0], _field_mc_channel))
_metadata.add_mc_channel(_refl->GetUInt32(*buffer[0], _field_mc_channel));
}
}
void LedHandler::process_messages()
{
MessageBuffer* buf = _blk->getBuffer();
// cout << "led process" <<endl;
google::protobuf::Message* cur = buf->remove_head();
while(cur != 0)
{
if(cur->GetTypeName() != "LedChangeMessage")
{
cout << "not led" << endl;
delete cur;
cur = buf->remove_head();
continue;
}
LedChangeMessage* led_change = (LedChangeMessage*)cur;
for(int i = 0; i < led_change->leds_size(); i++)
{
setLed(led_change->leds(i).chain(),led_change->leds(i).color());
}
delete cur;
cur = buf->remove_head();
}
}
void ChatRoom::Deliver(const ChatMessage& chat)
{
MessageBuffer msgs;
auto ptr = std::unique_ptr<Message>(new ChatMessage(chat));
msgs.Push(ptr);
for (auto& user : _users)
user->Deliver(msgs);
}
bool Netstream::write(const std::string &data)
{
MessageBuffer msg;
if (msg.set_body_length(data.size())) {
memcpy(msg.body(), data.c_str(), data.size());
boost::asio::async_write(sock_, boost::asio::buffer(msg.data(), msg.length()), boost::bind(&Netstream::handle_write, this, boost::asio::placeholders::error));
return true;
}
return false;
}
void MuddComm::ProcessMessage(const TimeMessage& timeMsg)
{
MessageBuffer msgs;
auto now = time(0);
auto s = ctime(&now);
auto timeChat = std::unique_ptr<Message>(new ChatMessage(s));
msgs.Push(timeChat);
Deliver(msgs);
}
void SendQDirInfo()
{
char cPacketID[2] = { VMPI_SHARED_PACKET_ID, VMPI_SUBPACKETID_DIRECTORIES };
MessageBuffer mb;
mb.write( cPacketID, 2 );
mb.write( gamedir, strlen( gamedir ) + 1 );
mb.write( qdir, strlen( qdir ) + 1 );
VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT );
}
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));
}
}
bool ConnectionInstance::sendRaw(string& message) {
if (closed)
return false;
MessageBuffer* buffer = new MessageBuffer();
MessagePtr outMessage(buffer);
buffer->Set(message.data(), message.length());
writeQueue.push_back(outMessage);
ev_io_start(loop, writeEvent);
return true;
}
int DbWrapper::unlock()
{
// no unlock for system db
if (m_uid < 5000)
return CKM_API_SUCCESS;
int retCode;
RawBuffer ret = m_logic.unlockUserKey(m_uid, m_pw);
MessageBuffer buff;
buff.Push(ret);
buff.Deserialize(retCode);
return retCode;
}
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);
}
}
MessageBuffer::MessageBuffer(const MessageBuffer& other)
{
mutex.Lock();
owner = other.getOwner();
copyFrom(other);
mutex.Unlock();
}
void MessageBuffer::mergeFrom(const MessageBuffer& other)
{
mutex.Lock();
std::vector<Message*>& tmp = other.getBuffer();
msg_buf->insert(msg_buf->end(),tmp.begin(),tmp.end());
mutex.Unlock();
}
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 MuddComm::HandleReadBody(const error_code& error)
{
if (!error)
{
MessageBuffer msgs;
msgs.Deserialize(_readMsg.data());
ProcessMessageBuffer(msgs);
// Reserve space for the header, then read it in
_readMsg.resize(MessageBuffer::HEADER_LENGTH, '\0');
async_read(_socket, buffer(_readMsg.data(), MessageBuffer::HEADER_LENGTH), bind(&MuddComm::HandleReadHeader, shared_from_this(), _1));
}
else
{
_room.Leave(shared_from_this());
}
}
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);
}
int getCertChain(
ServiceConnection & serviceConnection,
LogicCommand command,
int counter,
const CertificateShPtr &certificate,
const T &untrustedVector,
const T &trustedVector,
bool useTrustedSystemCertificates,
CertificateShPtrVector &certificateChainVector)
{
return try_catch([&] {
MessageBuffer recv;
auto send = MessageBuffer::Serialize(static_cast<int>(command),
counter,
certificate->getDER(),
untrustedVector,
trustedVector,
useTrustedSystemCertificates);
int retCode = serviceConnection.processRequest(send.Pop(), recv);
if (CKM_API_SUCCESS != retCode)
return retCode;
int retCommand;
int retCounter;
RawBufferVector rawBufferVector;
recv.Deserialize(retCommand, retCounter, retCode, rawBufferVector);
if ((counter != retCounter) || (static_cast<int>(command) != retCommand))
return CKM_API_ERROR_UNKNOWN;
if (retCode != CKM_API_SUCCESS)
return retCode;
for (auto &e: rawBufferVector) {
CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
if (cert->empty())
return CKM_API_ERROR_BAD_RESPONSE;
certificateChainVector.push_back(cert);
}
return retCode;
});
}
void MuddComm::ProcessMessageBuffer(MessageBuffer& msgs)
{
auto msg_up = msgs.Pop();
while (msg_up)
{
if (msg_up->Header() == ChatMessage::HEADER)
{
ChatMessage* msg = dynamic_cast<ChatMessage*>(msg_up.get());
ProcessMessage(*msg);
}
else if (msg_up->Header() == TimeMessage::HEADER)
{
TimeMessage* msg = dynamic_cast<TimeMessage*>(msg_up.get());
ProcessMessage(*msg);
}
msg_up = msgs.Pop();
}
}
void write_metadata(shared<a4::io::OutputStream> stream,
const MessageBuffer& buffer)
{
compute_info(buffer);
// Only write metadata if there is at least one message to be written
// (A4 doesn't deal well with the case of metadata for 0 events yet)
if (buffer.size() >= 1) {
stream->metadata(_metadata);
}
reset_counters();
}
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);
}
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;
}
int main()
{
Foo foo;
MessageBuffer mb;
std::ostringstream ostr;
MsgJoinReq msgJoinReq("foo", 1234);
msgJoinReq.encode(ostr);
MsgJoinAccept msgJoinAccept(4321);
msgJoinAccept.encode(ostr);
MsgJoinReject msgJoinReject;
msgJoinReject.encode(ostr);
mb.append(ostr.str());
std::cout << ostr.str() << std::endl;
try
{
while (true)
{
std::string message = mb.getMessage();
std::cout << "Message: " << message << std::endl;
std::istringstream istr(message);
Message* msg = Message::decode(istr);
msg->handle(&foo, 0);
}
}
catch (MessageNotReady& ex)
{
std::cout << "Message not ready" << std::endl;
}
return 0;
}
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 DistributeWork_Master( CDSInfo *pInfo, ProcessWorkUnitFn processFn, ReceiveWorkUnitFn receiveFn )
{
pInfo->m_WorkerInfo.m_pProcessFn = processFn;
pInfo->m_MasterInfo.m_ReceiveFn = receiveFn;
VMPITracker_Start( (int) pInfo->m_nWorkUnits );
g_bMasterDistributingWork = true;
g_pCurDistributorMaster->DistributeWork_Master( pInfo );
g_bMasterDistributingWork = false;
VMPITracker_End();
// Tell all workers to move on.
MessageBuffer mb;
PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_MASTER_FINISHED );
VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT );
// Clear the master's local completed work unit list.
CMasterWorkUnitCompletedList *pList = g_MasterWorkUnitCompletedList.Lock();
pList->m_CompletedWUs.RemoveAll();
g_MasterWorkUnitCompletedList.Unlock();
}
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);
}
