// Update is called once per frame
void Update()
{
if (!connected)
{
return;
}
// Wating for Param#1 Microseconds to check is there any data send from server.
// 1 second == 1000 Millisecond == 1000 * 1000 Microseconds
if (socket.Poll(10000, SelectMode.SelectRead))
{
try {
byte[] data = SockRecv();
CodedInputStream stream = CodedInputStream.CreateInstance(data);
CodeBattle.Marine marine = CodeBattle.Marine.ParseFrom(stream);
print("Receive: " + marine);
}
catch (Exception e) {
print(e);
connected = false;
return;
}
}
if (Input.GetKeyDown(KeyCode.A))
{
byte[] data = PackData(id++);
try {
SockSend(data);
}
catch {
print("Socket Send Error");
}
}
}
private static OrcProto.PostScript extractPostScript(ByteBuffer bb, string path,
int psLen, int psAbsOffset)
{
// TODO: when PB is upgraded to 2.6, newInstance(ByteBuffer) method should be used here.
Debug.Assert(bb.hasArray());
CodedInputStream @in = CodedInputStream.CreateInstance(
bb.array(), bb.arrayOffset() + psAbsOffset, psLen);
OrcProto.PostScript ps = OrcProto.PostScript.ParseFrom(@in);
checkOrcVersion(LOG, path, ps.VersionList.flip());
// Check compression codec.
switch (ps.Compression)
{
case OrcProto.CompressionKind.NONE:
case OrcProto.CompressionKind.ZLIB:
case OrcProto.CompressionKind.SNAPPY:
case OrcProto.CompressionKind.LZO:
break;
default:
throw new ArgumentException("Unknown compression");
}
return(ps);
}
public void TestNegativeEnumArray()
{
int arraySize = 1 + 1 + (11 * 5);
int msgSize = arraySize;
byte[] bytes = new byte[msgSize];
CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
uint tag = WireFormat.MakeTag(8, WireFormat.WireType.Varint);
for (int i = 0; i >= -5; i--)
{
output.WriteTag(tag);
output.WriteEnum(i);
}
Assert.AreEqual(0, output.SpaceLeft);
CodedInputStream input = CodedInputStream.CreateInstance(bytes);
Assert.IsTrue(input.ReadTag(out tag));
RepeatedField <SampleEnum> values = new RepeatedField <SampleEnum>();
values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x));
Assert.AreEqual(6, values.Count);
Assert.AreEqual(SampleEnum.None, values[0]);
Assert.AreEqual(((SampleEnum)(-1)), values[1]);
Assert.AreEqual(SampleEnum.NegativeValue, values[2]);
Assert.AreEqual(((SampleEnum)(-3)), values[3]);
Assert.AreEqual(((SampleEnum)(-4)), values[4]);
Assert.AreEqual(((SampleEnum)(-5)), values[5]);
}
public IMessage ReadMessage(IBuilder builder)
{
return(builder.WeakMergeFrom(CodedInputStream.CreateInstance(this.GetPayload(Stream))).WeakBuild());
// this._stream.ReadMessage(builder, ExtensionRegistry.Empty); // this method doesn't seem to work with 7728. /raist.
// return builder.WeakBuild();
}
public void WriteTo_Message()
{
var message1 = new ForeignMessage {
C = 20
};
var message2 = new ForeignMessage {
C = 25
};
uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
var field = new RepeatedField <ForeignMessage> {
message1, message2
};
var stream = new MemoryStream();
var output = CodedOutputStream.CreateInstance(stream);
field.WriteTo(output, FieldCodec.ForMessage(tag, ForeignMessage.Parser));
output.Flush();
stream.Position = 0;
var input = CodedInputStream.CreateInstance(stream);
input.AssertNextTag(tag);
Assert.AreEqual(message1, input.ReadMessage(ForeignMessage.Parser));
input.AssertNextTag(tag);
Assert.AreEqual(message2, input.ReadMessage(ForeignMessage.Parser));
Assert.IsTrue(input.IsAtEnd);
}
public void AddEntriesFrom_Message()
{
var message1 = new ForeignMessage {
C = 2000
};
var message2 = new ForeignMessage {
C = -250
};
uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
var stream = new MemoryStream();
var output = CodedOutputStream.CreateInstance(stream);
output.WriteTag(tag);
output.WriteMessage(message1);
output.WriteTag(tag);
output.WriteMessage(message2);
output.Flush();
stream.Position = 0;
var field = new RepeatedField <ForeignMessage>();
var input = CodedInputStream.CreateInstance(stream);
input.AssertNextTag(tag);
field.AddEntriesFrom(input, FieldCodec.ForMessage(tag, ForeignMessage.Parser));
CollectionAssert.AreEqual(new[] { message1, message2 }, field);
Assert.IsTrue(input.IsAtEnd);
}
public void AddEntriesFrom_NonPackedInt32()
{
uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.Varint);
var stream = new MemoryStream();
var output = CodedOutputStream.CreateInstance(stream);
output.WriteTag(nonPackedTag);
output.WriteInt32(10);
output.WriteTag(nonPackedTag);
output.WriteInt32(999);
output.WriteTag(nonPackedTag);
output.WriteInt32(-1000); // Just for variety...
output.Flush();
stream.Position = 0;
// Deliberately "expecting" a packed tag, but we detect that the data is
// actually not packed.
uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
var field = new RepeatedField <int>();
var input = CodedInputStream.CreateInstance(stream);
input.AssertNextTag(nonPackedTag);
field.AddEntriesFrom(input, FieldCodec.ForInt32(packedTag));
CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field);
Assert.IsTrue(input.IsAtEnd);
}
public ProtobufPackageInfo Filter(BufferList data, out int rest)
{
rest = 0;
var buffStream = new BufferStream();
buffStream.Initialize(data);
var stream = CodedInputStream.CreateInstance(buffStream);
var varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= 0)
{
return(default(ProtobufPackageInfo));
}
var total = data.Total;
var packageLen = varint32 + (int)stream.Position;
if (total >= packageLen)
{
rest = total - packageLen;
var body = stream.ReadRawBytes(varint32);
var message = DefeatMessage.ParseFrom(body);
var requestInfo = new ProtobufPackageInfo(message.Type, message);
return(requestInfo);
}
return(default(ProtobufPackageInfo));
}
//处理粘包(递归) 接收的长度
private void HandleReceveBytes(byte[] recveBytes, Int32 recelen)
{
try
{
CodedInputStream inputStream = CodedInputStream.CreateInstance(recveBytes);
//数据所有长度
Int32 varint32 = (Int32)inputStream.ReadRawVarint32();
//获取消息头长度
Int32 headlength = CodedOutputStream.ComputeRawVarint32Size((uint)varint32);
// System.Console.WriteLine("len:" + recelen + "\nvarint32:" + varint32 + "\nlen:" + headlength);
//如果所有有长度大于接收的长度。断包了
if (varint32 > recelen - headlength)
{
//需要的长度
Int32 needlen = varint32 + headlength - recelen;
//已经的长度
Int32 haslen = recelen;
byte[] resArr = new byte[varint32 + headlength];
recveBytes.CopyTo(resArr, 0);
while (true)
{
//
byte[] newResult = new byte[needlen];
int len = clientSocket.Receive(newResult, 0, needlen, SocketFlags.None);
//System.Console.WriteLine("len:" + len + "\nhaslen:" + haslen + "\nneedlen:" + needlen);
newResult.CopyTo(resArr, haslen);
haslen += len;
needlen -= len;
if (needlen == 0)
{
break;
}
}
Thread thread = new Thread(new ParameterizedThreadStart(ReceiveDataHandle));
thread.Start(resArr);
}
else
{
Thread thread = new Thread(new ParameterizedThreadStart(ReceiveDataHandle));
thread.Start(recveBytes);
// ReceiveDataHandle(recveBytes);
//如果实际接受的长度大于包体长度+包头长（粘包）
if (recelen > (varint32 + headlength))
{
//剩下的进行解决
byte[] res = recveBytes.Skip <byte>(varint32 + headlength).ToArray <byte>();
HandleReceveBytes(res, recelen - varint32 - headlength);
}
}
}
catch (Exception exc)
{
System.Console.WriteLine("接受数据出问题：" + exc);
}
}
public PacketDistributed ParseFrom(byte[] data, int nLen)
{
CodedInputStream input = CodedInputStream.CreateInstance(data, 0, nLen);
PacketDistributed inst = MergeFrom(input, this);
input.CheckLastTagWas(0);
return(inst);
}
private int GetReceivedMessageSize(out byte[] buffer)
{
buffer = new byte[MAX_VARINT32_SIZE];
socket.Receive(buffer);
CodedInputStream tmp = CodedInputStream.CreateInstance(buffer);
return((int)tmp.ReadRawVarint32());
}
public static void Route(ConnectionDataEventArgs e)
{
var stream = CodedInputStream.CreateInstance(e.Data.ToArray());
while (!stream.IsAtEnd)
{
Identify(e.Connection, stream);
}
}
/**
* 协议解析，把这里搞明白了，就没白看
*/
public void OnDataReceive(Object sender, DataEventArgs e)
{
//DataEventArgs 里面有 byte[] Data是从协议层接收上来的字节数组，需要程序端进行缓存
Console.WriteLine("buff length: {0}, offset: {1}", e.Length, e.Offset);
if (e.Length <= 0)
{
return;
}
//把收取上来的自己全部缓存到本地 buffer 中
Array.Copy(e.Data, 0, buffer.Data, buffer.Length, e.Length);
buffer.Length += e.Length;
CodedInputStream stream = CodedInputStream.CreateInstance(buffer.Data);
while (!stream.IsAtEnd)
{
//标记读取的Position, 在长度不够时进行数组拷贝，到下一次在进行解析
int markReadIndex = (int)stream.Position;
//Protobuf 变长头, 也就是消息长度
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try
{
byte[] body = stream.ReadRawBytes(varint32);
LaidianCommandModel response = LaidianCommandModel.ParseFrom(body);
taskMsg.Enqueue(response);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
else
{
/**
* 本次数据不够长度,缓存进行下一次解析
*/
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
/**
* 缓存未处理完的字节
*/
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
public virtual Stream Invoke(Stream request)
{
ICodedInputStream input = CodedInputStream.CreateInstance(request);
string method = null;
input.ReadString(ref method);
IMessageLite response = _createStub.CallMethod(method, input, ExtensionRegistry.Empty);
return(new MemoryStream(response.ToByteArray()));
}
public static void ReadProto(PcapDotNet.Packets.Datagram payload)
{
Console.Write('.');
var stream = CodedInputStream.CreateInstance(payload.ToArray());
while (!stream.IsAtEnd)
{
Identify(stream);
}
}
public IEnumerable <byte> ReadBytes()
{
var networkStream = TcpClientWrapper.GetStream();
var codedInputStream = CodedInputStream.CreateInstance(networkStream);
var messageLength = codedInputStream.ReadRawVarint64();
for (ulong i = 0; i < messageLength; i++)
{
yield return(codedInputStream.ReadRawByte());
}
}
public ToonHandleHelper(D3.OnlineService.EntityId entityID)
{
var stream = CodedInputStream.CreateInstance(entityID.ToByteArray());
ulong tmp = 0;
// I believe this actually calls ReadRawVarint64(), but just to be sure..
stream.ReadUInt64(ref tmp);
this.ID = tmp;
//this.Program = stream.ReadRawVarint32();
//this.Region = stream.ReadRawVarint32();
//this.Realm = stream.ReadRawVarint32();
}
public override bool TryBinding(IHttpContext context, IPathStack path, object controller, out IHttpHandler handler)
{
if (path.IsAtEnd)
{
handler = null; return(false);
}
string method = path.Pop();
if (!path.IsAtEnd)
{
handler = null; return(false);
}
IService service = controller as IService;
if (service == null)
{
throw new Exception("ProtobufControllerAttribute can only be applied to classes implementing IService.");
}
var descriptor = service.DescriptorForType.FindMethodByName(method);
if (descriptor == null)
{
handler = null; return(false);
}
IMessage request;
string verb = context.Request.HttpMethod;
if (verb == "GET")
{
request = null;
}
else if (verb == "POST" && context.Request.ContentType == CONTENT_TYPE)
{
request =
service.GetRequestPrototype(descriptor)
.WeakToBuilder()
.WeakMergeFrom(CodedInputStream.CreateInstance(context.Request.InputStream))
.WeakBuild();
}
else
{
handler = null;
return(false);
}
handler = new ProtobufServiceHandler(service, descriptor, request);
return(true);
}
void ReadLoop()
{
var reader = CodedInputStream.CreateInstance(socket.GetStream());
while (socket.Connected)
{
try {
HandlePacket(reader);
} catch (Exception e) {
Disconnect(e.Message);
}
}
}
/**
* Creates coded input stream (used for protobuf message parsing) with higher message size limit.
*
* @param name the name of the stream
* @param input the list of ranges of bytes for the stream; from disk or cache
* @param length the length in bytes of the stream
* @param codec the compression codec
* @param bufferSize the compression buffer size
* @return coded input stream
* @
*/
public static CodedInputStream createCodedInputStream(long?fileId,
string name,
List <DiskRange> input,
long length,
CompressionCodec codec,
int bufferSize)
{
InStream inStream = create(fileId, name, input, length, codec, bufferSize);
CodedInputStream codedInputStream = CodedInputStream.CreateInstance(inStream);
codedInputStream.SetSizeLimit(PROTOBUF_MESSAGE_MAX_LIMIT);
return(codedInputStream);
}
protected virtual RpcMultiPartResponse MultiPartMessage(RpcMultiPartRequest request, ExtensionRegistry registry)
{
RpcSession session = RpcCallContext.Session;
string messageId = request.TransactionId.ToBase64();
Stream message;
if (!session.TryGetValue(messageId, out message))
{
if (request.CurrentPosition != 0)
{
throw new InvalidDataException("The TransactionId is not valid.");
}
session.Add(messageId, message = CreateStream(request.TotalBytes));
message.SetLength(request.TotalBytes);
}
if (request.MessageStatus == RpcMultiPartRequest.Types.RpcMessageStatus.CANCEL)
{
message.Dispose();
session.Remove(messageId);
return(RpcMultiPartResponse.CreateBuilder().SetContinue(false).Build());
}
if (message.Position != request.CurrentPosition || message.Length != request.TotalBytes ||
request.BytesSent != request.PayloadBytes.Length)
{
throw new InvalidDataException();
}
request.PayloadBytes.WriteTo(message);
if (request.MessageStatus == RpcMultiPartRequest.Types.RpcMessageStatus.COMPLETE)
{
using (message)
{
session.Remove(messageId);
if (message.Position != request.TotalBytes)
{
throw new InvalidDataException();
}
message.Position = 0;
byte[] response =
next.CallMethod(request.MethodName, CodedInputStream.CreateInstance(message), registry).
ToByteArray();
return(RpcMultiPartResponse.CreateBuilder()
.SetResponseBytes(ByteString.CopyFrom(response))
.SetContinue(true)
.Build());
}
}
return(RpcMultiPartResponse.CreateBuilder()
.SetContinue(true)
.Build());
}
/// <summary>
/// Runs a single test. Error messages are displayed to Console.Error, and the return value indicates
/// general success/failure.
/// </summary>
public static bool RunTest(string typeName, string file)
{
Console.WriteLine("Benchmarking {0} with file {1}", typeName, file);
IMessage defaultMessage;
try
{
defaultMessage = MessageUtil.GetDefaultMessage(typeName);
}
catch (ArgumentException e)
{
Console.Error.WriteLine(e.Message);
return(false);
}
try
{
byte[] inputData = File.ReadAllBytes(file);
MemoryStream inputStream = new MemoryStream(inputData);
ByteString inputString = ByteString.CopyFrom(inputData);
IMessage sampleMessage = defaultMessage.WeakCreateBuilderForType().WeakMergeFrom(inputString).WeakBuild();
Benchmark("Serialize to byte string", inputData.Length, () => sampleMessage.ToByteString());
Benchmark("Serialize to byte array", inputData.Length, () => sampleMessage.ToByteArray());
Benchmark("Serialize to memory stream", inputData.Length, () => sampleMessage.WriteTo(new MemoryStream()));
Benchmark("Deserialize from byte string", inputData.Length,
() => defaultMessage.WeakCreateBuilderForType()
.WeakMergeFrom(inputString)
.WeakBuild()
);
Benchmark("Deserialize from byte array", inputData.Length,
() => defaultMessage.WeakCreateBuilderForType()
.WeakMergeFrom(CodedInputStream.CreateInstance(inputData))
.WeakBuild()
);
Benchmark("Deserialize from memory stream", inputData.Length, () =>
{
inputStream.Position = 0;
defaultMessage.WeakCreateBuilderForType()
.WeakMergeFrom(CodedInputStream.CreateInstance(inputStream))
.WeakBuild();
});
Console.WriteLine();
return(true);
}
catch (Exception e)
{
Console.Error.WriteLine("Error: {0}", e.Message);
Console.Error.WriteLine();
Console.Error.WriteLine("Detailed exception information: {0}", e);
return(false);
}
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer message, List <object> output)
{
Contract.Requires(context != null);
Contract.Requires(message != null);
Contract.Requires(output != null);
int length = message.ReadableBytes;
if (length <= 0)
{
return;
}
Stream inputStream = null;
try
{
CodedInputStream codedInputStream;
if (message.IoBufferCount == 1)
{
ArraySegment <byte> bytes = message.GetIoBuffer(message.ReaderIndex, length);
codedInputStream = CodedInputStream.CreateInstance(bytes.Array, bytes.Offset, length);
}
else
{
inputStream = new ReadOnlyByteBufferStream(message, false);
codedInputStream = CodedInputStream.CreateInstance(inputStream);
}
IBuilderLite newBuilder = this.protoType.WeakCreateBuilderForType();
IBuilderLite messageBuilder = this.extensionRegistry == null
? newBuilder.WeakMergeFrom(codedInputStream)
: newBuilder.WeakMergeFrom(codedInputStream, this.extensionRegistry);
IMessageLite decodedMessage = messageBuilder.WeakBuild();
if (decodedMessage != null)
{
output.Add(decodedMessage);
}
}
catch (Exception exception)
{
throw new CodecException(exception);
}
finally
{
inputStream?.Dispose();
}
}
private void BNetBufferAssembledCallback(byte[] buffer, Direction direction, string clientHash)
{
Dictionary <string, Color[]> colors = new Dictionary <string, Color[]>();
Color[][] trafficColors = new Color[][]
{ new Color[] { Color.LightCoral, Color.LightBlue },
new Color[] { Color.Tomato, Color.Blue },
new Color[] { Color.Red, Color.BlueViolet },
new Color[] { Color.PaleVioletRed, Color.CadetBlue } };
var stream = CodedInputStream.CreateInstance(buffer);
while (!stream.IsAtEnd)
{
try
{
var packet = new PacketIn(null, null);
if (packet.Header.ServiceId == 0xFE /*ServiceReply*/)
{
//ProcessReply(client, packet);
var callNode = RPCCallbacksIn[packet.Header.Token];
RPCCallbacksIn.Remove(packet.Header.Token);
callNode.ReceiveReply(packet, true);
}
else
{
var service = Service.GetByID(packet.Header.ServiceId);
if (service == null)
{
MooNetTree.Nodes.Add(String.Format("Service not found: {0}", service));
return;
}
var newNode = new MooNetCallNode(packet, stream);
MooNetTree.Nodes.Add(newNode);
RPCCallbacksIn.Add(packet.Header.Token, newNode);
}
}
catch (Exception e)
{
var newNode = new TreeNode(String.Format("Error parsing {0}", e.Message));
MooNetTree.Nodes.Add(newNode);
}
}
}
public Header(byte[] data)
{
this.Data = data;
var stream = CodedInputStream.CreateInstance(data);
this.ServiceID = stream.ReadRawByte();
this.MethodID = stream.ReadRawVarint32();
this.RequestID = stream.ReadRawByte() | (stream.ReadRawByte() << 8);
if (ServiceID != 0xfe)
{
this.Unknown = stream.ReadRawVarint64();
}
this.PayloadLength = stream.ReadRawVarint32();
}
public void Run()
{
try
{
CodedInputStream stream = CodedInputStream.CreateInstance(this.stream);
while (!stream.IsAtEnd)
{
Handle(stream);
}
Console.WriteLine("GS: Disconnected!");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
var file = File.OpenRead(args[0]);
var reader = CodedInputStream.CreateInstance(file);
var expected_responses = new Dictionary <int, IMessage>();
while (!reader.IsAtEnd)
{
var service_id = reader.ReadRawByte();
var method_id = reader.ReadInt32() - 1;
var request_id = reader.ReadFixedUInt16();
if (service_id == 0xFE)
{
}
}
}
public static void Identify(IConnection connection, CodedInputStream stream)
{
var header = new BNetHeader(stream);
var payload = new byte[header.PayloadLength];
payload = stream.ReadRawBytes((int)header.PayloadLength);
var packet = new BNetPacket(header, payload);
var service = Service.GetByID(header.ServiceID);
if (service == null)
{
Logger.Error("No service exists with id: 0x{0}", header.ServiceID.ToString("X2"));
return;
}
//var method = service.DescriptorForType.Methods[(int)header.MethodID - 1];
//Logger.Warn("METHODID: {0}, from header: {1}", (uint)method.Options[bnet.protocol.Rpc.MethodId.Descriptor], header.MethodID);
var method = service.DescriptorForType.Methods.Single(m => (uint)m.Options[bnet.protocol.Rpc.MethodId.Descriptor] == header.MethodID);
var proto = service.GetRequestPrototype(method);
var builder = proto.WeakCreateBuilderForType();
try
{
var message = builder.WeakMergeFrom(CodedInputStream.CreateInstance(packet.Payload.ToArray())).WeakBuild();
lock (service) // lock the service so that it's in-context client does not get changed..
{
//Logger.Debug("service-call data:{0}", message.ToString());
((IServerService)service).Client = (IBNetClient)connection.Client;
service.CallMethod(method, null, message, (msg => SendResponse(connection, header.RequestID, msg)));
}
}
catch (NotImplementedException)
{
Logger.Debug("Unimplemented service method: {0} {1}", service.GetType().Name, method.Name);
}
catch (UninitializedMessageException e)
{
Logger.Debug("Failed to parse message: {0}", e.Message);
}
catch (Exception e)
{
Logger.DebugException(e, string.Empty);
}
}
public TMessage CallMethod <TMessage, TBuilder>(string method, IMessageLite request, IBuilderLite <TMessage, TBuilder> response)
where TMessage : IMessageLite <TMessage, TBuilder>
where TBuilder : IBuilderLite <TMessage, TBuilder>
{
Stream stream = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(stream);
output.WriteStringNoTag(method);
request.WriteTo(output);
output.Flush();
stream.Position = 0;
stream = _channel.Invoke(stream);
CodedInputStream input = CodedInputStream.CreateInstance(stream);
response.MergeFrom(input);
return(response.Build());
}
public static void OnDataReceive2(System.Object sender, DataEventArgs e)
{
print("buff length: " + e.Length + ", offset: " + e.Offset);
if (e.Length <= 0)
{
return;
}
Array.Copy(e.Data, 0, buffer.Data, buffer.Length, e.Length);
buffer.Length += e.Length;
CodedInputStream stream = CodedInputStream.CreateInstance(buffer.Data);
while (!stream.IsAtEnd)
{
int markReadIndex = (int)stream.Position;
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try {
byte[] body = stream.ReadRawBytes(varint32);
NamePacket response = NamePacket.ParseFrom(body);
print("Response: " + response.ToString() + ", count: " + (++count));
} catch (Exception exception) {
print(exception.Message);
}
}
else
{
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
