void ConnectionHandler::SendProtobufMessage(UInt32 opcode, google::protobuf::Message &msg) {
// send length
UInt32Bytes length{ByteOrder::toLittleEndian(static_cast<UInt32>(msg.ByteSize()))};
socket_.sendBytes(length.bytes, 4);
// send opcode
UInt32Bytes opcodeBytes{Poco::ByteOrder::toLittleEndian(opcode)};
socket_.sendBytes(opcodeBytes.bytes, 4);
// send data
socket_.sendBytes(msg.SerializeAsString().data(), msg.ByteSize());
}
size_t ProtobufSocketSerializer::serialize(
const ::google::protobuf::Message &msg, char *&packet) {
size_t size = PROTOBUF_HEADER_LENGTH + (size_t) msg.ByteSize();
packet = new char[size]();
::google::protobuf::io::ArrayOutputStream aos(packet, (int) size);
::google::protobuf::io::CodedOutputStream coded_output(&aos);
coded_output.WriteLittleEndian32((google::protobuf::uint32) msg.ByteSize());
msg.SerializeToCodedStream(&coded_output);
return size;
}
void Client::InternalSendMessage(const google::protobuf::Message& _message) {
if (state_ != CONNECTED) {
LOG(ERROR) << "Client is not connected. Dropping message" << std::endl;
return;
}
// Generate a zero rid.
REQID rid = REQID_Generator::generate_zero_reqid();
// Make the outgoing packet
sp_int32 byte_size = _message.ByteSize();
sp_uint32 sop = OutgoingPacket::SizeRequiredToPackString(_message.GetTypeName()) + REQID_size +
OutgoingPacket::SizeRequiredToPackProtocolBuffer(byte_size);
auto opkt = new OutgoingPacket(sop);
CHECK_EQ(opkt->PackString(_message.GetTypeName()), 0);
CHECK_EQ(opkt->PackREQID(rid), 0);
CHECK_EQ(opkt->PackProtocolBuffer(_message, byte_size), 0);
Connection* conn = static_cast<Connection*>(conn_);
if (conn->sendPacket(opkt, NULL) != 0) {
LOG(ERROR) << "Some problem sending message thru the connection. Dropping message" << std::endl;
delete opkt;
return;
}
return;
}
int LinkImpl::serialize(const google::protobuf::Message &message)
{
auto sz = message.ByteSize();
if(!message.SerializeToArray(data,sz))
throw std::runtime_error("Message failed to serialize (probably too big)");
return sz;
}
void ProtobufCodec::fillEmptyBuffer(netlib::Buffer *buf,const google::protobuf::Message &message)
{
assert(buf->readableSize() == 0);
const std::string &typeName = message.GetTypeName();
//类型名字长度包含'/0'
int32_t nameLen = static_cast<int32_t>(typeName.size() + 1);
//消息长度
int byte_size = message.ByteSize();
buf->makeSureEnough(byte_size);
//总长度
int32_t len = nameLen + kHeaderLen + byte_size;
buf->appendInt32(len);
//将名字长度和名字加入到buffer中去
buf->appendInt32(nameLen);
buf->append(typeName.c_str(),nameLen);
uint8_t *start = reinterpret_cast<uint8_t *>(buf->getWritePeek());
//将消息从start位置开始序列化
uint8_t *end = message.SerializeWithCachedSizesToArray(start);
buf->moveWriteIndex(byte_size);
assert(end - start == byte_size);
}
bool Connection::sendMessage(Connection::MessageType type, const google::protobuf::Message& msg, const Message::Deadline& expires, bool prioritized)
{
size_t bufLimit = prioritized ? SEND_BUF_EMERGENCY : SEND_BUF;
if (_sndQueue.size() > bufLimit)
return false;
auto buf = new Message(expires);
// Encode
{
::google::protobuf::io::StringOutputStream of(&buf->buf);
::google::protobuf::io::CodedOutputStream stream(&of);
stream.WriteTag(::google::protobuf::internal::WireFormatLite::MakeTag(type, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
stream.WriteVarint32(msg.ByteSize());
bool encoded = msg.SerializeToCodedStream(&stream);
BOOST_VERIFY(encoded);
}
_sndQueue.enqueue(buf);
_stats->outgoingMessages += 1;
_stats->outgoingMessagesCurrent += 1;
// Push out at once unless _queued;
if (_sendWaiting == 0)
trySend();
return true;
}
bool sendToClinet(const PkgHead& pkg_head, const google::protobuf::Message& message)
{
char buff[MAX_BUFF];
char *p = buff;
int32_t pkg_head_size = sizeof(pkg_head);
int32_t pkg_body_size = message.ByteSize();
int32_t pkg_total_size = pkg_head_size + pkg_body_size;
__BEGIN_PROC__
//消息头
int32_t *header = (int32_t *)p;
*header = htonl(pkg_total_size);
p += sizeof(*header);
int32_t send_len = sizeof(*header) + pkg_total_size;
if(send_len > MAX_BUFF)
{
LOG_ERROR(0, "there is no enough buff. buff size:%d, real size:%d", MAX_BUFF, send_len);
break;
}
//协议包头
PkgHead *p_pkg_head = (PkgHead *)p;
*p_pkg_head = pkg_head;
p_pkg_head->body_len = pkg_body_size;
p_pkg_head->pack();
p += sizeof(PkgHead);
//协议包体
if (!message.SerializeToArray(p, pkg_body_size))
{
LOG_ERROR(0, "message.SerializeToArray failed");
break;
}
int32_t ret = 0;
ret = skynet_socket_send(0, pkg_head.client_fd, buff, send_len);
if(-1 == ret)
{
LOG_ERROR(0, "skynet_socket_send failed");
break;
}
LOG_DEBUG(0, "send_len:%d pkg_body_len:%d", send_len, pkg_body_size);
return true;
__END_PROC__
return false;
}
void GridClientProtobufMarshaller::marshalMsg(const ::google::protobuf::Message& msg, int8_t*& pBuffer,
unsigned long& bufferLength) {
bufferLength = msg.ByteSize();
pBuffer = new int8_t[bufferLength];
msg.SerializeToArray(pBuffer, bufferLength);
}
/**
* Writes a given protobuff message to the buffer (this->buffer) prefixed by a header.
* @return the total size (header size + message size). Return 0 if the total size is bigger than 'Protos.Core.Settings.max_udp_datagram_size'.
*/
int UDPListener::writeMessageToBuffer(Common::MessageHeader::MessageType type, const google::protobuf::Message& message)
{
const Common::MessageHeader header(type, message.ByteSize(), this->getOwnID());
const int nbBytesWritten = Common::Message::writeMessageToBuffer(this->buffer, this->MAX_UDP_DATAGRAM_PAYLOAD_SIZE, header, &message);
if (!nbBytesWritten)
L_ERRO(QString("Datagram size too big: %1, max allowed: %2").arg(Common::MessageHeader::HEADER_SIZE + header.getSize()).arg(this->MAX_UDP_DATAGRAM_PAYLOAD_SIZE));
return nbBytesWritten;
}
void Connection::messageToNetwork(const ::google::protobuf::Message &msg, unsigned int msgType, QByteArray &cache) {
int len = msg.ByteSize();
if (len > 0x7fffff)
return;
cache.resize(len + 6);
unsigned char *uc = reinterpret_cast<unsigned char *>(cache.data());
qToBigEndian<quint16>(msgType, & uc[0]);
qToBigEndian<quint32>(len, & uc[2]);
msg.SerializeToArray(uc + 6, len);
}
void Client::SendResponse(REQID _id, const google::protobuf::Message& _response) {
sp_int32 byte_size = _response.ByteSize();
sp_uint32 data_size = OutgoingPacket::SizeRequiredToPackString(_response.GetTypeName()) +
REQID_size + OutgoingPacket::SizeRequiredToPackProtocolBuffer(byte_size);
auto opkt = new OutgoingPacket(data_size);
CHECK_EQ(opkt->PackString(_response.GetTypeName()), 0);
CHECK_EQ(opkt->PackREQID(_id), 0);
CHECK_EQ(opkt->PackProtocolBuffer(_response, byte_size), 0);
InternalSendResponse(opkt);
return;
}
bool Connection::encode(Connection::MessageType type, const google::protobuf::Message &msg) {
byte* buf = _sendBuf.allocate(MAX_MSG);
::google::protobuf::io::ArrayOutputStream of(buf, MAX_MSG);
::google::protobuf::io::CodedOutputStream stream(&of);
stream.WriteTag(::google::protobuf::internal::WireFormatLite::MakeTag(type, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
stream.WriteVarint32(msg.ByteSize());
bool res = msg.SerializeToCodedStream(&stream);
if (res)
_sendBuf.charge(stream.ByteCount());
return res;
}
bool WriteMessage(const shared_ptr<UnixSocketConnection> &connection,
uint32_t type,
const google::protobuf::Message &response) {
shared_ptr<vector<char> > data(new vector<char>(response.ByteSize() + sizeof(type)));
char *ptr = &(*data)[0];
*reinterpret_cast<uint32_t *>(ptr) = type;
if (!response.SerializeToArray(ptr + sizeof(type), data->size() - sizeof(type))) {
WARNING_LOG("serialize message to string failed.");
return false;
}
connection->Write(data);
return true;
}
int UDPListener::writeMessageToBuffer(Common::MessageHeader::MessageType type, const google::protobuf::Message& message)
{
const int bodySize = message.ByteSize();
Common::MessageHeader header(type, bodySize, this->peerManager->getID());
if (Common::MessageHeader::HEADER_SIZE + bodySize > static_cast<int>(SETTINGS.get<quint32>("max_udp_datagram_size")))
{
L_ERRO(QString("Datagram size too big : %1").arg(Common::MessageHeader::HEADER_SIZE + bodySize));
return 0;
}
Common::MessageHeader::writeHeader(this->buffer, header);
message.SerializeToArray(this->bodyBuffer, BUFFER_SIZE - Common::MessageHeader::HEADER_SIZE);
return Common::MessageHeader::HEADER_SIZE + bodySize;
}
void NetworkClient::Send(int packetID, const google::protobuf::Message& msg)
{
int msgSize = msg.ByteSize();
int bufferSize = Packet::Header::Size + msgSize;
Packet::Header header;
header.packetID = packetID;
header.length = msgSize;
auto buffer = std::unique_ptr<char[]>(new char[bufferSize]);
header.Serialize(buffer.get());
msg.SerializeToArray(buffer.get() + Packet::Header::Size, msgSize);
conn->Send(bufferSize, buffer.get());
}
void CGroupManagerClient::SendMessageToClient(const ::google::protobuf::Message &msg, s32 msgid)
{
int count = msg.ByteSize();
byte buf[MAX_MSG_LEN] = {0};
*((s32*)buf) = msgid;
if( msg.SerializeToArray(buf+MSG_ID_LEN, MAX_MSG_LEN) )
{
if( !SendPkg( buf, count+MSG_ID_LEN ) )
{
SERVER_LOG_ERROR( "CGroupManagerClient,SendMessageToGroupServer,SendPkg" );
}
}
else
{
SERVER_LOG_ERROR( "CGroupManagerClient,SendMessageToGroupServer,SerializeToArray" );
}
}
void mumlib::Transport::sendControlMessagePrivate(MessageType type, google::protobuf::Message &message) {
const uint16_t type_network = htons(static_cast<uint16_t>(type));
const int size = message.ByteSize();
const uint32_t size_network = htonl(size);
const int length = sizeof(type_network) + sizeof(size_network) + size;
uint8_t buff[MAX_TCP_LENGTH];
memcpy(buff, &type_network, sizeof(type_network));
memcpy(buff + sizeof(type_network), &size_network, sizeof(size_network));
message.SerializeToArray(buff + sizeof(type_network) + sizeof(size_network), size);
sendSsl(buff, length);
}
///
/// \brief ·¢ËÍÊý¾Ý
///
/// \author albert.xu
/// \date 2017/08/05
///
xgc_void CClientSession::Send( xgc_uint16 msgid, ::google::protobuf::Message& msg )
{
#pragma pack(1)
struct
{
MessageHeader h;
char b[1024 * 4];
} m;
#pragma pack()
xgc_uint16 data_size = msg.ByteSize();
xgc_uint16 pack_size = sizeof( MessageHeader ) + data_size;
m.h.length = htons( pack_size );
m.h.message = htons( msgid );
msg.SerializeToArray( m.b, sizeof( m.b ) );
SendPacket( handle_, &m, pack_size );
}
// Write out the given protobuf to the specified file descriptor by
// first writing out the length of the protobuf followed by the contents.
// NOTE: On error, this may have written partial data to the file.
inline Try<Nothing> write(int fd, const google::protobuf::Message& message)
{
if (!message.IsInitialized()) {
return Error("Uninitialized protocol buffer");
}
// First write the size of the protobuf.
uint32_t size = message.ByteSize();
std::string bytes = std::string((char*) &size, sizeof(size));
Try<Nothing> result = os::write(fd, bytes);
if (result.isError()) {
return Error("Failed to write size: " + result.error());
}
if (!message.SerializeToFileDescriptor(fd)) {
return Error("Failed to write/serialize message");
}
return Nothing();
}
int CAuth::Send2Server(XYHeaderIn& Header, unsigned int DstID, char SendType, char Flag, const google::protobuf::Message& Message)
{
BusHeader CurBusHeader;
int HeaderLen = CurBusHeader.GetHeaderLen() + Header.GetHeaderLen();
CurBusHeader.PkgLen = HeaderLen + Message.ByteSize();
CurBusHeader.CmdID = Cmd_Transfer;
CurBusHeader.SrcID = GetServerID();
CurBusHeader.DstID = DstID;
CurBusHeader.SendType = SendType;
CurBusHeader.Flag = Flag;
CurBusHeader.Write(m_pSendBuff);
Header.Write(m_pSendBuff+CurBusHeader.GetHeaderLen());
if(!Message.SerializeToArray(m_pSendBuff+HeaderLen, XY_PKG_MAX_LEN-HeaderLen))
{
XF_LOG_WARN(0, 0, "pack err msg failed");
return -1;
}
int Ret = m_SendQueue.InQueue(m_pSendBuff, CurBusHeader.PkgLen);
if(Ret == m_SendQueue.E_SHM_QUEUE_FULL)
{
XF_LOG_WARN(0, 0, "m_SendQueue InQueue failed, queue full");
return -1;
}
else if (Ret != 0)
{
XF_LOG_WARN(0, 0, "m_SendQueue InQueue failed, Ret=%d", Ret);
return -1;
}
else
{
XF_LOG_TRACE(0, 0, "m_SendQueue InQueue Success,[%s]", CStrTool::Str2Hex(m_pSendBuff, CurBusHeader.PkgLen));
}
return 0;
}
// Write out the given protobuf to the specified file descriptor by
// first writing out the length of the protobuf followed by the
// contents.
inline Result<bool> write(int fd, const google::protobuf::Message& message)
{
if (!message.IsInitialized()) {
LOG(ERROR) << "Failed to write protocol buffer to file, "
<< "protocol buffer is not initialized!";
return false;
}
uint32_t size = message.ByteSize();
ssize_t length = ::write(fd, (void*) &size, sizeof(size));
if (length == -1) {
std::string error = strerror(errno);
error = error + " (" + __FILE__ + ":" + utils::stringify(__LINE__) + ")";
return Result<bool>::error(error);
}
CHECK(length != 0);
CHECK(length == sizeof(size)); // TODO(benh): Handle a non-blocking fd?
return message.SerializeToFileDescriptor(fd);
}
/**
This function is used to receive and deserialize a protobuf object from a ZMQ socket.
@param inputSocketToReceiveFrom: This is the socket to receive the object from
@param inputMessageBuffer: This is the buffer to place the received object in
@param inputFlags: The flags to pass to the ZMQ socket
@param inputPreappendedDataBuffer: The buffer to place x bytes before the message in
@param inputPreappendedDataSize: How much data to expect to be preappended
@param inputPostappendedDataBuffer: The buffer to place x bytes before the message in
@param inputPostappendedDataSize: How much data to expect to be postappended
@return: <true if message received, true if message deserialized correctly>
@throws: This function can throw exceptions
*/
std::tuple<bool, bool> pylongps::receiveProtobufMessage(zmq::socket_t &inputSocketToReceiveFrom, google::protobuf::Message &inputMessageBuffer, int inputFlags, char *inputPreappendedDataBuffer, int inputPreappendedDataSize, char *inputPostappendedDataBuffer, int inputPostappendedDataSize)
{
if(inputPreappendedDataSize < 0 || inputPostappendedDataSize < 0)
{
throw SOMException("Negative data size\n", INVALID_FUNCTION_INPUT, __FILE__, __LINE__);
}
if((inputPreappendedDataSize > 0 && inputPreappendedDataBuffer == nullptr) || (inputPostappendedDataSize < 0 && inputPostappendedDataBuffer == nullptr))
{
throw SOMException("Data size > 0 but buffer is nullptr\n", INVALID_FUNCTION_INPUT, __FILE__, __LINE__);
}
bool messageReceived = false;
bool messageDeserialized = false;
std::unique_ptr<zmq::message_t> messageBuffer;
SOM_TRY
messageBuffer.reset(new zmq::message_t);
SOM_CATCH("Error initializing ZMQ message")
SOM_TRY
messageReceived = inputSocketToReceiveFrom.recv(messageBuffer.get(), inputFlags);
SOM_CATCH("Error, unable to receive message\n")
if(messageReceived == false)
{ //Didn't get a message
return std::tuple<bool, bool>(messageReceived, messageDeserialized);
}
//Attempt to retrieve any preappended data
if(messageBuffer->size() < inputPreappendedDataSize)
{ //Message isn't valid (smaller than expected preappended data)
return std::tuple<bool, bool>(messageReceived, messageDeserialized);
}
else if(inputPreappendedDataSize > 0)
{ //Preappended data is expected and the message is large enough to get it
memcpy((void *) inputPreappendedDataBuffer, messageBuffer->data(), inputPreappendedDataSize);
}
//Deserialize message
inputMessageBuffer.ParseFromArray(((char *) messageBuffer->data())+inputPreappendedDataSize, messageBuffer->size()-inputPreappendedDataSize);
if(!inputMessageBuffer.IsInitialized())
{
return std::tuple<bool, bool>(messageReceived, messageDeserialized);
}
if(inputPostappendedDataSize > 0)
{
int protobufMessageSize = inputMessageBuffer.ByteSize();
if((protobufMessageSize+inputPreappendedDataSize+inputPostappendedDataSize) > messageBuffer->size())
{
return std::tuple<bool, bool>(messageReceived, messageDeserialized);
}
else
{
memcpy((void *) inputPostappendedDataBuffer, (void *) (((char *) messageBuffer->data()) + protobufMessageSize + inputPreappendedDataSize), inputPostappendedDataSize);
messageDeserialized = true;
}
}
else
{
messageDeserialized = true;
}
return std::tuple<bool, bool>(messageReceived, messageDeserialized);
}