I'm utilizing Protobuf3 with c# for my client & c++ for my server, where
the .proto's are generated from the corresponding protoc3 compiler. I'm new
to utilizing Google Protocol Buffers, where I'm currently trying to figure
out how to re-parse the received bytes on my server that were sent from my
client to turn it back into it's originating google::protobuf::Message
object on my c++ server.
My client is sending a CodedOutputStream in c# :
public PacketHandler()
> {
> m_client = GetComponent<ClientObject>();
> m_packet = new
> byte[m_client.GetServerConnection().GetMaxPacketSize()];
> m_ostream = new BinaryWriter(new MemoryStream(m_packet));
> }
>
> public void DataToSend(IMessage message)
> {
> // message looks like :
> // Base.BaseMessage msg = new Base.BaseMessage();
> // msg.Msg = Google.Protobuf.WellKnownTypes.Any.Pack(new
> Server.Ping());
> CodedOutputStream output = new
> CodedOutputStream(m_ostream.BaseStream, true);
> output.WriteMessage(message);
> output.Flush();
> m_client.GetServerConnection().GetClient().Send(m_packet,
> message.CalculateSize());
> }
>
This seems to be working, the message that is sent right now is a simple
Ping message that looks like this:
// Ping.proto
> syntax = "proto3";
> package server;
>
> import "BaseMessage.proto";
>
> message Ping {
>
> }
>
> message Pong {
>
> }
>
My BaseMessage looks like this :
// BaseMessage.proto
> syntax = "proto3";
>
> package base;
>
> message BaseMessage {
> uint32 size = 1;
> google.protobuf.Any msg = 2;
> }
>
The received message that I am getting on my c++ server side looks like
this : #\u0012!\n\u001Ftype.googleapis.com/server.Pin
When receiving the message I am attempting to re-parse using the
CodedInputStream object by attempting to parse the received bytes.
PacketHandler::PacketHandler(QByteArray& packet, const
> Manager::ClientPtr client) :
> m_packet(packet),
> m_client(client)
> {
> unsigned char buffer[512] = { 0 };
> unsigned char data[packet.size()] = { 0 };
> memcpy(data, packet.data(), packet.size());
>
> google::protobuf::uint32 msgSize;
> google::protobuf::io::CodedInputStream inputStream(data,
> packet.size());
> inputStream.ReadVarint32(&msgSize); // read the prefixed message
> length
>
> base::BaseMessage msg;
> msg.ParseFromCodedStream(&inputStream);
>
> if (msg.msg().Is<server::Ping>())
> {
> // This never occurs
> server::Ping pingMsg;
> msg.msg().UnpackTo(&pingMsg);
> qDebug() << "Is a Ping";
> }
> qDebug() << msg.size(); // this isn't the correct value either
> }
>
This is where I am a bit unsure of the process that is needing to be done
to re-parse the message into the particular message. I'm reading the
initial prefixed length of message to remove that from the parse, where the
inputStream has the remaining bytes for the message identification.
--
You received this message because you are subscribed to the Google Groups
"Protocol Buffers" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/protobuf.
For more options, visit https://groups.google.com/d/optout.
