// 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; } } }