| #region Copyright notice and license | |
| // Protocol Buffers - Google's data interchange format | |
| // Copyright 2008 Google Inc. All rights reserved. | |
| // https://developers.google.com/protocol-buffers/ | |
| // | |
| // 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 Google.Protobuf.Collections; | |
| using System; | |
| using System.Collections.Generic; | |
| using System.IO; | |
| namespace Google.Protobuf | |
| { | |
| /// <summary> | |
| /// Reads and decodes protocol message fields. | |
| /// </summary> | |
| /// <remarks> | |
| /// <para> | |
| /// This class is generally used by generated code to read appropriate | |
| /// primitives from the stream. It effectively encapsulates the lowest | |
| /// levels of protocol buffer format. | |
| /// </para> | |
| /// <para> | |
| /// Repeated fields and map fields are not handled by this class; use <see cref="RepeatedField{T}"/> | |
| /// and <see cref="MapField{TKey, TValue}"/> to serialize such fields. | |
| /// </para> | |
| /// </remarks> | |
| public sealed class CodedInputStream : IDisposable | |
| { | |
| /// <summary> | |
| /// Whether to leave the underlying stream open when disposing of this stream. | |
| /// This is always true when there's no stream. | |
| /// </summary> | |
| private readonly bool leaveOpen; | |
| /// <summary> | |
| /// Buffer of data read from the stream or provided at construction time. | |
| /// </summary> | |
| private readonly byte[] buffer; | |
| /// <summary> | |
| /// The index of the buffer at which we need to refill from the stream (if there is one). | |
| /// </summary> | |
| private int bufferSize; | |
| private int bufferSizeAfterLimit = 0; | |
| /// <summary> | |
| /// The position within the current buffer (i.e. the next byte to read) | |
| /// </summary> | |
| private int bufferPos = 0; | |
| /// <summary> | |
| /// The stream to read further input from, or null if the byte array buffer was provided | |
| /// directly on construction, with no further data available. | |
| /// </summary> | |
| private readonly Stream input; | |
| /// <summary> | |
| /// The last tag we read. 0 indicates we've read to the end of the stream | |
| /// (or haven't read anything yet). | |
| /// </summary> | |
| private uint lastTag = 0; | |
| /// <summary> | |
| /// The next tag, used to store the value read by PeekTag. | |
| /// </summary> | |
| private uint nextTag = 0; | |
| private bool hasNextTag = false; | |
| internal const int DefaultRecursionLimit = 100; | |
| internal const int DefaultSizeLimit = Int32.MaxValue; | |
| internal 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; | |
| private int recursionDepth = 0; | |
| private readonly int recursionLimit; | |
| private readonly int sizeLimit; | |
| #region Construction | |
| // Note that the checks are performed such that we don't end up checking obviously-valid things | |
| // like non-null references for arrays we've just created. | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given byte array. | |
| /// </summary> | |
| public CodedInputStream(byte[] buffer) : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), 0, buffer.Length, true) | |
| { | |
| } | |
| /// <summary> | |
| /// Creates a new <see cref="CodedInputStream"/> that reads from the given byte array slice. | |
| /// </summary> | |
| public CodedInputStream(byte[] buffer, int offset, int length) | |
| : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), offset, offset + length, true) | |
| { | |
| if (offset < 0 || offset > buffer.Length) | |
| { | |
| throw new ArgumentOutOfRangeException("offset", "Offset must be within the buffer"); | |
| } | |
| if (length < 0 || offset + length > buffer.Length) | |
| { | |
| throw new ArgumentOutOfRangeException("length", "Length must be non-negative and within the buffer"); | |
| } | |
| } | |
| /// <summary> | |
| /// Creates a new <see cref="CodedInputStream"/> reading data from the given stream, which will be disposed | |
| /// when the returned object is disposed. | |
| /// </summary> | |
| /// <param name="input">The stream to read from.</param> | |
| public CodedInputStream(Stream input) : this(input, false) | |
| { | |
| } | |
| /// <summary> | |
| /// Creates a new <see cref="CodedInputStream"/> reading data from the given stream. | |
| /// </summary> | |
| /// <param name="input">The stream to read from.</param> | |
| /// <param name="leaveOpen"><c>true</c> to leave <paramref name="input"/> open when the returned | |
| /// <c cref="CodedInputStream"/> is disposed; <c>false</c> to dispose of the given stream when the | |
| /// returned object is disposed.</param> | |
| public CodedInputStream(Stream input, bool leaveOpen) | |
| : this(ProtoPreconditions.CheckNotNull(input, "input"), new byte[BufferSize], 0, 0, leaveOpen) | |
| { | |
| } | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given | |
| /// stream and buffer, using the default limits. | |
| /// </summary> | |
| internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, bool leaveOpen) | |
| { | |
| this.input = input; | |
| this.buffer = buffer; | |
| this.bufferPos = bufferPos; | |
| this.bufferSize = bufferSize; | |
| this.sizeLimit = DefaultSizeLimit; | |
| this.recursionLimit = DefaultRecursionLimit; | |
| this.leaveOpen = leaveOpen; | |
| } | |
| /// <summary> | |
| /// Creates a new CodedInputStream reading data from the given | |
| /// stream and buffer, using the specified limits. | |
| /// </summary> | |
| /// <remarks> | |
| /// This chains to the version with the default limits instead of vice versa to avoid | |
| /// having to check that the default values are valid every time. | |
| /// </remarks> | |
| internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, int sizeLimit, int recursionLimit, bool leaveOpen) | |
| : this(input, buffer, bufferPos, bufferSize, leaveOpen) | |
| { | |
| if (sizeLimit <= 0) | |
| { | |
| throw new ArgumentOutOfRangeException("sizeLimit", "Size limit must be positive"); | |
| } | |
| if (recursionLimit <= 0) | |
| { | |
| throw new ArgumentOutOfRangeException("recursionLimit!", "Recursion limit must be positive"); | |
| } | |
| this.sizeLimit = sizeLimit; | |
| this.recursionLimit = recursionLimit; | |
| } | |
| #endregion | |
| /// <summary> | |
| /// Creates a <see cref="CodedInputStream"/> with the specified size and recursion limits, reading | |
| /// from an input stream. | |
| /// </summary> | |
| /// <remarks> | |
| /// This method exists separately from the constructor to reduce the number of constructor overloads. | |
| /// It is likely to be used considerably less frequently than the constructors, as the default limits | |
| /// are suitable for most use cases. | |
| /// </remarks> | |
| /// <param name="input">The input stream to read from</param> | |
| /// <param name="sizeLimit">The total limit of data to read from the stream.</param> | |
| /// <param name="recursionLimit">The maximum recursion depth to allow while reading.</param> | |
| /// <returns>A <c>CodedInputStream</c> reading from <paramref name="input"/> with the specified size | |
| /// and recursion limits.</returns> | |
| public static CodedInputStream CreateWithLimits(Stream input, int sizeLimit, int recursionLimit) | |
| { | |
| // Note: we may want an overload accepting leaveOpen | |
| return new CodedInputStream(input, new byte[BufferSize], 0, 0, sizeLimit, recursionLimit, false); | |
| } | |
| /// <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; | |
| } | |
| } | |
| /// <summary> | |
| /// Returns the last tag read, or 0 if no tags have been read or we've read beyond | |
| /// the end of the stream. | |
| /// </summary> | |
| internal uint LastTag { get { return lastTag; } } | |
| /// <summary> | |
| /// Returns the size limit for this stream. | |
| /// </summary> | |
| /// <remarks> | |
| /// This limit is applied when reading from the underlying stream, as a sanity check. It is | |
| /// not applied when reading from a byte array data source without an underlying stream. | |
| /// The default value is Int32.MaxValue. | |
| /// </remarks> | |
| /// <value> | |
| /// The size limit. | |
| /// </value> | |
| public int SizeLimit { get { return sizeLimit; } } | |
| /// <summary> | |
| /// Returns the recursion limit for this stream. This limit is applied whilst reading messages, | |
| /// to avoid maliciously-recursive data. | |
| /// </summary> | |
| /// <remarks> | |
| /// The default limit is 100. | |
| /// </remarks> | |
| /// <value> | |
| /// The recursion limit for this stream. | |
| /// </value> | |
| public int RecursionLimit { get { return recursionLimit; } } | |
| /// <summary> | |
| /// Internal-only property; when set to true, unknown fields will be discarded while parsing. | |
| /// </summary> | |
| internal bool DiscardUnknownFields { get; set; } | |
| /// <summary> | |
| /// Internal-only property; provides extension identifiers to compatible messages while parsing. | |
| /// </summary> | |
| internal ExtensionRegistry ExtensionRegistry { get; set; } | |
| /// <summary> | |
| /// Disposes of this instance, potentially closing any underlying stream. | |
| /// </summary> | |
| /// <remarks> | |
| /// As there is no flushing to perform here, disposing of a <see cref="CodedInputStream"/> which | |
| /// was constructed with the <c>leaveOpen</c> option parameter set to <c>true</c> (or one which | |
| /// was constructed to read from a byte array) has no effect. | |
| /// </remarks> | |
| public void Dispose() | |
| { | |
| if (!leaveOpen) | |
| { | |
| input.Dispose(); | |
| } | |
| } | |
| #region Validation | |
| /// <summary> | |
| /// Verifies that the last call to ReadTag() returned tag 0 - in other words, | |
| /// we've reached the end of the stream when we expected to. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException">The | |
| /// tag read was not the one specified</exception> | |
| internal void CheckReadEndOfStreamTag() | |
| { | |
| if (lastTag != 0) | |
| { | |
| throw InvalidProtocolBufferException.MoreDataAvailable(); | |
| } | |
| } | |
| #endregion | |
| #region Reading of tags etc | |
| /// <summary> | |
| /// Peeks at the next field tag. This is like calling <see cref="ReadTag"/>, but the | |
| /// tag is not consumed. (So a subsequent call to <see cref="ReadTag"/> will return the | |
| /// same value.) | |
| /// </summary> | |
| public uint PeekTag() | |
| { | |
| if (hasNextTag) | |
| { | |
| return nextTag; | |
| } | |
| uint savedLast = lastTag; | |
| nextTag = ReadTag(); | |
| hasNextTag = true; | |
| lastTag = savedLast; // Undo the side effect of ReadTag | |
| return nextTag; | |
| } | |
| /// <summary> | |
| /// Reads a field tag, returning the tag of 0 for "end of stream". | |
| /// </summary> | |
| /// <remarks> | |
| /// If this method returns 0, it doesn't necessarily mean the end of all | |
| /// the data in this CodedInputStream; it may be the end of the logical stream | |
| /// for an embedded message, for example. | |
| /// </remarks> | |
| /// <returns>The next field tag, or 0 for end of stream. (0 is never a valid tag.)</returns> | |
| public uint ReadTag() | |
| { | |
| if (hasNextTag) | |
| { | |
| lastTag = nextTag; | |
| hasNextTag = false; | |
| return lastTag; | |
| } | |
| // Optimize for the incredibly common case of having at least two bytes left in the buffer, | |
| // and those two bytes being enough to get the tag. This will be true for fields up to 4095. | |
| if (bufferPos + 2 <= bufferSize) | |
| { | |
| int tmp = buffer[bufferPos++]; | |
| if (tmp < 128) | |
| { | |
| lastTag = (uint)tmp; | |
| } | |
| else | |
| { | |
| int result = tmp & 0x7f; | |
| if ((tmp = buffer[bufferPos++]) < 128) | |
| { | |
| result |= tmp << 7; | |
| lastTag = (uint) result; | |
| } | |
| else | |
| { | |
| // Nope, rewind and go the potentially slow route. | |
| bufferPos -= 2; | |
| lastTag = ReadRawVarint32(); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| if (IsAtEnd) | |
| { | |
| lastTag = 0; | |
| return 0; | |
| } | |
| lastTag = ReadRawVarint32(); | |
| } | |
| if (WireFormat.GetTagFieldNumber(lastTag) == 0) | |
| { | |
| // If we actually read a tag with a field of 0, that's not a valid tag. | |
| throw InvalidProtocolBufferException.InvalidTag(); | |
| } | |
| if (ReachedLimit) | |
| { | |
| return 0; | |
| } | |
| return lastTag; | |
| } | |
| /// <summary> | |
| /// Skips the data for the field with the tag we've just read. | |
| /// This should be called directly after <see cref="ReadTag"/>, when | |
| /// the caller wishes to skip an unknown field. | |
| /// </summary> | |
| /// <remarks> | |
| /// This method throws <see cref="InvalidProtocolBufferException"/> if the last-read tag was an end-group tag. | |
| /// If a caller wishes to skip a group, they should skip the whole group, by calling this method after reading the | |
| /// start-group tag. This behavior allows callers to call this method on any field they don't understand, correctly | |
| /// resulting in an error if an end-group tag has not been paired with an earlier start-group tag. | |
| /// </remarks> | |
| /// <exception cref="InvalidProtocolBufferException">The last tag was an end-group tag</exception> | |
| /// <exception cref="InvalidOperationException">The last read operation read to the end of the logical stream</exception> | |
| public void SkipLastField() | |
| { | |
| if (lastTag == 0) | |
| { | |
| throw new InvalidOperationException("SkipLastField cannot be called at the end of a stream"); | |
| } | |
| switch (WireFormat.GetTagWireType(lastTag)) | |
| { | |
| case WireFormat.WireType.StartGroup: | |
| SkipGroup(lastTag); | |
| break; | |
| case WireFormat.WireType.EndGroup: | |
| throw new InvalidProtocolBufferException( | |
| "SkipLastField called on an end-group tag, indicating that the corresponding start-group was missing"); | |
| case WireFormat.WireType.Fixed32: | |
| ReadFixed32(); | |
| break; | |
| case WireFormat.WireType.Fixed64: | |
| ReadFixed64(); | |
| break; | |
| case WireFormat.WireType.LengthDelimited: | |
| var length = ReadLength(); | |
| SkipRawBytes(length); | |
| break; | |
| case WireFormat.WireType.Varint: | |
| ReadRawVarint32(); | |
| break; | |
| } | |
| } | |
| /// <summary> | |
| /// Skip a group. | |
| /// </summary> | |
| internal void SkipGroup(uint startGroupTag) | |
| { | |
| // Note: Currently we expect this to be the way that groups are read. We could put the recursion | |
| // depth changes into the ReadTag method instead, potentially... | |
| recursionDepth++; | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| uint tag; | |
| while (true) | |
| { | |
| tag = ReadTag(); | |
| if (tag == 0) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| // Can't call SkipLastField for this case- that would throw. | |
| if (WireFormat.GetTagWireType(tag) == WireFormat.WireType.EndGroup) | |
| { | |
| break; | |
| } | |
| // This recursion will allow us to handle nested groups. | |
| SkipLastField(); | |
| } | |
| int startField = WireFormat.GetTagFieldNumber(startGroupTag); | |
| int endField = WireFormat.GetTagFieldNumber(tag); | |
| if (startField != endField) | |
| { | |
| throw new InvalidProtocolBufferException( | |
| $"Mismatched end-group tag. Started with field {startField}; ended with field {endField}"); | |
| } | |
| recursionDepth--; | |
| } | |
| /// <summary> | |
| /// Reads a double field from the stream. | |
| /// </summary> | |
| public double ReadDouble() | |
| { | |
| return BitConverter.Int64BitsToDouble((long) ReadRawLittleEndian64()); | |
| } | |
| /// <summary> | |
| /// Reads a float field from the stream. | |
| /// </summary> | |
| public float ReadFloat() | |
| { | |
| if (BitConverter.IsLittleEndian && 4 <= bufferSize - bufferPos) | |
| { | |
| float ret = BitConverter.ToSingle(buffer, bufferPos); | |
| bufferPos += 4; | |
| return ret; | |
| } | |
| else | |
| { | |
| byte[] rawBytes = ReadRawBytes(4); | |
| if (!BitConverter.IsLittleEndian) | |
| { | |
| ByteArray.Reverse(rawBytes); | |
| } | |
| return BitConverter.ToSingle(rawBytes, 0); | |
| } | |
| } | |
| /// <summary> | |
| /// Reads a uint64 field from the stream. | |
| /// </summary> | |
| public ulong ReadUInt64() | |
| { | |
| return ReadRawVarint64(); | |
| } | |
| /// <summary> | |
| /// Reads an int64 field from the stream. | |
| /// </summary> | |
| public long ReadInt64() | |
| { | |
| return (long) ReadRawVarint64(); | |
| } | |
| /// <summary> | |
| /// Reads an int32 field from the stream. | |
| /// </summary> | |
| public int ReadInt32() | |
| { | |
| return (int) ReadRawVarint32(); | |
| } | |
| /// <summary> | |
| /// Reads a fixed64 field from the stream. | |
| /// </summary> | |
| public ulong ReadFixed64() | |
| { | |
| return ReadRawLittleEndian64(); | |
| } | |
| /// <summary> | |
| /// Reads a fixed32 field from the stream. | |
| /// </summary> | |
| public uint ReadFixed32() | |
| { | |
| return ReadRawLittleEndian32(); | |
| } | |
| /// <summary> | |
| /// Reads a bool field from the stream. | |
| /// </summary> | |
| public bool ReadBool() | |
| { | |
| return ReadRawVarint32() != 0; | |
| } | |
| /// <summary> | |
| /// Reads a string field from the stream. | |
| /// </summary> | |
| public string ReadString() | |
| { | |
| int length = ReadLength(); | |
| // No need to read any data for an empty string. | |
| if (length == 0) | |
| { | |
| return ""; | |
| } | |
| if (length <= bufferSize - bufferPos && length > 0) | |
| { | |
| // Fast path: We already have the bytes in a contiguous buffer, so | |
| // just copy directly from it. | |
| String result = CodedOutputStream.Utf8Encoding.GetString(buffer, bufferPos, length); | |
| bufferPos += length; | |
| return result; | |
| } | |
| // Slow path: Build a byte array first then copy it. | |
| return CodedOutputStream.Utf8Encoding.GetString(ReadRawBytes(length), 0, length); | |
| } | |
| /// <summary> | |
| /// Reads an embedded message field value from the stream. | |
| /// </summary> | |
| public void ReadMessage(IMessage builder) | |
| { | |
| int length = ReadLength(); | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| int oldLimit = PushLimit(length); | |
| ++recursionDepth; | |
| builder.MergeFrom(this); | |
| CheckReadEndOfStreamTag(); | |
| // Check that we've read exactly as much data as expected. | |
| if (!ReachedLimit) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| --recursionDepth; | |
| PopLimit(oldLimit); | |
| } | |
| /// <summary> | |
| /// Reads an embedded group field from the stream. | |
| /// </summary> | |
| public void ReadGroup(IMessage builder) | |
| { | |
| if (recursionDepth >= recursionLimit) | |
| { | |
| throw InvalidProtocolBufferException.RecursionLimitExceeded(); | |
| } | |
| ++recursionDepth; | |
| builder.MergeFrom(this); | |
| --recursionDepth; | |
| } | |
| /// <summary> | |
| /// Reads a bytes field value from the stream. | |
| /// </summary> | |
| public ByteString ReadBytes() | |
| { | |
| int length = ReadLength(); | |
| if (length <= bufferSize - bufferPos && length > 0) | |
| { | |
| // Fast path: We already have the bytes in a contiguous buffer, so | |
| // just copy directly from it. | |
| ByteString result = ByteString.CopyFrom(buffer, bufferPos, length); | |
| bufferPos += length; | |
| return result; | |
| } | |
| else | |
| { | |
| // Slow path: Build a byte array and attach it to a new ByteString. | |
| return ByteString.AttachBytes(ReadRawBytes(length)); | |
| } | |
| } | |
| /// <summary> | |
| /// Reads a uint32 field value from the stream. | |
| /// </summary> | |
| public uint ReadUInt32() | |
| { | |
| return ReadRawVarint32(); | |
| } | |
| /// <summary> | |
| /// Reads an enum field value from the stream. | |
| /// </summary> | |
| public int ReadEnum() | |
| { | |
| // Currently just a pass-through, but it's nice to separate it logically from WriteInt32. | |
| return (int) ReadRawVarint32(); | |
| } | |
| /// <summary> | |
| /// Reads an sfixed32 field value from the stream. | |
| /// </summary> | |
| public int ReadSFixed32() | |
| { | |
| return (int) ReadRawLittleEndian32(); | |
| } | |
| /// <summary> | |
| /// Reads an sfixed64 field value from the stream. | |
| /// </summary> | |
| public long ReadSFixed64() | |
| { | |
| return (long) ReadRawLittleEndian64(); | |
| } | |
| /// <summary> | |
| /// Reads an sint32 field value from the stream. | |
| /// </summary> | |
| public int ReadSInt32() | |
| { | |
| return DecodeZigZag32(ReadRawVarint32()); | |
| } | |
| /// <summary> | |
| /// Reads an sint64 field value from the stream. | |
| /// </summary> | |
| public long ReadSInt64() | |
| { | |
| return DecodeZigZag64(ReadRawVarint64()); | |
| } | |
| /// <summary> | |
| /// Reads a length for length-delimited data. | |
| /// </summary> | |
| /// <remarks> | |
| /// This is internally just reading a varint, but this method exists | |
| /// to make the calling code clearer. | |
| /// </remarks> | |
| public int ReadLength() | |
| { | |
| return (int) ReadRawVarint32(); | |
| } | |
| /// <summary> | |
| /// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>, | |
| /// the tag is consumed and the method returns <c>true</c>; otherwise, the | |
| /// stream is left in the original position and the method returns <c>false</c>. | |
| /// </summary> | |
| public bool MaybeConsumeTag(uint tag) | |
| { | |
| if (PeekTag() == tag) | |
| { | |
| hasNextTag = false; | |
| return true; | |
| } | |
| return false; | |
| } | |
| #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> | |
| /// Reads 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> | |
| internal 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> | |
| internal 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> | |
| /// Reads a raw varint from the stream. | |
| /// </summary> | |
| internal 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> | |
| /// Reads a 32-bit little-endian integer from the stream. | |
| /// </summary> | |
| internal uint ReadRawLittleEndian32() | |
| { | |
| uint b1 = ReadRawByte(); | |
| uint b2 = ReadRawByte(); | |
| uint b3 = ReadRawByte(); | |
| uint b4 = ReadRawByte(); | |
| return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24); | |
| } | |
| /// <summary> | |
| /// Reads a 64-bit little-endian integer from the stream. | |
| /// </summary> | |
| internal 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); | |
| } | |
| /// <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> | |
| internal 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> | |
| internal static long DecodeZigZag64(ulong n) | |
| { | |
| return (long)(n >> 1) ^ -(long)(n & 1); | |
| } | |
| #endregion | |
| #region Internal reading and buffer management | |
| /// <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> | |
| internal 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> | |
| internal void PopLimit(int oldLimit) | |
| { | |
| currentLimit = oldLimit; | |
| RecomputeBufferSizeAfterLimit(); | |
| } | |
| /// <summary> | |
| /// Returns whether or not all the data before the limit has been read. | |
| /// </summary> | |
| /// <returns></returns> | |
| internal 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 < 0 || totalBytesRead > sizeLimit) | |
| { | |
| 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> | |
| internal byte ReadRawByte() | |
| { | |
| if (bufferPos == bufferSize) | |
| { | |
| RefillBuffer(true); | |
| } | |
| return buffer[bufferPos++]; | |
| } | |
| /// <summary> | |
| /// Reads a fixed size of bytes from the input. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException"> | |
| /// the end of the stream or the current limit was reached | |
| /// </exception> | |
| internal byte[] ReadRawBytes(int size) | |
| { | |
| if (size < 0) | |
| { | |
| throw InvalidProtocolBufferException.NegativeSize(); | |
| } | |
| if (totalBytesRetired + bufferPos + size > currentLimit) | |
| { | |
| // Read to the end of the stream (up to the current limit) 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 <paramref name="size"/> bytes. | |
| /// </summary> | |
| /// <exception cref="InvalidProtocolBufferException">the end of the stream | |
| /// or the current limit was reached</exception> | |
| private 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[Math.Min(1024, amountToSkip)]; | |
| while (amountToSkip > 0) | |
| { | |
| int bytesRead = input.Read(skipBuffer, 0, Math.Min(skipBuffer.Length, amountToSkip)); | |
| if (bytesRead <= 0) | |
| { | |
| throw InvalidProtocolBufferException.TruncatedMessage(); | |
| } | |
| amountToSkip -= bytesRead; | |
| } | |
| } | |
| } | |
| #endregion | |
| } | |
| } |