| #region Copyright notice and license | |
| // Protocol Buffers - Google's data interchange format | |
| // Copyright 2008 Google Inc. All rights reserved. | |
| // http://github.com/jskeet/dotnet-protobufs/ | |
| // Original C++/Java/Python code: | |
| // http://code.google.com/p/protobuf/ | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are | |
| // met: | |
| // | |
| // * Redistributions of source code must retain the above copyright | |
| // notice, this list of conditions and the following disclaimer. | |
| // * Redistributions in binary form must reproduce the above | |
| // copyright notice, this list of conditions and the following disclaimer | |
| // in the documentation and/or other materials provided with the | |
| // distribution. | |
| // * Neither the name of Google Inc. nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #endregion | |
| using System; | |
| using System.Collections.Generic; | |
| using System.IO; | |
| using System.Text; | |
| using Google.ProtocolBuffers.Descriptors; | |
| namespace Google.ProtocolBuffers | |
| { | |
| /// <summary> | |
| /// Readings and decodes protocol message fields. | |
| /// </summary> | |
| /// <remarks> | |
| /// This class contains two kinds of methods: methods that read specific | |
| /// protocol message constructs and field types (e.g. ReadTag and | |
| /// ReadInt32) and methods that read low-level values (e.g. | |
| /// ReadRawVarint32 and ReadRawBytes). If you are reading encoded protocol | |
| /// messages, you should use the former methods, but if you are reading some | |
| /// other format of your own design, use the latter. The names of the former | |
| /// methods are taken from the protocol buffer type names, not .NET types. | |
| /// (Hence ReadFloat instead of ReadSingle, and ReadBool instead of ReadBoolean.) | |
| /// | |
| /// TODO(jonskeet): Consider whether recursion and size limits shouldn't be readonly, | |
| /// set at construction time. | |
| /// </remarks> | |
| public sealed class CodedInputStream : ICodedInputStream | |
| { | |
| private readonly byte[] buffer; | |
| private int bufferSize; | |
| private int bufferSizeAfterLimit = 0; | |
| private int bufferPos = 0; | |
| private readonly Stream input; | |
| private uint lastTag = 0; | |
| private uint nextTag = 0; | |
| private bool hasNextTag = false; | |
| internal const int DefaultRecursionLimit = 64; | |
| internal const int DefaultSizeLimit = 64 << 20; // 64MB | |
| public const int BufferSize = 4096; | |
| /// <summary> | |
| /// The total number of bytes read before the current buffer. The | |
| /// total bytes read up to the current position can be computed as | |
| /// totalBytesRetired + bufferPos. | |
| /// </summary> | |
| private int totalBytesRetired = 0; | |
| /// <summary> | |
| /// The absolute position of the end of the current message. | |
| /// </summary> | |
| private int currentLimit = int.MaxValue; | |
| /// <summary> | |
| /// <see cref="SetRecursionLimit"/> | |
| /// </summary> | |
| private int recursionDepth = 0; | |
| private int recursionLimit = DefaultRecursionLimit; | |
| /// <summary> | |
| /// <see cref="SetSizeLimit"/> | |
| /// </summary> | |
| private int sizeLimit = DefaultSizeLimit; | |
| #region Construction | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given | |
| /// stream. | |
| /// </summary> | |
| public static CodedInputStream CreateInstance(Stream input) | |
| { | |
| return new CodedInputStream(input); | |
| } | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given | |
| /// stream and a pre-allocated memory buffer. | |
| /// </summary> | |
| public static CodedInputStream CreateInstance(Stream input, byte[] buffer) | |
| { | |
| return new CodedInputStream(input, buffer); | |
| } | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given | |
| /// byte array. | |
| /// </summary> | |
| public static CodedInputStream CreateInstance(byte[] buf) | |
| { | |
| return new CodedInputStream(buf, 0, buf.Length); | |
| } | |
| /// <summary> | |
| /// Creates a new CodedInputStream that reads from the given | |
| /// byte array slice. | |
| /// </summary> | |
| public static CodedInputStream CreateInstance(byte[] buf, int offset, int length) | |
| { | |
| return new CodedInputStream(buf, offset, length); | |
| } | |
| private CodedInputStream(byte[] buffer, int offset, int length) | |
| { | |
| this.buffer = buffer; | |
| this.bufferPos = offset; | |
| this.bufferSize = offset + length; | |
| this.input = null; | |
| } | |
| private CodedInputStream(Stream input) | |
| { | |
| this.buffer = new byte[BufferSize]; | |
| this.bufferSize = 0; | |
| this.input = input; | |
| } | |
| private CodedInputStream(Stream input, byte[] buffer) | |
| { | |
| this.buffer = buffer; | |
| this.bufferSize = 0; | |
| this.input = input; | |
| } | |
| #endregion | |
| /// <summary> | |
| /// Returns the current position in the input stream, or the position in the input buffer | |
| /// </summary> | |
| public long Position | |
| { | |
| get | |
| { | |
| if (input != null) | |
| { | |
| return input.Position - ((bufferSize + bufferSizeAfterLimit) - bufferPos); | |
| } | |
| return bufferPos; | |
| } | |
| } | |
| void ICodedInputStream.ReadMessageStart() { } | |
| void ICodedInputStream.ReadMessageEnd() { } | |
| #region Validation | |
| /// <summary> | |
| /// Verifies that the last call to ReadTag() returned the given tag value. | |
| /// This is used to verify that a nested group ended with the correct | |
| /// end tag. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException">The last | |
| /// tag read was not the one specified</exception> | |
| [CLSCompliant(false)] | |
| public void CheckLastTagWas(uint value) | |
| { | |
| if (lastTag != value) | |
| { | |
| throw InvalidProtocolBufferException.InvalidEndTag(); | |
| } | |
| } | |
| #endregion | |
| #region Reading of tags etc | |
| /// <summary> | |
| /// Attempt to peek at the next field tag. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool PeekNextTag(out uint fieldTag, out string fieldName) | |
| { | |
| if (hasNextTag) | |
| { | |
| fieldName = null; | |
| fieldTag = nextTag; | |
| return true; | |
| } | |
| uint savedLast = lastTag; | |
| hasNextTag = ReadTag(out nextTag, out fieldName); | |
| lastTag = savedLast; | |
| fieldTag = nextTag; | |
| return hasNextTag; | |
| } | |
| /// <summary> | |
| /// Attempt to read a field tag, returning false if we have reached the end | |
| /// of the input data. | |
| /// </summary> | |
| /// <param name="fieldTag">The 'tag' of the field (id * 8 + wire-format)</param> | |
| /// <param name="fieldName">Not Supported - For protobuffer streams, this parameter is always null</param> | |
| /// <returns>true if the next fieldTag was read</returns> | |
| [CLSCompliant(false)] | |
| public bool ReadTag(out uint fieldTag, out string fieldName) | |
| { | |
| fieldName = null; | |
| if (hasNextTag) | |
| { | |
| fieldTag = nextTag; | |
| lastTag = fieldTag; | |
| hasNextTag = false; | |
| return true; | |
| } | |
| if (IsAtEnd) | |
| { | |
| fieldTag = 0; | |
| lastTag = fieldTag; | |
| return false; | |
| } | |
| fieldTag = ReadRawVarint32(); | |
| lastTag = fieldTag; | |
| if (lastTag == 0) | |
| { | |
| // If we actually read zero, that's not a valid tag. | |
| throw InvalidProtocolBufferException.InvalidTag(); | |
| } | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a double field from the stream. | |
| /// </summary> | |
| public bool ReadDouble(ref double value) | |
| { | |
| value = FrameworkPortability.Int64ToDouble((long) ReadRawLittleEndian64()); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a float field from the stream. | |
| /// </summary> | |
| public bool ReadFloat(ref float value) | |
| { | |
| if (BitConverter.IsLittleEndian && 4 <= bufferSize - bufferPos) | |
| { | |
| value = BitConverter.ToSingle(buffer, bufferPos); | |
| bufferPos += 4; | |
| } | |
| else | |
| { | |
| byte[] rawBytes = ReadRawBytes(4); | |
| if (!BitConverter.IsLittleEndian) | |
| { | |
| ByteArray.Reverse(rawBytes); | |
| } | |
| value = BitConverter.ToSingle(rawBytes, 0); | |
| } | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a uint64 field from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool ReadUInt64(ref ulong value) | |
| { | |
| value = ReadRawVarint64(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read an int64 field from the stream. | |
| /// </summary> | |
| public bool ReadInt64(ref long value) | |
| { | |
| value = (long) ReadRawVarint64(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read an int32 field from the stream. | |
| /// </summary> | |
| public bool ReadInt32(ref int value) | |
| { | |
| value = (int) ReadRawVarint32(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a fixed64 field from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool ReadFixed64(ref ulong value) | |
| { | |
| value = ReadRawLittleEndian64(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a fixed32 field from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool ReadFixed32(ref uint value) | |
| { | |
| value = ReadRawLittleEndian32(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Read a bool field from the stream. | |
| /// </summary> | |
| public bool ReadBool(ref bool value) | |
| { | |
| value = ReadRawVarint32() != 0; | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads a string field from the stream. | |
| /// </summary> | |
| public bool ReadString(ref string value) | |
| { | |
| int size = (int) ReadRawVarint32(); | |
| // No need to read any data for an empty string. | |
| if (size == 0) | |
| { | |
| value = ""; | |
| return true; | |
| } | |
| if (size <= bufferSize - bufferPos) | |
| { | |
| // Fast path: We already have the bytes in a contiguous buffer, so | |
| // just copy directly from it. | |
| String result = Encoding.UTF8.GetString(buffer, bufferPos, size); | |
| bufferPos += size; | |
| value = result; | |
| return true; | |
| } | |
| // Slow path: Build a byte array first then copy it. | |
| value = Encoding.UTF8.GetString(ReadRawBytes(size), 0, size); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads a group field value from the stream. | |
| /// </summary> | |
| public void ReadGroup(int fieldNumber, IBuilderLite builder, | |
| ExtensionRegistry extensionRegistry) | |
| { | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| ++recursionDepth; | |
| builder.WeakMergeFrom(this, extensionRegistry); | |
| CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup)); | |
| --recursionDepth; | |
| } | |
| /// <summary> | |
| /// Reads a group field value from the stream and merges it into the given | |
| /// UnknownFieldSet. | |
| /// </summary> | |
| [Obsolete] | |
| public void ReadUnknownGroup(int fieldNumber, IBuilderLite builder) | |
| { | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| ++recursionDepth; | |
| builder.WeakMergeFrom(this); | |
| CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup)); | |
| --recursionDepth; | |
| } | |
| /// <summary> | |
| /// Reads an embedded message field value from the stream. | |
| /// </summary> | |
| public void ReadMessage(IBuilderLite builder, ExtensionRegistry extensionRegistry) | |
| { | |
| int length = (int) ReadRawVarint32(); | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| int oldLimit = PushLimit(length); | |
| ++recursionDepth; | |
| builder.WeakMergeFrom(this, extensionRegistry); | |
| CheckLastTagWas(0); | |
| --recursionDepth; | |
| PopLimit(oldLimit); | |
| } | |
| /// <summary> | |
| /// Reads a bytes field value from the stream. | |
| /// </summary> | |
| public bool ReadBytes(ref ByteString value) | |
| { | |
| int size = (int) ReadRawVarint32(); | |
| if (size <= bufferSize - bufferPos && size > 0) | |
| { | |
| // Fast path: We already have the bytes in a contiguous buffer, so | |
| // just copy directly from it. | |
| ByteString result = ByteString.CopyFrom(buffer, bufferPos, size); | |
| bufferPos += size; | |
| value = result; | |
| return true; | |
| } | |
| else | |
| { | |
| // Slow path: Build a byte array and attach it to a new ByteString. | |
| value = ByteString.AttachBytes(ReadRawBytes(size)); | |
| return true; | |
| } | |
| } | |
| /// <summary> | |
| /// Reads a uint32 field value from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool ReadUInt32(ref uint value) | |
| { | |
| value = ReadRawVarint32(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads an enum field value from the stream. The caller is responsible | |
| /// for converting the numeric value to an actual enum. | |
| /// </summary> | |
| public bool ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) | |
| { | |
| int rawValue = (int) ReadRawVarint32(); | |
| value = mapping.FindValueByNumber(rawValue); | |
| if (value != null) | |
| { | |
| unknown = null; | |
| return true; | |
| } | |
| unknown = rawValue; | |
| return false; | |
| } | |
| /// <summary> | |
| /// Reads an enum field value from the stream. If the enum is valid for type T, | |
| /// then the ref value is set and it returns true. Otherwise the unknown output | |
| /// value is set and this method returns false. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public bool ReadEnum<T>(ref T value, out object unknown) | |
| where T : struct, IComparable, IFormattable | |
| { | |
| int number = (int) ReadRawVarint32(); | |
| if (EnumParser<T>.TryConvert(number, ref value)) | |
| { | |
| unknown = null; | |
| return true; | |
| } | |
| unknown = number; | |
| return false; | |
| } | |
| /// <summary> | |
| /// Reads an sfixed32 field value from the stream. | |
| /// </summary> | |
| public bool ReadSFixed32(ref int value) | |
| { | |
| value = (int) ReadRawLittleEndian32(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads an sfixed64 field value from the stream. | |
| /// </summary> | |
| public bool ReadSFixed64(ref long value) | |
| { | |
| value = (long) ReadRawLittleEndian64(); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads an sint32 field value from the stream. | |
| /// </summary> | |
| public bool ReadSInt32(ref int value) | |
| { | |
| value = DecodeZigZag32(ReadRawVarint32()); | |
| return true; | |
| } | |
| /// <summary> | |
| /// Reads an sint64 field value from the stream. | |
| /// </summary> | |
| public bool ReadSInt64(ref long value) | |
| { | |
| value = DecodeZigZag64(ReadRawVarint64()); | |
| return true; | |
| } | |
| private bool BeginArray(uint fieldTag, out bool isPacked, out int oldLimit) | |
| { | |
| isPacked = WireFormat.GetTagWireType(fieldTag) == WireFormat.WireType.LengthDelimited; | |
| if (isPacked) | |
| { | |
| int length = (int) (ReadRawVarint32() & int.MaxValue); | |
| if (length > 0) | |
| { | |
| oldLimit = PushLimit(length); | |
| return true; | |
| } | |
| oldLimit = -1; | |
| return false; //packed but empty | |
| } | |
| oldLimit = -1; | |
| return true; | |
| } | |
| /// <summary> | |
| /// Returns true if the next tag is also part of the same unpacked array. | |
| /// </summary> | |
| private bool ContinueArray(uint currentTag) | |
| { | |
| string ignore; | |
| uint next; | |
| if (PeekNextTag(out next, out ignore)) | |
| { | |
| if (next == currentTag) | |
| { | |
| hasNextTag = false; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /// <summary> | |
| /// Returns true if the next tag is also part of the same array, which may or may not be packed. | |
| /// </summary> | |
| private bool ContinueArray(uint currentTag, bool packed, int oldLimit) | |
| { | |
| if (packed) | |
| { | |
| if (ReachedLimit) | |
| { | |
| PopLimit(oldLimit); | |
| return false; | |
| } | |
| return true; | |
| } | |
| string ignore; | |
| uint next; | |
| if (PeekNextTag(out next, out ignore)) | |
| { | |
| if (next == currentTag) | |
| { | |
| hasNextTag = false; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadPrimitiveArray(FieldType fieldType, uint fieldTag, string fieldName, ICollection<object> list) | |
| { | |
| WireFormat.WireType normal = WireFormat.GetWireType(fieldType); | |
| WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag); | |
| // 2.3 allows packed form even if the field is not declared packed. | |
| if (normal != wformat && wformat == WireFormat.WireType.LengthDelimited) | |
| { | |
| int length = (int) (ReadRawVarint32() & int.MaxValue); | |
| int limit = PushLimit(length); | |
| while (!ReachedLimit) | |
| { | |
| Object value = null; | |
| if (ReadPrimitiveField(fieldType, ref value)) | |
| { | |
| list.Add(value); | |
| } | |
| } | |
| PopLimit(limit); | |
| } | |
| else | |
| { | |
| Object value = null; | |
| do | |
| { | |
| if (ReadPrimitiveField(fieldType, ref value)) | |
| { | |
| list.Add(value); | |
| } | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadStringArray(uint fieldTag, string fieldName, ICollection<string> list) | |
| { | |
| string tmp = null; | |
| do | |
| { | |
| ReadString(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadBytesArray(uint fieldTag, string fieldName, ICollection<ByteString> list) | |
| { | |
| ByteString tmp = null; | |
| do | |
| { | |
| ReadBytes(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadBoolArray(uint fieldTag, string fieldName, ICollection<bool> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| bool tmp = false; | |
| do | |
| { | |
| ReadBool(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadInt32Array(uint fieldTag, string fieldName, ICollection<int> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| int tmp = 0; | |
| do | |
| { | |
| ReadInt32(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadSInt32Array(uint fieldTag, string fieldName, ICollection<int> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| int tmp = 0; | |
| do | |
| { | |
| ReadSInt32(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadUInt32Array(uint fieldTag, string fieldName, ICollection<uint> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| uint tmp = 0; | |
| do | |
| { | |
| ReadUInt32(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadFixed32Array(uint fieldTag, string fieldName, ICollection<uint> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| uint tmp = 0; | |
| do | |
| { | |
| ReadFixed32(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadSFixed32Array(uint fieldTag, string fieldName, ICollection<int> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| int tmp = 0; | |
| do | |
| { | |
| ReadSFixed32(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadInt64Array(uint fieldTag, string fieldName, ICollection<long> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| long tmp = 0; | |
| do | |
| { | |
| ReadInt64(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadSInt64Array(uint fieldTag, string fieldName, ICollection<long> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| long tmp = 0; | |
| do | |
| { | |
| ReadSInt64(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadUInt64Array(uint fieldTag, string fieldName, ICollection<ulong> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| ulong tmp = 0; | |
| do | |
| { | |
| ReadUInt64(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadFixed64Array(uint fieldTag, string fieldName, ICollection<ulong> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| ulong tmp = 0; | |
| do | |
| { | |
| ReadFixed64(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadSFixed64Array(uint fieldTag, string fieldName, ICollection<long> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| long tmp = 0; | |
| do | |
| { | |
| ReadSFixed64(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadDoubleArray(uint fieldTag, string fieldName, ICollection<double> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| double tmp = 0; | |
| do | |
| { | |
| ReadDouble(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadFloatArray(uint fieldTag, string fieldName, ICollection<float> list) | |
| { | |
| bool isPacked; | |
| int holdLimit; | |
| if (BeginArray(fieldTag, out isPacked, out holdLimit)) | |
| { | |
| float tmp = 0; | |
| do | |
| { | |
| ReadFloat(ref tmp); | |
| list.Add(tmp); | |
| } while (ContinueArray(fieldTag, isPacked, holdLimit)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadEnumArray(uint fieldTag, string fieldName, ICollection<IEnumLite> list, | |
| out ICollection<object> unknown, IEnumLiteMap mapping) | |
| { | |
| unknown = null; | |
| object unkval; | |
| IEnumLite value = null; | |
| WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag); | |
| // 2.3 allows packed form even if the field is not declared packed. | |
| if (wformat == WireFormat.WireType.LengthDelimited) | |
| { | |
| int length = (int) (ReadRawVarint32() & int.MaxValue); | |
| int limit = PushLimit(length); | |
| while (!ReachedLimit) | |
| { | |
| if (ReadEnum(ref value, out unkval, mapping)) | |
| { | |
| list.Add(value); | |
| } | |
| else | |
| { | |
| if (unknown == null) | |
| { | |
| unknown = new List<object>(); | |
| } | |
| unknown.Add(unkval); | |
| } | |
| } | |
| PopLimit(limit); | |
| } | |
| else | |
| { | |
| do | |
| { | |
| if (ReadEnum(ref value, out unkval, mapping)) | |
| { | |
| list.Add(value); | |
| } | |
| else | |
| { | |
| if (unknown == null) | |
| { | |
| unknown = new List<object>(); | |
| } | |
| unknown.Add(unkval); | |
| } | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadEnumArray<T>(uint fieldTag, string fieldName, ICollection<T> list, | |
| out ICollection<object> unknown) | |
| where T : struct, IComparable, IFormattable | |
| { | |
| unknown = null; | |
| object unkval; | |
| T value = default(T); | |
| WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag); | |
| // 2.3 allows packed form even if the field is not declared packed. | |
| if (wformat == WireFormat.WireType.LengthDelimited) | |
| { | |
| int length = (int) (ReadRawVarint32() & int.MaxValue); | |
| int limit = PushLimit(length); | |
| while (!ReachedLimit) | |
| { | |
| if (ReadEnum<T>(ref value, out unkval)) | |
| { | |
| list.Add(value); | |
| } | |
| else | |
| { | |
| if (unknown == null) | |
| { | |
| unknown = new List<object>(); | |
| } | |
| unknown.Add(unkval); | |
| } | |
| } | |
| PopLimit(limit); | |
| } | |
| else | |
| { | |
| do | |
| { | |
| if (ReadEnum(ref value, out unkval)) | |
| { | |
| list.Add(value); | |
| } | |
| else | |
| { | |
| if (unknown == null) | |
| { | |
| unknown = new List<object>(); | |
| } | |
| unknown.Add(unkval); | |
| } | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadMessageArray<T>(uint fieldTag, string fieldName, ICollection<T> list, T messageType, | |
| ExtensionRegistry registry) where T : IMessageLite | |
| { | |
| do | |
| { | |
| IBuilderLite builder = messageType.WeakCreateBuilderForType(); | |
| ReadMessage(builder, registry); | |
| list.Add((T) builder.WeakBuildPartial()); | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| [CLSCompliant(false)] | |
| public void ReadGroupArray<T>(uint fieldTag, string fieldName, ICollection<T> list, T messageType, | |
| ExtensionRegistry registry) where T : IMessageLite | |
| { | |
| do | |
| { | |
| IBuilderLite builder = messageType.WeakCreateBuilderForType(); | |
| ReadGroup(WireFormat.GetTagFieldNumber(fieldTag), builder, registry); | |
| list.Add((T) builder.WeakBuildPartial()); | |
| } while (ContinueArray(fieldTag)); | |
| } | |
| /// <summary> | |
| /// Reads a field of any primitive type. Enums, groups and embedded | |
| /// messages are not handled by this method. | |
| /// </summary> | |
| public bool ReadPrimitiveField(FieldType fieldType, ref object value) | |
| { | |
| switch (fieldType) | |
| { | |
| case FieldType.Double: | |
| { | |
| double tmp = 0; | |
| if (ReadDouble(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Float: | |
| { | |
| float tmp = 0; | |
| if (ReadFloat(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Int64: | |
| { | |
| long tmp = 0; | |
| if (ReadInt64(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.UInt64: | |
| { | |
| ulong tmp = 0; | |
| if (ReadUInt64(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Int32: | |
| { | |
| int tmp = 0; | |
| if (ReadInt32(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Fixed64: | |
| { | |
| ulong tmp = 0; | |
| if (ReadFixed64(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Fixed32: | |
| { | |
| uint tmp = 0; | |
| if (ReadFixed32(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Bool: | |
| { | |
| bool tmp = false; | |
| if (ReadBool(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.String: | |
| { | |
| string tmp = null; | |
| if (ReadString(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Bytes: | |
| { | |
| ByteString tmp = null; | |
| if (ReadBytes(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.UInt32: | |
| { | |
| uint tmp = 0; | |
| if (ReadUInt32(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.SFixed32: | |
| { | |
| int tmp = 0; | |
| if (ReadSFixed32(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.SFixed64: | |
| { | |
| long tmp = 0; | |
| if (ReadSFixed64(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.SInt32: | |
| { | |
| int tmp = 0; | |
| if (ReadSInt32(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.SInt64: | |
| { | |
| long tmp = 0; | |
| if (ReadSInt64(ref tmp)) | |
| { | |
| value = tmp; | |
| return true; | |
| } | |
| return false; | |
| } | |
| case FieldType.Group: | |
| throw new ArgumentException("ReadPrimitiveField() cannot handle nested groups."); | |
| case FieldType.Message: | |
| throw new ArgumentException("ReadPrimitiveField() cannot handle embedded messages."); | |
| // We don't handle enums because we don't know what to do if the | |
| // value is not recognized. | |
| case FieldType.Enum: | |
| throw new ArgumentException("ReadPrimitiveField() cannot handle enums."); | |
| default: | |
| throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); | |
| } | |
| } | |
| #endregion | |
| #region Underlying reading primitives | |
| /// <summary> | |
| /// Same code as ReadRawVarint32, but read each byte individually, checking for | |
| /// buffer overflow. | |
| /// </summary> | |
| private uint SlowReadRawVarint32() | |
| { | |
| int tmp = ReadRawByte(); | |
| if (tmp < 128) | |
| { | |
| return (uint) tmp; | |
| } | |
| int result = tmp & 0x7f; | |
| if ((tmp = ReadRawByte()) < 128) | |
| { | |
| result |= tmp << 7; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 7; | |
| if ((tmp = ReadRawByte()) < 128) | |
| { | |
| result |= tmp << 14; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 14; | |
| if ((tmp = ReadRawByte()) < 128) | |
| { | |
| result |= tmp << 21; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 21; | |
| result |= (tmp = ReadRawByte()) << 28; | |
| if (tmp >= 128) | |
| { | |
| // Discard upper 32 bits. | |
| for (int i = 0; i < 5; i++) | |
| { | |
| if (ReadRawByte() < 128) | |
| { | |
| return (uint) result; | |
| } | |
| } | |
| throw InvalidProtocolBufferException.MalformedVarint(); | |
| } | |
| } | |
| } | |
| } | |
| return (uint) result; | |
| } | |
| /// <summary> | |
| /// Read a raw Varint from the stream. If larger than 32 bits, discard the upper bits. | |
| /// This method is optimised for the case where we've got lots of data in the buffer. | |
| /// That means we can check the size just once, then just read directly from the buffer | |
| /// without constant rechecking of the buffer length. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public uint ReadRawVarint32() | |
| { | |
| if (bufferPos + 5 > bufferSize) | |
| { | |
| return SlowReadRawVarint32(); | |
| } | |
| int tmp = buffer[bufferPos++]; | |
| if (tmp < 128) | |
| { | |
| return (uint) tmp; | |
| } | |
| int result = tmp & 0x7f; | |
| if ((tmp = buffer[bufferPos++]) < 128) | |
| { | |
| result |= tmp << 7; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 7; | |
| if ((tmp = buffer[bufferPos++]) < 128) | |
| { | |
| result |= tmp << 14; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 14; | |
| if ((tmp = buffer[bufferPos++]) < 128) | |
| { | |
| result |= tmp << 21; | |
| } | |
| else | |
| { | |
| result |= (tmp & 0x7f) << 21; | |
| result |= (tmp = buffer[bufferPos++]) << 28; | |
| if (tmp >= 128) | |
| { | |
| // Discard upper 32 bits. | |
| // Note that this has to use ReadRawByte() as we only ensure we've | |
| // got at least 5 bytes at the start of the method. This lets us | |
| // use the fast path in more cases, and we rarely hit this section of code. | |
| for (int i = 0; i < 5; i++) | |
| { | |
| if (ReadRawByte() < 128) | |
| { | |
| return (uint) result; | |
| } | |
| } | |
| throw InvalidProtocolBufferException.MalformedVarint(); | |
| } | |
| } | |
| } | |
| } | |
| return (uint) result; | |
| } | |
| /// <summary> | |
| /// Reads a varint from the input one byte at a time, so that it does not | |
| /// read any bytes after the end of the varint. If you simply wrapped the | |
| /// stream in a CodedInputStream and used ReadRawVarint32(Stream)} | |
| /// then you would probably end up reading past the end of the varint since | |
| /// CodedInputStream buffers its input. | |
| /// </summary> | |
| /// <param name="input"></param> | |
| /// <returns></returns> | |
| [CLSCompliant(false)] | |
| public static uint ReadRawVarint32(Stream input) | |
| { | |
| int result = 0; | |
| int offset = 0; | |
| for (; offset < 32; offset += 7) | |
| { | |
| int b = input.ReadByte(); | |
| if (b == -1) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| result |= (b & 0x7f) << offset; | |
| if ((b & 0x80) == 0) | |
| { | |
| return (uint) result; | |
| } | |
| } | |
| // Keep reading up to 64 bits. | |
| for (; offset < 64; offset += 7) | |
| { | |
| int b = input.ReadByte(); | |
| if (b == -1) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| if ((b & 0x80) == 0) | |
| { | |
| return (uint) result; | |
| } | |
| } | |
| throw InvalidProtocolBufferException.MalformedVarint(); | |
| } | |
| /// <summary> | |
| /// Read a raw varint from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public ulong ReadRawVarint64() | |
| { | |
| int shift = 0; | |
| ulong result = 0; | |
| while (shift < 64) | |
| { | |
| byte b = ReadRawByte(); | |
| result |= (ulong) (b & 0x7F) << shift; | |
| if ((b & 0x80) == 0) | |
| { | |
| return result; | |
| } | |
| shift += 7; | |
| } | |
| throw InvalidProtocolBufferException.MalformedVarint(); | |
| } | |
| /// <summary> | |
| /// Read a 32-bit little-endian integer from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public uint ReadRawLittleEndian32() | |
| { | |
| uint b1 = ReadRawByte(); | |
| uint b2 = ReadRawByte(); | |
| uint b3 = ReadRawByte(); | |
| uint b4 = ReadRawByte(); | |
| return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24); | |
| } | |
| /// <summary> | |
| /// Read a 64-bit little-endian integer from the stream. | |
| /// </summary> | |
| [CLSCompliant(false)] | |
| public ulong ReadRawLittleEndian64() | |
| { | |
| ulong b1 = ReadRawByte(); | |
| ulong b2 = ReadRawByte(); | |
| ulong b3 = ReadRawByte(); | |
| ulong b4 = ReadRawByte(); | |
| ulong b5 = ReadRawByte(); | |
| ulong b6 = ReadRawByte(); | |
| ulong b7 = ReadRawByte(); | |
| ulong b8 = ReadRawByte(); | |
| return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24) | |
| | (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56); | |
| } | |
| #endregion | |
| /// <summary> | |
| /// Decode a 32-bit value with ZigZag encoding. | |
| /// </summary> | |
| /// <remarks> | |
| /// ZigZag encodes signed integers into values that can be efficiently | |
| /// encoded with varint. (Otherwise, negative values must be | |
| /// sign-extended to 64 bits to be varint encoded, thus always taking | |
| /// 10 bytes on the wire.) | |
| /// </remarks> | |
| [CLSCompliant(false)] | |
| public static int DecodeZigZag32(uint n) | |
| { | |
| return (int) (n >> 1) ^ -(int) (n & 1); | |
| } | |
| /// <summary> | |
| /// Decode a 32-bit value with ZigZag encoding. | |
| /// </summary> | |
| /// <remarks> | |
| /// ZigZag encodes signed integers into values that can be efficiently | |
| /// encoded with varint. (Otherwise, negative values must be | |
| /// sign-extended to 64 bits to be varint encoded, thus always taking | |
| /// 10 bytes on the wire.) | |
| /// </remarks> | |
| [CLSCompliant(false)] | |
| public static long DecodeZigZag64(ulong n) | |
| { | |
| return (long) (n >> 1) ^ -(long) (n & 1); | |
| } | |
| /// <summary> | |
| /// Set the maximum message recursion depth. | |
| /// </summary> | |
| /// <remarks> | |
| /// In order to prevent malicious | |
| /// messages from causing stack overflows, CodedInputStream limits | |
| /// how deeply messages may be nested. The default limit is 64. | |
| /// </remarks> | |
| public int SetRecursionLimit(int limit) | |
| { | |
| if (limit < 0) | |
| { | |
| throw new ArgumentOutOfRangeException("Recursion limit cannot be negative: " + limit); | |
| } | |
| int oldLimit = recursionLimit; | |
| recursionLimit = limit; | |
| return oldLimit; | |
| } | |
| /// <summary> | |
| /// Set the maximum message size. | |
| /// </summary> | |
| /// <remarks> | |
| /// In order to prevent malicious messages from exhausting memory or | |
| /// causing integer overflows, CodedInputStream limits how large a message may be. | |
| /// The default limit is 64MB. You should set this limit as small | |
| /// as you can without harming your app's functionality. Note that | |
| /// size limits only apply when reading from an InputStream, not | |
| /// when constructed around a raw byte array (nor with ByteString.NewCodedInput). | |
| /// If you want to read several messages from a single CodedInputStream, you | |
| /// can call ResetSizeCounter() after each message to avoid hitting the | |
| /// size limit. | |
| /// </remarks> | |
| public int SetSizeLimit(int limit) | |
| { | |
| if (limit < 0) | |
| { | |
| throw new ArgumentOutOfRangeException("Size limit cannot be negative: " + limit); | |
| } | |
| int oldLimit = sizeLimit; | |
| sizeLimit = limit; | |
| return oldLimit; | |
| } | |
| #region Internal reading and buffer management | |
| /// <summary> | |
| /// Resets the current size counter to zero (see SetSizeLimit). | |
| /// </summary> | |
| public void ResetSizeCounter() | |
| { | |
| totalBytesRetired = 0; | |
| } | |
| /// <summary> | |
| /// Sets currentLimit to (current position) + byteLimit. This is called | |
| /// when descending into a length-delimited embedded message. The previous | |
| /// limit is returned. | |
| /// </summary> | |
| /// <returns>The old limit.</returns> | |
| public int PushLimit(int byteLimit) | |
| { | |
| if (byteLimit < 0) | |
| { | |
| throw InvalidProtocolBufferException.NegativeSize(); | |
| } | |
| byteLimit += totalBytesRetired + bufferPos; | |
| int oldLimit = currentLimit; | |
| if (byteLimit > oldLimit) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| currentLimit = byteLimit; | |
| RecomputeBufferSizeAfterLimit(); | |
| return oldLimit; | |
| } | |
| private void RecomputeBufferSizeAfterLimit() | |
| { | |
| bufferSize += bufferSizeAfterLimit; | |
| int bufferEnd = totalBytesRetired + bufferSize; | |
| if (bufferEnd > currentLimit) | |
| { | |
| // Limit is in current buffer. | |
| bufferSizeAfterLimit = bufferEnd - currentLimit; | |
| bufferSize -= bufferSizeAfterLimit; | |
| } | |
| else | |
| { | |
| bufferSizeAfterLimit = 0; | |
| } | |
| } | |
| /// <summary> | |
| /// Discards the current limit, returning the previous limit. | |
| /// </summary> | |
| public void PopLimit(int oldLimit) | |
| { | |
| currentLimit = oldLimit; | |
| RecomputeBufferSizeAfterLimit(); | |
| } | |
| /// <summary> | |
| /// Returns whether or not all the data before the limit has been read. | |
| /// </summary> | |
| /// <returns></returns> | |
| public bool ReachedLimit | |
| { | |
| get | |
| { | |
| if (currentLimit == int.MaxValue) | |
| { | |
| return false; | |
| } | |
| int currentAbsolutePosition = totalBytesRetired + bufferPos; | |
| return currentAbsolutePosition >= currentLimit; | |
| } | |
| } | |
| /// <summary> | |
| /// Returns true if the stream has reached the end of the input. This is the | |
| /// case if either the end of the underlying input source has been reached or | |
| /// the stream has reached a limit created using PushLimit. | |
| /// </summary> | |
| public bool IsAtEnd | |
| { | |
| get { return bufferPos == bufferSize && !RefillBuffer(false); } | |
| } | |
| /// <summary> | |
| /// Called when buffer is empty to read more bytes from the | |
| /// input. If <paramref name="mustSucceed"/> is true, RefillBuffer() gurantees that | |
| /// either there will be at least one byte in the buffer when it returns | |
| /// or it will throw an exception. If <paramref name="mustSucceed"/> is false, | |
| /// RefillBuffer() returns false if no more bytes were available. | |
| /// </summary> | |
| /// <param name="mustSucceed"></param> | |
| /// <returns></returns> | |
| private bool RefillBuffer(bool mustSucceed) | |
| { | |
| if (bufferPos < bufferSize) | |
| { | |
| throw new InvalidOperationException("RefillBuffer() called when buffer wasn't empty."); | |
| } | |
| if (totalBytesRetired + bufferSize == currentLimit) | |
| { | |
| // Oops, we hit a limit. | |
| if (mustSucceed) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| else | |
| { | |
| return false; | |
| } | |
| } | |
| totalBytesRetired += bufferSize; | |
| bufferPos = 0; | |
| bufferSize = (input == null) ? 0 : input.Read(buffer, 0, buffer.Length); | |
| if (bufferSize < 0) | |
| { | |
| throw new InvalidOperationException("Stream.Read returned a negative count"); | |
| } | |
| if (bufferSize == 0) | |
| { | |
| if (mustSucceed) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| else | |
| { | |
| return false; | |
| } | |
| } | |
| else | |
| { | |
| RecomputeBufferSizeAfterLimit(); | |
| int totalBytesRead = | |
| totalBytesRetired + bufferSize + bufferSizeAfterLimit; | |
| if (totalBytesRead > sizeLimit || totalBytesRead < 0) | |
| { | |
| throw InvalidProtocolBufferException.SizeLimitExceeded(); | |
| } | |
| return true; | |
| } | |
| } | |
| /// <summary> | |
| /// Read one byte from the input. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException"> | |
| /// the end of the stream or the current limit was reached | |
| /// </exception> | |
| public byte ReadRawByte() | |
| { | |
| if (bufferPos == bufferSize) | |
| { | |
| RefillBuffer(true); | |
| } | |
| return buffer[bufferPos++]; | |
| } | |
| /// <summary> | |
| /// Read a fixed size of bytes from the input. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException"> | |
| /// the end of the stream or the current limit was reached | |
| /// </exception> | |
| public byte[] ReadRawBytes(int size) | |
| { | |
| if (size < 0) | |
| { | |
| throw InvalidProtocolBufferException.NegativeSize(); | |
| } | |
| if (totalBytesRetired + bufferPos + size > currentLimit) | |
| { | |
| // Read to the end of the stream anyway. | |
| SkipRawBytes(currentLimit - totalBytesRetired - bufferPos); | |
| // Then fail. | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| if (size <= bufferSize - bufferPos) | |
| { | |
| // We have all the bytes we need already. | |
| byte[] bytes = new byte[size]; | |
| ByteArray.Copy(buffer, bufferPos, bytes, 0, size); | |
| bufferPos += size; | |
| return bytes; | |
| } | |
| else if (size < buffer.Length) | |
| { | |
| // Reading more bytes than are in the buffer, but not an excessive number | |
| // of bytes. We can safely allocate the resulting array ahead of time. | |
| // First copy what we have. | |
| byte[] bytes = new byte[size]; | |
| int pos = bufferSize - bufferPos; | |
| ByteArray.Copy(buffer, bufferPos, bytes, 0, pos); | |
| bufferPos = bufferSize; | |
| // We want to use RefillBuffer() and then copy from the buffer into our | |
| // byte array rather than reading directly into our byte array because | |
| // the input may be unbuffered. | |
| RefillBuffer(true); | |
| while (size - pos > bufferSize) | |
| { | |
| Buffer.BlockCopy(buffer, 0, bytes, pos, bufferSize); | |
| pos += bufferSize; | |
| bufferPos = bufferSize; | |
| RefillBuffer(true); | |
| } | |
| ByteArray.Copy(buffer, 0, bytes, pos, size - pos); | |
| bufferPos = size - pos; | |
| return bytes; | |
| } | |
| else | |
| { | |
| // The size is very large. For security reasons, we can't allocate the | |
| // entire byte array yet. The size comes directly from the input, so a | |
| // maliciously-crafted message could provide a bogus very large size in | |
| // order to trick the app into allocating a lot of memory. We avoid this | |
| // by allocating and reading only a small chunk at a time, so that the | |
| // malicious message must actually *be* extremely large to cause | |
| // problems. Meanwhile, we limit the allowed size of a message elsewhere. | |
| // Remember the buffer markers since we'll have to copy the bytes out of | |
| // it later. | |
| int originalBufferPos = bufferPos; | |
| int originalBufferSize = bufferSize; | |
| // Mark the current buffer consumed. | |
| totalBytesRetired += bufferSize; | |
| bufferPos = 0; | |
| bufferSize = 0; | |
| // Read all the rest of the bytes we need. | |
| int sizeLeft = size - (originalBufferSize - originalBufferPos); | |
| List<byte[]> chunks = new List<byte[]>(); | |
| while (sizeLeft > 0) | |
| { | |
| byte[] chunk = new byte[Math.Min(sizeLeft, buffer.Length)]; | |
| int pos = 0; | |
| while (pos < chunk.Length) | |
| { | |
| int n = (input == null) ? -1 : input.Read(chunk, pos, chunk.Length - pos); | |
| if (n <= 0) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| totalBytesRetired += n; | |
| pos += n; | |
| } | |
| sizeLeft -= chunk.Length; | |
| chunks.Add(chunk); | |
| } | |
| // OK, got everything. Now concatenate it all into one buffer. | |
| byte[] bytes = new byte[size]; | |
| // Start by copying the leftover bytes from this.buffer. | |
| int newPos = originalBufferSize - originalBufferPos; | |
| ByteArray.Copy(buffer, originalBufferPos, bytes, 0, newPos); | |
| // And now all the chunks. | |
| foreach (byte[] chunk in chunks) | |
| { | |
| Buffer.BlockCopy(chunk, 0, bytes, newPos, chunk.Length); | |
| newPos += chunk.Length; | |
| } | |
| // Done. | |
| return bytes; | |
| } | |
| } | |
| /// <summary> | |
| /// Reads and discards a single field, given its tag value. | |
| /// </summary> | |
| /// <returns>false if the tag is an end-group tag, in which case | |
| /// nothing is skipped. Otherwise, returns true.</returns> | |
| [CLSCompliant(false)] | |
| public bool SkipField() | |
| { | |
| uint tag = lastTag; | |
| switch (WireFormat.GetTagWireType(tag)) | |
| { | |
| case WireFormat.WireType.Varint: | |
| ReadRawVarint64(); | |
| return true; | |
| case WireFormat.WireType.Fixed64: | |
| ReadRawLittleEndian64(); | |
| return true; | |
| case WireFormat.WireType.LengthDelimited: | |
| SkipRawBytes((int) ReadRawVarint32()); | |
| return true; | |
| case WireFormat.WireType.StartGroup: | |
| SkipMessage(); | |
| CheckLastTagWas( | |
| WireFormat.MakeTag(WireFormat.GetTagFieldNumber(tag), | |
| WireFormat.WireType.EndGroup)); | |
| return true; | |
| case WireFormat.WireType.EndGroup: | |
| return false; | |
| case WireFormat.WireType.Fixed32: | |
| ReadRawLittleEndian32(); | |
| return true; | |
| default: | |
| throw InvalidProtocolBufferException.InvalidWireType(); | |
| } | |
| } | |
| /// <summary> | |
| /// Reads and discards an entire message. This will read either until EOF | |
| /// or until an endgroup tag, whichever comes first. | |
| /// </summary> | |
| public void SkipMessage() | |
| { | |
| uint tag; | |
| string name; | |
| while (ReadTag(out tag, out name)) | |
| { | |
| if (!SkipField()) | |
| { | |
| return; | |
| } | |
| } | |
| } | |
| /// <summary> | |
| /// Reads and discards <paramref name="size"/> bytes. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException">the end of the stream | |
| /// or the current limit was reached</exception> | |
| public void SkipRawBytes(int size) | |
| { | |
| if (size < 0) | |
| { | |
| throw InvalidProtocolBufferException.NegativeSize(); | |
| } | |
| if (totalBytesRetired + bufferPos + size > currentLimit) | |
| { | |
| // Read to the end of the stream anyway. | |
| SkipRawBytes(currentLimit - totalBytesRetired - bufferPos); | |
| // Then fail. | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| if (size <= bufferSize - bufferPos) | |
| { | |
| // We have all the bytes we need already. | |
| bufferPos += size; | |
| } | |
| else | |
| { | |
| // Skipping more bytes than are in the buffer. First skip what we have. | |
| int pos = bufferSize - bufferPos; | |
| // ROK 5/7/2013 Issue #54: should retire all bytes in buffer (bufferSize) | |
| // totalBytesRetired += pos; | |
| totalBytesRetired += bufferSize; | |
| bufferPos = 0; | |
| bufferSize = 0; | |
| // Then skip directly from the InputStream for the rest. | |
| if (pos < size) | |
| { | |
| if (input == null) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| SkipImpl(size - pos); | |
| totalBytesRetired += size - pos; | |
| } | |
| } | |
| } | |
| /// <summary> | |
| /// Abstraction of skipping to cope with streams which can't really skip. | |
| /// </summary> | |
| private void SkipImpl(int amountToSkip) | |
| { | |
| if (input.CanSeek) | |
| { | |
| long previousPosition = input.Position; | |
| input.Position += amountToSkip; | |
| if (input.Position != previousPosition + amountToSkip) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| } | |
| else | |
| { | |
| byte[] skipBuffer = new byte[1024]; | |
| while (amountToSkip > 0) | |
| { | |
| int bytesRead = input.Read(skipBuffer, 0, skipBuffer.Length); | |
| if (bytesRead <= 0) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| amountToSkip -= bytesRead; | |
| } | |
| } | |
| } | |
| #endregion | |
| } | |
| } |