Beispiel #1
0
MumblePacket::MumblePacket(MumblePacketType type, const Message &message) {

	int msgSize = message.ByteSize();

	this->messageData = new char[msgSize];
	message.SerializePartialToArray(this->messageData, msgSize);

	this->packetHeader.packetType = static_cast<short>(type);
	this->packetHeader.packetLength = message.ByteSize() + 6; //The 6 more bytes are for the header (2 + 4 bytes -> type + size)

	this->rawData = new char[this->packetHeader.packetLength];

	memcpy(this->rawData, static_cast<void *>(&this->packetHeader), 6); //We copy the header.
	memcpy(this->rawData+6, this->messageData, msgSize); //We copy the message
}
Beispiel #2
0
void Communication::sendMessage(Socket& socket, const Message& message) {
	int serialized_size = message.ByteSize();
	char *serialized_pb = new char[serialized_size];
	message.SerializeToArray(serialized_pb, serialized_size);
	sendReplyMessage(socket, serialized_pb, serialized_size);
	delete[] serialized_pb;
}
Beispiel #3
0
serialized_message serialize_message(Message const &message)
{
    size_t msg_size = message.ByteSize();
    size_t size = msg_size + MAX_VARINT_BYTES;
    std::shared_ptr<uint8> buffer(new uint8[size]);
    auto it = CodedOutputStream::WriteVarint32ToArray(msg_size, buffer.get());
    bool written = message.SerializeToArray(it, msg_size);
    assert(written);
    return serialized_message(msg_size + (it - buffer.get()), buffer);
}
Beispiel #4
0
void CNetworkPlayer::TryDequeueCommands () {
    while (m_unreliableQueue.size() > 0) {
        if ((m_nextMessage.ByteSize() + m_unreliableQueue.front().ByteSize()) > SOCKET_MAX_MESSAGE_SIZE) {
            return;
        }

        *m_nextMessage.add_commands() = m_unreliableQueue.front();
        m_unreliableQueue.pop();
    }
}
Beispiel #5
0
bool Caster::sendMessage(const Message& message) {
    int msg_size = message.ByteSize();
    QByteArray data;
    data.resize(msg_size + 4);
    qToBigEndian<uint32_t>(msg_size,
                           reinterpret_cast<unsigned char*>(data.data()));
    if (!message.SerializeToArray(data.data() + 4, msg_size)) {
        return false;
    }
    return socket_.write(data) == data.size();
}
Beispiel #6
0
int     MetaSerializer::Pack(void* obj,Buffer & buffer)
{
    Message*    msg  =  (Message*)obj;//m_pObjFactory->GetPrototype(meta);
    //const Descriptor* meta =  msg->GetDescriptor();
    bool ret =  msg->SerializeToArray(buffer.pBuffer, buffer.iCap);
    if(!ret)
    {
        LOG_ERROR("meta name = %s pack error !",msg->GetDescriptor()->name().c_str());
        buffer.iUsed = 0;
        return -1;
    }
    buffer.iUsed = msg->ByteSize();
    return 0;
}
Beispiel #7
0
void CNetworkPlayer::TryDequeueReliableCommands () {
    unsigned seq = (m_currentSeq == m_lastSentSeq) ? m_currentSeq + 1 : m_currentSeq;

    ReliableCommand rc;
    rc.set_sequence(seq);

    while (m_reliableQueue.size() > 0) {
        *rc.mutable_command() = m_reliableQueue.front();

        if ((m_nextMessage.ByteSize() + rc.ByteSize()) > SOCKET_MAX_MESSAGE_SIZE) {
            return;
        }

        *m_nextMessage.add_reliablecommands() = rc;
        m_currentSeq = seq;
        m_reliableQueue.pop();
    }
}
Beispiel #8
0
bool Robot::send(int msgId, Message &msg)
{
	if (!m_link->isopen()) {
		// LOG_ERROR << "robot<" << m_robotId << "> [" << m_link->m_localAddr.toIpPort() << "] <-> gatesvr [" << m_link->m_peerAddr.toIpPort() << "] is not open";
		return false;
	}

	if (!m_isEncrypt) {
		m_link->send(msgId, msg);
		return true;
	}

	uint32 headSize = sizeof(NetMsgHead);
	int size = msg.ByteSize();

	bool ok = msg.SerializeToArray(m_link->m_net->g_encryptBuf + headSize + EncryptHeadLen, size);
	if (!ok) {
		LOG_ERROR << "robot<" << m_robotId << "> [" << m_link->getLocalAddr().toIpPort() << "] <-> gatesvr [" << m_link->getPeerAddr().toIpPort()
		          << "] send msg failed, SerializeToArray error, [len=" << size << "] failed, content = [" << msgtool::getMsgDebugString(msg) << "]";

		return false;
	}

	// 添加加解密头尾
	uint8* decryptBuf = (uint8*)(m_link->m_net->g_encryptBuf + headSize);
	int decryptBufLen = size + EncryptHeadLen + EncryptTailLen;

	encrypttool::encrypt(decryptBuf, decryptBufLen, m_encryptKey, sizeof(m_encryptKey));

	NetMsgHead* pHeader = (NetMsgHead*)m_link->m_net->g_encryptBuf;

	int packetLen = msgtool::buildNetHeader(pHeader, msgId, decryptBufLen);
	if (packetLen <= 0) {
		LOG_ERROR << "robot<" << m_robotId << "> [" << m_link->getLocalAddr().toIpPort() << "] <-> gatesvr [" << m_link->getPeerAddr().toIpPort()
		          << "] pakcetLen = " << packetLen;
		return false;
	}

	m_link->send(m_link->m_net->g_encryptBuf, packetLen);

	return true;
}
Beispiel #9
0
int     MetaSerializer::GetPackSize(void* obj)
{
    Message*    msg  =  (Message*)obj;//m_pObjFactory->GetPrototype(meta);
    return    msg->ByteSize();
}