/// <summary> /// Pick up 16 bytes IV from the front of cipher text, use it together with <paramref name="key"> to AES parse the protobuf stream. /// </summary> /// <typeparam name="P">Your protobuf type here.</typeparam> public static P ProtoFromStream <P>(Stream stream, byte[] key) where P : IMessage <P>, new() { //iOS used to complain about Protobuf doing JIT without this, not sure about now. Environment.SetEnvironmentVariable("MONO_REFLECTION_SERIALIZER", "yes"); //This scheme we paste initialization vector as a header of the save file, so we just yank it back for use... byte[] ivRead = new byte[16]; stream.Read(ivRead, 0, 16); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); aes.Key = key; aes.IV = ivRead; //Debug.Log($"Using {string.Join(",", des.Key.Select(x => x))} {string.Join(",", des.IV.Select(x => x))}"); P loadedData = new P(); using (var cryptoStream = new CryptoStream(stream, aes.CreateDecryptor(), CryptoStreamMode.Read)) { using (Google.Protobuf.CodedInputStream cis = new Google.Protobuf.CodedInputStream(cryptoStream)) { loadedData = new MessageParser <P>(() => new P()).ParseFrom(cis); return(loadedData); } } }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() /// </summary> private static void AssertReadVarint(byte[] data, ulong value) { CodedInputStream input = new CodedInputStream(data); Assert.AreEqual((uint) value, input.ReadRawVarint32()); input = new CodedInputStream(data); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); // Try different block sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual((uint) value, input.ReadRawVarint32()); input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); } // Try reading directly from a MemoryStream. We want to verify that it // doesn't read past the end of the input, so write an extra byte - this // lets us test the position at the end. MemoryStream memoryStream = new MemoryStream(); memoryStream.Write(data, 0, data.Length); memoryStream.WriteByte(0); memoryStream.Position = 0; Assert.AreEqual((uint) value, CodedInputStream.ReadRawVarint32(memoryStream)); Assert.AreEqual(data.Length, memoryStream.Position); }
/// <summary> /// Merges data from the given byte array into an existing message. /// </summary> /// <param name="message">The message to merge the data into.</param> /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param> public static void MergeFrom(this IMessage message, byte[] data) { ProtoPreconditions.CheckNotNull(message, "message"); ProtoPreconditions.CheckNotNull(data, "data"); CodedInputStream input = new CodedInputStream(data); message.MergeFrom(input); input.CheckReadEndOfStreamTag(); }
/// <summary> /// Merges data from the given stream into an existing message. /// </summary> /// <param name="message">The message to merge the data into.</param> /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param> public static void MergeFrom(this IMessage message, Stream input) { ProtoPreconditions.CheckNotNull(message, "message"); ProtoPreconditions.CheckNotNull(input, "input"); CodedInputStream codedInput = new CodedInputStream(input); message.MergeFrom(codedInput); codedInput.CheckReadEndOfStreamTag(); }
/// <summary> /// Merges data from the given stream into an existing message. /// </summary> /// <param name="message">The message to merge the data into.</param> /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param> public static void MergeFrom(this IMessage message, Stream input) { Preconditions.CheckNotNull(message, "message"); Preconditions.CheckNotNull(input, "input"); CodedInputStream codedInput = new CodedInputStream(input); message.MergeFrom(codedInput); codedInput.CheckLastTagWas(0); }
public void ByteStringToValueType () { // From Google's protobuf documentation, varint encoding example: // 300 = 1010 1100 0000 0010 = 0xAC 0x02 byte[] bytes = { 0xAC, 0x02 }; var codedStream = new CodedInputStream (bytes); uint value = codedStream.ReadUInt32 (); Assert.AreEqual (300, value); }
public void MergeFrom(pb.CodedInputStream input) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE input.ReadRawMessage(this); #else uint tag; while ((tag = input.ReadTag()) != 0) { switch (tag) { default: _unknownFields = pb.UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { ClientId = input.ReadString(); break; } case 18: { MessageId = input.ReadString(); break; } case 24: { Type = (MessageType)input.ReadEnum(); break; } case 34: { if (time_ == null) { Time = new global.Google.Protobuf.WellKnownTypes.Timestamp(); } input.ReadMessage(Time); break; } case 40: { Status = (MessageStatus)input.ReadEnum(); break; } case 50: { Payload = input.ReadBytes(); break; } case 56: { Response = (ResponseType)input.ReadEnum(); break; } } } #endif }
private void MergeAllFrom(List <Type> protoClasses, string pathToProtos1, string pathToProtos2) { if (pathToProtos1 == "" || pathToProtos2 == "") { MessageBox.Show("Please select data protos files first"); } this.protoInstances1 = new List <object>(); this.protoInstances2 = new List <object>(); foreach (Type protoClass in protoClasses) { ConstructorInfo[] constructors = protoClass.GetConstructors(); if (constructors.Count <ConstructorInfo>() > 0) { try { var protoInstance1 = constructors[0].Invoke(null); var protoInstance2 = constructors[0].Invoke(null); IEnumerable <MethodInfo> protoMethods1 = (IEnumerable <MethodInfo>)protoInstance1.GetType().GetMethods(); IEnumerable <MethodInfo> protoMethods2 = (IEnumerable <MethodInfo>)protoInstance1.GetType().GetMethods(); var mergeFromList1 = protoMethods1.Where(m => m.Name == "MergeFrom").ToList(); var mergeFromList2 = protoMethods1.Where(m => m.Name == "MergeFrom").ToList(); var mergeFrom1 = mergeFromList1[1]; var mergeFrom2 = mergeFromList2[1]; byte[] protosBytes1 = File.ReadAllBytes(pathToProtos1); var googleCode1 = new Google.Protobuf.CodedInputStream(protosBytes1); byte[] protosBytes2 = File.ReadAllBytes(pathToProtos2); var googleCode2 = new Google.Protobuf.CodedInputStream(protosBytes2); mergeFrom1.Invoke(protoInstance1, new object[] { googleCode1 }); mergeFrom2.Invoke(protoInstance2, new object[] { googleCode2 }); protoInstances1.Add(protoInstance1); protoInstances2.Add(protoInstance2); } catch (System.Reflection.TargetInvocationException i) { } } } }
/// <summary> /// Decode a value of the given type. /// Should not be called directly. This interface is used by service client stubs. /// </summary> public static object Decode(ByteString value, Type type, Connection client) { var stream = new CodedInputStream (value.ToByteArray ()); if (type == typeof(double)) return stream.ReadDouble (); else if (type == typeof(float)) return stream.ReadFloat (); else if (type == typeof(int)) return stream.ReadInt32 (); else if (type == typeof(long)) return stream.ReadInt64 (); else if (type == typeof(uint)) return stream.ReadUInt32 (); else if (type == typeof(ulong)) return stream.ReadUInt64 (); else if (type == typeof(bool)) return stream.ReadBool (); else if (type == typeof(string)) return stream.ReadString (); else if (type == typeof(byte[])) return stream.ReadBytes ().ToByteArray (); else if (type.IsEnum) return stream.ReadInt32 (); else if (typeof(RemoteObject).IsAssignableFrom (type)) { if (client == null) throw new ArgumentException ("Client not passed when decoding remote object"); var id = stream.ReadUInt64 (); if (id == 0) return null; return (RemoteObject)Activator.CreateInstance (type, client, id); } else if (typeof(IMessage).IsAssignableFrom (type)) { IMessage message = (IMessage)Activator.CreateInstance (type); message.MergeFrom (stream); return message; } else if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof(IList<>)) return DecodeList (value, type, client); else if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof(IDictionary<,>)) return DecodeDictionary (value, type, client); else if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof(ISet<>)) return DecodeSet (value, type, client); else if (type.IsGenericType && (type.GetGenericTypeDefinition () == typeof(Tuple<>) || type.GetGenericTypeDefinition () == typeof(Tuple<,>) || type.GetGenericTypeDefinition () == typeof(Tuple<,,>) || type.GetGenericTypeDefinition () == typeof(Tuple<,,,>) || type.GetGenericTypeDefinition () == typeof(Tuple<,,,,>) || type.GetGenericTypeDefinition () == typeof(Tuple<,,,,,>))) return DecodeTuple (value, type, client); // TODO: ugly handing of tuple types throw new ArgumentException (type + " is not a serializable type"); }
private bool MergeFrom(Type protoClass, string pathToProtos1, string pathToProtos2) { if (pathToProtos1 == "" || pathToProtos2 == "") { return(false); } ConstructorInfo[] constructors = protoClass.GetConstructors(); if (constructors.Count <ConstructorInfo>() > 0) { try { var protoInstance1 = constructors[0].Invoke(null); var protoInstance2 = constructors[0].Invoke(null); IEnumerable <MethodInfo> protoMethods1 = (IEnumerable <MethodInfo>)protoInstance1.GetType().GetMethods(); IEnumerable <MethodInfo> protoMethods2 = (IEnumerable <MethodInfo>)protoInstance1.GetType().GetMethods(); var mergeFromList1 = protoMethods1.Where(m => m.Name == "MergeFrom").ToList(); var mergeFromList2 = protoMethods1.Where(m => m.Name == "MergeFrom").ToList(); var mergeFrom1 = mergeFromList1[1]; var mergeFrom2 = mergeFromList2[1]; byte[] protosBytes1 = File.ReadAllBytes(pathToProtos1); var googleCode1 = new Google.Protobuf.CodedInputStream(protosBytes1); byte[] protosBytes2 = File.ReadAllBytes(pathToProtos2); var googleCode2 = new Google.Protobuf.CodedInputStream(protosBytes2); mergeFrom1.Invoke(protoInstance1, new object[] { googleCode1 }); mergeFrom2.Invoke(protoInstance2, new object[] { googleCode2 }); this.proto1 = protoInstance1; this.proto2 = protoInstance2; return(true); } catch (System.Reflection.TargetInvocationException i) { return(false); } } return(false); }
protected override int Read (ref Request request, byte[] data, int offset, int length) { try { var codedStream = new CodedInputStream (data, offset, length); // Get the protobuf message size int size = (int)codedStream.ReadUInt32 (); int totalSize = (int)codedStream.Position + size; // Check if enough data is available, if not then delay the decoding if (length < totalSize) return 0; // Decode the request request = Schema.KRPC.Request.Parser.ParseFrom (codedStream).ToMessage (); return totalSize; } catch (InvalidProtocolBufferException e) { throw new MalformedRequestException (e.Message); } }
private static PlayerData PlayerDataFromStream(Stream stream) { Environment.SetEnvironmentVariable("MONO_REFLECTION_SERIALIZER", "yes"); //So that iOS don't complain about protobuf's JITing //Try to get the IV.. byte[] ivRead = new byte[8]; stream.Read(ivRead, 0, 8); DESCryptoServiceProvider des = new DESCryptoServiceProvider(); des.Key = Key; des.IV = ivRead; PlayerData loadedData = new PlayerData(); using (var cryptoStream = new CryptoStream(stream, des.CreateDecryptor(), CryptoStreamMode.Read)) { using (Google.Protobuf.CodedInputStream cis = new Google.Protobuf.CodedInputStream(cryptoStream)) { loadedData = PlayerData.Parser.ParseFrom(cis); return(loadedData); } } }
internal uint <ForUInt32> b__7_0(CodedInputStream input) { return(input.ReadUInt32()); }
public void TestCodedInputOutputPosition() { byte[] content = new byte[110]; for (int i = 0; i < content.Length; i++) content[i] = (byte)i; byte[] child = new byte[120]; { MemoryStream ms = new MemoryStream(child); CodedOutputStream cout = new CodedOutputStream(ms, 20); // Field 11: numeric value: 500 cout.WriteTag(11, WireFormat.WireType.Varint); Assert.AreEqual(1, cout.Position); cout.WriteInt32(500); Assert.AreEqual(3, cout.Position); //Field 12: length delimited 120 bytes cout.WriteTag(12, WireFormat.WireType.LengthDelimited); Assert.AreEqual(4, cout.Position); cout.WriteBytes(ByteString.CopyFrom(content)); Assert.AreEqual(115, cout.Position); // Field 13: fixed numeric value: 501 cout.WriteTag(13, WireFormat.WireType.Fixed32); Assert.AreEqual(116, cout.Position); cout.WriteSFixed32(501); Assert.AreEqual(120, cout.Position); cout.Flush(); } byte[] bytes = new byte[130]; { CodedOutputStream cout = new CodedOutputStream(bytes); // Field 1: numeric value: 500 cout.WriteTag(1, WireFormat.WireType.Varint); Assert.AreEqual(1, cout.Position); cout.WriteInt32(500); Assert.AreEqual(3, cout.Position); //Field 2: length delimited 120 bytes cout.WriteTag(2, WireFormat.WireType.LengthDelimited); Assert.AreEqual(4, cout.Position); cout.WriteBytes(ByteString.CopyFrom(child)); Assert.AreEqual(125, cout.Position); // Field 3: fixed numeric value: 500 cout.WriteTag(3, WireFormat.WireType.Fixed32); Assert.AreEqual(126, cout.Position); cout.WriteSFixed32(501); Assert.AreEqual(130, cout.Position); cout.Flush(); } // Now test Input stream: { CodedInputStream cin = new CodedInputStream(new MemoryStream(bytes), new byte[50], 0, 0); Assert.AreEqual(0, cin.Position); // Field 1: uint tag = cin.ReadTag(); Assert.AreEqual(1, tag >> 3); Assert.AreEqual(1, cin.Position); Assert.AreEqual(500, cin.ReadInt32()); Assert.AreEqual(3, cin.Position); //Field 2: tag = cin.ReadTag(); Assert.AreEqual(2, tag >> 3); Assert.AreEqual(4, cin.Position); int childlen = cin.ReadLength(); Assert.AreEqual(120, childlen); Assert.AreEqual(5, cin.Position); int oldlimit = cin.PushLimit((int)childlen); Assert.AreEqual(5, cin.Position); // Now we are reading child message { // Field 11: numeric value: 500 tag = cin.ReadTag(); Assert.AreEqual(11, tag >> 3); Assert.AreEqual(6, cin.Position); Assert.AreEqual(500, cin.ReadInt32()); Assert.AreEqual(8, cin.Position); //Field 12: length delimited 120 bytes tag = cin.ReadTag(); Assert.AreEqual(12, tag >> 3); Assert.AreEqual(9, cin.Position); ByteString bstr = cin.ReadBytes(); Assert.AreEqual(110, bstr.Length); Assert.AreEqual((byte) 109, bstr[109]); Assert.AreEqual(120, cin.Position); // Field 13: fixed numeric value: 501 tag = cin.ReadTag(); Assert.AreEqual(13, tag >> 3); // ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit Assert.AreEqual(121, cin.Position); Assert.AreEqual(501, cin.ReadSFixed32()); Assert.AreEqual(125, cin.Position); Assert.IsTrue(cin.IsAtEnd); } cin.PopLimit(oldlimit); Assert.AreEqual(125, cin.Position); // Field 3: fixed numeric value: 501 tag = cin.ReadTag(); Assert.AreEqual(3, tag >> 3); Assert.AreEqual(126, cin.Position); Assert.AreEqual(501, cin.ReadSFixed32()); Assert.AreEqual(130, cin.Position); Assert.IsTrue(cin.IsAtEnd); } }
public override void ReadValue(CodedInputStream stream) { }
internal float <ForFloat> b__13_0(CodedInputStream input) { return(input.ReadFloat()); }
static object DecodeSet (CodedInputStream stream, Type type, IConnection client) { var encodedSet = KRPC.Schema.KRPC.Set.Parser.ParseFrom (stream); var set = (IEnumerable)(typeof(HashSet<>) .MakeGenericType (type.GetGenericArguments ().Single ()) .GetConstructor (Type.EmptyTypes) .Invoke (null)); MethodInfo methodInfo = type.GetMethod ("Add"); foreach (var item in encodedSet.Items) { var decodedItem = Decode (item, type.GetGenericArguments ().Single (), client); methodInfo.Invoke (set, new [] { decodedItem }); } return set; }
internal int <ForSInt32> b__4_0(CodedInputStream input) { return(input.ReadSInt32()); }
static object DecodeMessage (CodedInputStream stream, Type type) { if (type == typeof(Request)) { var message = new Schema.KRPC.Request (); message.MergeFrom (stream); return message.ToMessage (); } throw new ArgumentException ("Cannot decode protocol buffer messages of type " + type); }
internal uint <ForFixed32> b__5_0(CodedInputStream input) { return(input.ReadFixed32()); }
internal long <ForSFixed64> b__11_0(CodedInputStream input) { return(input.ReadSFixed64()); }
public void MergeFrom(CodedInputStream input) { Invoke(0, input); }
public void TestCodedInputOutputPosition() { byte[] content = new byte[110]; for (int i = 0; i < content.Length; i++) { content[i] = (byte)i; } byte[] child = new byte[120]; { MemoryStream ms = new MemoryStream(child); CodedOutputStream cout = new CodedOutputStream(ms, 20); // Field 11: numeric value: 500 cout.WriteTag(11, WireFormat.WireType.Varint); Assert.AreEqual(1, cout.Position); cout.WriteInt32(500); Assert.AreEqual(3, cout.Position); //Field 12: length delimited 120 bytes cout.WriteTag(12, WireFormat.WireType.LengthDelimited); Assert.AreEqual(4, cout.Position); cout.WriteBytes(ByteString.CopyFrom(content)); Assert.AreEqual(115, cout.Position); // Field 13: fixed numeric value: 501 cout.WriteTag(13, WireFormat.WireType.Fixed32); Assert.AreEqual(116, cout.Position); cout.WriteSFixed32(501); Assert.AreEqual(120, cout.Position); cout.Flush(); } byte[] bytes = new byte[130]; { CodedOutputStream cout = new CodedOutputStream(bytes); // Field 1: numeric value: 500 cout.WriteTag(1, WireFormat.WireType.Varint); Assert.AreEqual(1, cout.Position); cout.WriteInt32(500); Assert.AreEqual(3, cout.Position); //Field 2: length delimited 120 bytes cout.WriteTag(2, WireFormat.WireType.LengthDelimited); Assert.AreEqual(4, cout.Position); cout.WriteBytes(ByteString.CopyFrom(child)); Assert.AreEqual(125, cout.Position); // Field 3: fixed numeric value: 500 cout.WriteTag(3, WireFormat.WireType.Fixed32); Assert.AreEqual(126, cout.Position); cout.WriteSFixed32(501); Assert.AreEqual(130, cout.Position); cout.Flush(); } // Now test Input stream: { CodedInputStream cin = new CodedInputStream(new MemoryStream(bytes), new byte[50], 0, 0, false); Assert.AreEqual(0, cin.Position); // Field 1: uint tag = cin.ReadTag(); Assert.AreEqual(1, tag >> 3); Assert.AreEqual(1, cin.Position); Assert.AreEqual(500, cin.ReadInt32()); Assert.AreEqual(3, cin.Position); //Field 2: tag = cin.ReadTag(); Assert.AreEqual(2, tag >> 3); Assert.AreEqual(4, cin.Position); int childlen = cin.ReadLength(); Assert.AreEqual(120, childlen); Assert.AreEqual(5, cin.Position); int oldlimit = cin.PushLimit((int)childlen); Assert.AreEqual(5, cin.Position); // Now we are reading child message { // Field 11: numeric value: 500 tag = cin.ReadTag(); Assert.AreEqual(11, tag >> 3); Assert.AreEqual(6, cin.Position); Assert.AreEqual(500, cin.ReadInt32()); Assert.AreEqual(8, cin.Position); //Field 12: length delimited 120 bytes tag = cin.ReadTag(); Assert.AreEqual(12, tag >> 3); Assert.AreEqual(9, cin.Position); ByteString bstr = cin.ReadBytes(); Assert.AreEqual(110, bstr.Length); Assert.AreEqual((byte)109, bstr[109]); Assert.AreEqual(120, cin.Position); // Field 13: fixed numeric value: 501 tag = cin.ReadTag(); Assert.AreEqual(13, tag >> 3); // ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit Assert.AreEqual(121, cin.Position); Assert.AreEqual(501, cin.ReadSFixed32()); Assert.AreEqual(125, cin.Position); Assert.IsTrue(cin.IsAtEnd); } cin.PopLimit(oldlimit); Assert.AreEqual(125, cin.Position); // Field 3: fixed numeric value: 501 tag = cin.ReadTag(); Assert.AreEqual(3, tag >> 3); Assert.AreEqual(126, cin.Position); Assert.AreEqual(501, cin.ReadSFixed32()); Assert.AreEqual(130, cin.Position); Assert.IsTrue(cin.IsAtEnd); } }
internal bool ContainsInputField(CodedInputStream stream, Type target, out Extension extension) { return(extensions.TryGetValue(new ObjectIntPair <Type>(target, WireFormat.GetTagFieldNumber(stream.LastTag)), out extension)); }
internal static T Read <T>(CodedInputStream input, FieldCodec <T> codec) { int byteLimit = input.ReadLength(); T result; while (true) { IL_FA: uint arg_C8_0 = 1476935752u; while (true) { uint num; switch ((num = (arg_C8_0 ^ 2018772964u)) % 9u) { case 0u: input.SkipLastField(); arg_C8_0 = 1768391466u; continue; case 1u: { uint num2; arg_C8_0 = (((num2 = input.ReadTag()) == 0u) ? 789788880u : 1000495088u); continue; } case 3u: arg_C8_0 = (num * 422428889u ^ 15908708u); continue; case 4u: result = codec.Read(input); arg_C8_0 = (num * 2015424451u ^ 1456283564u); continue; case 5u: { uint num2; arg_C8_0 = ((num2 == codec.Tag) ? 627669222u : 345821031u); continue; } case 6u: { input.CheckReadEndOfStreamTag(); int oldLimit; input.PopLimit(oldLimit); arg_C8_0 = (num * 1368242210u ^ 1133084529u); continue; } case 7u: { int oldLimit = input.PushLimit(byteLimit); result = codec.DefaultValue; arg_C8_0 = (num * 2466023856u ^ 3651674u); continue; } case 8u: goto IL_FA; } return(result); } } return(result); }
internal double <ForDouble> b__14_0(CodedInputStream input) { return(input.ReadDouble()); }
public void TestSlowPathAvoidance() { using (var ms = new MemoryStream()) { CodedOutputStream output = new CodedOutputStream(ms); output.WriteTag(1, WireFormat.WireType.LengthDelimited); output.WriteBytes(ByteString.CopyFrom(new byte[100])); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteBytes(ByteString.CopyFrom(new byte[100])); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms, new byte[ms.Length / 2], 0, 0); uint tag = input.ReadTag(); Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag)); Assert.AreEqual(100, input.ReadBytes().Length); tag = input.ReadTag(); Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag)); Assert.AreEqual(100, input.ReadBytes().Length); } }
internal bool <ForBool> b__2_0(CodedInputStream input) { return(input.ReadBool()); }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and /// expects them to fail with an InvalidProtocolBufferException whose /// description matches the given one. /// </summary> private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { CodedInputStream input = new CodedInputStream(data); var exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint32()); Assert.AreEqual(expected.Message, exception.Message); input = new CodedInputStream(data); exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint64()); Assert.AreEqual(expected.Message, exception.Message); // Make sure we get the same error when reading directly from a Stream. exception = Assert.Throws<InvalidProtocolBufferException>(() => CodedInputStream.ReadRawVarint32(new MemoryStream(data))); Assert.AreEqual(expected.Message, exception.Message); }
internal ulong <ForFixed64> b__10_0(CodedInputStream input) { return(input.ReadFixed64()); }
public void ResetSizeCounter() { CodedInputStream input = new CodedInputStream( new SmallBlockInputStream(new byte[256], 8)); input.SetSizeLimit(16); input.ReadRawBytes(16); Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawByte()); input.ResetSizeCounter(); input.ReadRawByte(); // No exception thrown. Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawBytes(16)); }
static object DecodeList (CodedInputStream stream, Type type, IConnection client) { var encodedList = KRPC.Schema.KRPC.List.Parser.ParseFrom (stream); var list = (IList)(typeof(List<>) .MakeGenericType (type.GetGenericArguments ().Single ()) .GetConstructor (Type.EmptyTypes) .Invoke (null)); foreach (var item in encodedList.Items) list.Add (Decode (item, type.GetGenericArguments ().Single (), client)); return list; }
public void MergeFrom(pb.CodedInputStream input) { throw new System.NotImplementedException(); }
internal ulong <ForUInt64> b__12_0(CodedInputStream input) { return(input.ReadUInt64()); }
internal ByteString <ForBytes> b__1_0(CodedInputStream input) { return(input.ReadBytes()); }
internal long <ForSInt64> b__9_0(CodedInputStream input) { return(input.ReadSInt64()); }
internal string <ForString> b__0_0(CodedInputStream input) { return(input.ReadString()); }
public void Dispose_DisposesUnderlyingStream() { var memoryStream = new MemoryStream(); Assert.IsTrue(memoryStream.CanRead); using (var cis = new CodedInputStream(memoryStream)) { } Assert.IsFalse(memoryStream.CanRead); // Disposed }
public void Dispose_WithLeaveOpen() { var memoryStream = new MemoryStream(); Assert.IsTrue(memoryStream.CanRead); using (var cis = new CodedInputStream(memoryStream, true)) { } Assert.IsTrue(memoryStream.CanRead); // We left the stream open }
public void ReadInvalidUtf8() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(1); output.WriteRawBytes(new byte[] {0x80}); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); string text = input.ReadString(); Assert.AreEqual('\ufffd', text[0]); }
static object DecodeDictionary (CodedInputStream stream, Type type, IConnection client) { var encodedDictionary = KRPC.Schema.KRPC.Dictionary.Parser.ParseFrom (stream); var dictionary = (IDictionary)(typeof(Dictionary<,>) .MakeGenericType (type.GetGenericArguments () [0], type.GetGenericArguments () [1]) .GetConstructor (Type.EmptyTypes) .Invoke (null)); foreach (var entry in encodedDictionary.Entries) { var key = Decode (entry.Key, type.GetGenericArguments () [0], client); var value = Decode (entry.Value, type.GetGenericArguments () [1], client); dictionary [key] = value; } return dictionary; }
public void RecursionLimitAppliedWhileSkippingGroup() { var stream = new MemoryStream(); var output = new CodedOutputStream(stream); for (int i = 0; i < CodedInputStream.DefaultRecursionLimit + 1; i++) { output.WriteTag(1, WireFormat.WireType.StartGroup); } for (int i = 0; i < CodedInputStream.DefaultRecursionLimit + 1; i++) { output.WriteTag(1, WireFormat.WireType.EndGroup); } output.Flush(); stream.Position = 0; // Now act like a generated client var input = new CodedInputStream(stream); Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.StartGroup), input.ReadTag()); Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); }
static object DecodeTuple (CodedInputStream stream, Type type, IConnection client) { var encodedTuple = KRPC.Schema.KRPC.Tuple.Parser.ParseFrom (stream); var valueTypes = type.GetGenericArguments ().ToArray (); var genericType = Type.GetType ("System.Tuple`" + valueTypes.Length.ToString ()); var values = new object[valueTypes.Length]; for (int i = 0; i < valueTypes.Length; i++) { var item = encodedTuple.Items [i]; values [i] = Decode (item, valueTypes [i], client); } var tuple = genericType .MakeGenericType (valueTypes) .GetConstructor (valueTypes) .Invoke (values); return tuple; }
public void SkipGroup() { // Create an output stream with a group in: // Field 1: string "field 1" // Field 2: group containing: // Field 1: fixed int32 value 100 // Field 2: string "ignore me" // Field 3: nested group containing // Field 1: fixed int64 value 1000 // Field 3: string "field 3" var stream = new MemoryStream(); var output = new CodedOutputStream(stream); output.WriteTag(1, WireFormat.WireType.LengthDelimited); output.WriteString("field 1"); // The outer group... output.WriteTag(2, WireFormat.WireType.StartGroup); output.WriteTag(1, WireFormat.WireType.Fixed32); output.WriteFixed32(100); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteString("ignore me"); // The nested group... output.WriteTag(3, WireFormat.WireType.StartGroup); output.WriteTag(1, WireFormat.WireType.Fixed64); output.WriteFixed64(1000); // Note: Not sure the field number is relevant for end group... output.WriteTag(3, WireFormat.WireType.EndGroup); // End the outer group output.WriteTag(2, WireFormat.WireType.EndGroup); output.WriteTag(3, WireFormat.WireType.LengthDelimited); output.WriteString("field 3"); output.Flush(); stream.Position = 0; // Now act like a generated client var input = new CodedInputStream(stream); Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited), input.ReadTag()); Assert.AreEqual("field 1", input.ReadString()); Assert.AreEqual(WireFormat.MakeTag(2, WireFormat.WireType.StartGroup), input.ReadTag()); input.SkipLastField(); // Should consume the whole group, including the nested one. Assert.AreEqual(WireFormat.MakeTag(3, WireFormat.WireType.LengthDelimited), input.ReadTag()); Assert.AreEqual("field 3", input.ReadString()); }
internal void Main() { client = new TcpClient (); client.Connect (address, port); stream = client.GetStream (); stream.Write (Encoder.streamHelloMessage, 0, Encoder.streamHelloMessage.Length); stream.Write (clientIdentifier, 0, clientIdentifier.Length); var recvOkMessage = new byte [Encoder.okMessage.Length]; stream.Read (recvOkMessage, 0, Encoder.okMessage.Length); if (recvOkMessage.Equals (Encoder.okMessage)) throw new Exception ("Invalid hello message received from stream server. " + "Got " + Encoder.ToHexString (recvOkMessage)); this.codedStream = new CodedInputStream (stream); try { while (true) { var message = new StreamMessage (); codedStream.ReadMessage (message); foreach (var response in message.Responses) manager.Update (response.Id, response.Response); } } catch (IOException) { // Exit when the connection closes } }
public void Tag0Throws() { var input = new CodedInputStream(new byte[] { 0 }); Assert.Throws<InvalidProtocolBufferException>(() => input.ReadTag()); }
/// <summary> /// Tries to merge a field from the coded input, returning true if the field was merged. /// If the set is null or the field was not otherwise merged, this returns false. /// </summary> public static bool TryMergeFieldFrom <TTarget>(ref ExtensionSet <TTarget> set, CodedInputStream stream) where TTarget : IExtendableMessage <TTarget> { ParseContext.Initialize(stream, out ParseContext ctx); try { return(TryMergeFieldFrom <TTarget>(ref set, ref ctx)); } finally { ctx.CopyStateTo(stream); } }
internal int <ForSFixed32> b__6_0(CodedInputStream input) { return(input.ReadSFixed32()); }
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes()); }
public void MergeFrom(CodedInputStream input) { hasValue = true; codec.ValueMerger(input, ref field); }
public void RogueEndGroupTag() { // If we have an end-group tag without a leading start-group tag, generated // code will just call SkipLastField... so that should fail. var stream = new MemoryStream(); var output = new CodedOutputStream(stream); output.WriteTag(1, WireFormat.WireType.EndGroup); output.Flush(); stream.Position = 0; var input = new CodedInputStream(stream); Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.EndGroup), input.ReadTag()); Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); }
public void MergeFrom(CodedInputStream input) { field.AddEntriesFrom(input, codec); }
public void SkipGroup_WrongEndGroupTag() { // Create an output stream with: // Field 1: string "field 1" // Start group 2 // Field 3: fixed int32 // End group 4 (should give an error) var stream = new MemoryStream(); var output = new CodedOutputStream(stream); output.WriteTag(1, WireFormat.WireType.LengthDelimited); output.WriteString("field 1"); // The outer group... output.WriteTag(2, WireFormat.WireType.StartGroup); output.WriteTag(3, WireFormat.WireType.Fixed32); output.WriteFixed32(100); output.WriteTag(4, WireFormat.WireType.EndGroup); output.Flush(); stream.Position = 0; // Now act like a generated client var input = new CodedInputStream(stream); Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited), input.ReadTag()); Assert.AreEqual("field 1", input.ReadString()); Assert.AreEqual(WireFormat.MakeTag(2, WireFormat.WireType.StartGroup), input.ReadTag()); Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); }
public void ReadTag_ZeroFieldRejected(byte tag) { CodedInputStream cis = new CodedInputStream(new byte[] { tag }); Assert.Throws <InvalidProtocolBufferException>(() => cis.ReadTag()); }
public void TestNegativeEnum() { byte[] bytes = { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 }; CodedInputStream input = new CodedInputStream(bytes); Assert.AreEqual((int)SampleEnum.NegativeValue, input.ReadEnum()); Assert.IsTrue(input.IsAtEnd); }
public void Dispose_FromByteArray() { var stream = new CodedInputStream(new byte[10]); stream.Dispose(); }
/// <summary> /// Parses the given bytes using ReadRawLittleEndian64() and checks /// that the result matches the given value. /// </summary> private static void AssertReadLittleEndian64(byte[] data, ulong value) { CodedInputStream input = new CodedInputStream(data); Assert.AreEqual(value, input.ReadRawLittleEndian64()); Assert.IsTrue(input.IsAtEnd); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { input = new CodedInputStream( new SmallBlockInputStream(data, blockSize)); Assert.AreEqual(value, input.ReadRawLittleEndian64()); Assert.IsTrue(input.IsAtEnd); } }
public static void Initialize(CodedInputStream codedInputStream, out SegmentedBufferHelper instance) { instance.totalLength = codedInputStream.InternalInputStream == null ? (int?)codedInputStream.InternalBuffer.Length : null; instance.readOnlySequenceEnumerator = default; instance.codedInputStream = codedInputStream; }
public void EndOfStreamReachedWhileSkippingGroup() { var stream = new MemoryStream(); var output = new CodedOutputStream(stream); output.WriteTag(1, WireFormat.WireType.StartGroup); output.WriteTag(2, WireFormat.WireType.StartGroup); output.WriteTag(2, WireFormat.WireType.EndGroup); output.Flush(); stream.Position = 0; // Now act like a generated client var input = new CodedInputStream(stream); input.ReadTag(); Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); }
public void Tag0Throws() { var input = new CodedInputStream(new byte[] { 0 }); Assert.Throws <InvalidProtocolBufferException>(() => input.ReadTag()); }