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 protobuf+unsubscr...@googlegroups.com.
To post to this group, send email to protobuf@googlegroups.com.
Visit this group at https://groups.google.com/group/protobuf.
For more options, visit https://groups.google.com/d/optout.

Reply via email to