816 lines
33 KiB
C#
816 lines
33 KiB
C#
#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 System;
|
|
using System.Buffers;
|
|
using System.Buffers.Binary;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security;
|
|
using System.Text;
|
|
using LC.Google.Protobuf.Collections;
|
|
|
|
namespace LC.Google.Protobuf
|
|
{
|
|
/// <summary>
|
|
/// Primitives for parsing protobuf wire format.
|
|
/// </summary>
|
|
[SecuritySafeCritical]
|
|
internal static class ParsingPrimitives
|
|
{
|
|
private const int StackallocThreshold = 256;
|
|
|
|
/// <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>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
return (int)ParseRawVarint32(ref buffer, ref state);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the next tag.
|
|
/// If the end of logical stream was reached, an invalid tag of 0 is returned.
|
|
/// </summary>
|
|
public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
// The "nextTag" logic is there only as an optimization for reading non-packed repeated / map
|
|
// fields and is strictly speaking not necessary.
|
|
// TODO(jtattermusch): look into simplifying the ParseTag logic.
|
|
if (state.hasNextTag)
|
|
{
|
|
state.lastTag = state.nextTag;
|
|
state.hasNextTag = false;
|
|
return state.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 (state.bufferPos + 2 <= state.bufferSize)
|
|
{
|
|
int tmp = buffer[state.bufferPos++];
|
|
if (tmp < 128)
|
|
{
|
|
state.lastTag = (uint)tmp;
|
|
}
|
|
else
|
|
{
|
|
int result = tmp & 0x7f;
|
|
if ((tmp = buffer[state.bufferPos++]) < 128)
|
|
{
|
|
result |= tmp << 7;
|
|
state.lastTag = (uint) result;
|
|
}
|
|
else
|
|
{
|
|
// Nope, rewind and go the potentially slow route.
|
|
state.bufferPos -= 2;
|
|
state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (SegmentedBufferHelper.IsAtEnd(ref buffer, ref state))
|
|
{
|
|
state.lastTag = 0;
|
|
return 0;
|
|
}
|
|
|
|
state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
|
|
}
|
|
if (WireFormat.GetTagFieldNumber(state.lastTag) == 0)
|
|
{
|
|
// If we actually read a tag with a field of 0, that's not a valid tag.
|
|
throw InvalidProtocolBufferException.InvalidTag();
|
|
}
|
|
return state.lastTag;
|
|
}
|
|
|
|
/// <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 static bool MaybeConsumeTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint tag)
|
|
{
|
|
if (PeekTag(ref buffer, ref state) == tag)
|
|
{
|
|
state.hasNextTag = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Peeks at the next field tag. This is like calling <see cref="ParseTag"/>, but the
|
|
/// tag is not consumed. (So a subsequent call to <see cref="ParseTag"/> will return the
|
|
/// same value.)
|
|
/// </summary>
|
|
public static uint PeekTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
if (state.hasNextTag)
|
|
{
|
|
return state.nextTag;
|
|
}
|
|
|
|
uint savedLast = state.lastTag;
|
|
state.nextTag = ParseTag(ref buffer, ref state);
|
|
state.hasNextTag = true;
|
|
state.lastTag = savedLast; // Undo the side effect of ReadTag
|
|
return state.nextTag;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a raw varint.
|
|
/// </summary>
|
|
public static ulong ParseRawVarint64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
if (state.bufferPos + 10 > state.bufferSize)
|
|
{
|
|
return ParseRawVarint64SlowPath(ref buffer, ref state);
|
|
}
|
|
|
|
ulong result = buffer[state.bufferPos++];
|
|
if (result < 128)
|
|
{
|
|
return result;
|
|
}
|
|
result &= 0x7f;
|
|
int shift = 7;
|
|
do
|
|
{
|
|
byte b = buffer[state.bufferPos++];
|
|
result |= (ulong)(b & 0x7F) << shift;
|
|
if (b < 0x80)
|
|
{
|
|
return result;
|
|
}
|
|
shift += 7;
|
|
}
|
|
while (shift < 64);
|
|
|
|
throw InvalidProtocolBufferException.MalformedVarint();
|
|
}
|
|
|
|
private static ulong ParseRawVarint64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
int shift = 0;
|
|
ulong result = 0;
|
|
do
|
|
{
|
|
byte b = ReadRawByte(ref buffer, ref state);
|
|
result |= (ulong)(b & 0x7F) << shift;
|
|
if (b < 0x80)
|
|
{
|
|
return result;
|
|
}
|
|
shift += 7;
|
|
}
|
|
while (shift < 64);
|
|
|
|
throw InvalidProtocolBufferException.MalformedVarint();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a raw Varint. 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>
|
|
public static uint ParseRawVarint32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
if (state.bufferPos + 5 > state.bufferSize)
|
|
{
|
|
return ParseRawVarint32SlowPath(ref buffer, ref state);
|
|
}
|
|
|
|
int tmp = buffer[state.bufferPos++];
|
|
if (tmp < 128)
|
|
{
|
|
return (uint)tmp;
|
|
}
|
|
int result = tmp & 0x7f;
|
|
if ((tmp = buffer[state.bufferPos++]) < 128)
|
|
{
|
|
result |= tmp << 7;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 7;
|
|
if ((tmp = buffer[state.bufferPos++]) < 128)
|
|
{
|
|
result |= tmp << 14;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 14;
|
|
if ((tmp = buffer[state.bufferPos++]) < 128)
|
|
{
|
|
result |= tmp << 21;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 21;
|
|
result |= (tmp = buffer[state.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(ref buffer, ref state) < 128)
|
|
{
|
|
return (uint) result;
|
|
}
|
|
}
|
|
throw InvalidProtocolBufferException.MalformedVarint();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (uint)result;
|
|
}
|
|
|
|
private static uint ParseRawVarint32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
int tmp = ReadRawByte(ref buffer, ref state);
|
|
if (tmp < 128)
|
|
{
|
|
return (uint) tmp;
|
|
}
|
|
int result = tmp & 0x7f;
|
|
if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
|
|
{
|
|
result |= tmp << 7;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 7;
|
|
if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
|
|
{
|
|
result |= tmp << 14;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 14;
|
|
if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
|
|
{
|
|
result |= tmp << 21;
|
|
}
|
|
else
|
|
{
|
|
result |= (tmp & 0x7f) << 21;
|
|
result |= (tmp = ReadRawByte(ref buffer, ref state)) << 28;
|
|
if (tmp >= 128)
|
|
{
|
|
// Discard upper 32 bits.
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
if (ReadRawByte(ref buffer, ref state) < 128)
|
|
{
|
|
return (uint) result;
|
|
}
|
|
}
|
|
throw InvalidProtocolBufferException.MalformedVarint();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (uint) result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a 32-bit little-endian integer.
|
|
/// </summary>
|
|
public static uint ParseRawLittleEndian32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
const int uintLength = sizeof(uint);
|
|
const int ulongLength = sizeof(ulong);
|
|
if (state.bufferPos + ulongLength > state.bufferSize)
|
|
{
|
|
return ParseRawLittleEndian32SlowPath(ref buffer, ref state);
|
|
}
|
|
// ReadUInt32LittleEndian is many times slower than ReadUInt64LittleEndian (at least on some runtimes)
|
|
// so it's faster better to use ReadUInt64LittleEndian and truncate the result.
|
|
uint result = (uint) BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, ulongLength));
|
|
state.bufferPos += uintLength;
|
|
return result;
|
|
}
|
|
|
|
private static uint ParseRawLittleEndian32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
uint b1 = ReadRawByte(ref buffer, ref state);
|
|
uint b2 = ReadRawByte(ref buffer, ref state);
|
|
uint b3 = ReadRawByte(ref buffer, ref state);
|
|
uint b4 = ReadRawByte(ref buffer, ref state);
|
|
return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a 64-bit little-endian integer.
|
|
/// </summary>
|
|
public static ulong ParseRawLittleEndian64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
const int length = sizeof(ulong);
|
|
if (state.bufferPos + length > state.bufferSize)
|
|
{
|
|
return ParseRawLittleEndian64SlowPath(ref buffer, ref state);
|
|
}
|
|
ulong result = BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, length));
|
|
state.bufferPos += length;
|
|
return result;
|
|
}
|
|
|
|
private static ulong ParseRawLittleEndian64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
ulong b1 = ReadRawByte(ref buffer, ref state);
|
|
ulong b2 = ReadRawByte(ref buffer, ref state);
|
|
ulong b3 = ReadRawByte(ref buffer, ref state);
|
|
ulong b4 = ReadRawByte(ref buffer, ref state);
|
|
ulong b5 = ReadRawByte(ref buffer, ref state);
|
|
ulong b6 = ReadRawByte(ref buffer, ref state);
|
|
ulong b7 = ReadRawByte(ref buffer, ref state);
|
|
ulong b8 = ReadRawByte(ref buffer, ref state);
|
|
return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24)
|
|
| (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a double value.
|
|
/// </summary>
|
|
public static double ParseDouble(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
const int length = sizeof(double);
|
|
if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
|
|
{
|
|
return BitConverter.Int64BitsToDouble((long)ParseRawLittleEndian64(ref buffer, ref state));
|
|
}
|
|
// ReadUnaligned uses processor architecture for endianness.
|
|
double result = Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
|
|
state.bufferPos += length;
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a float value.
|
|
/// </summary>
|
|
public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
const int length = sizeof(float);
|
|
if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
|
|
{
|
|
return ParseFloatSlow(ref buffer, ref state);
|
|
}
|
|
// ReadUnaligned uses processor architecture for endianness.
|
|
float result = Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
|
|
state.bufferPos += length;
|
|
return result;
|
|
}
|
|
|
|
private static unsafe float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
const int length = sizeof(float);
|
|
byte* stackBuffer = stackalloc byte[length];
|
|
Span<byte> tempSpan = new Span<byte>(stackBuffer, length);
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
tempSpan[i] = ReadRawByte(ref buffer, ref state);
|
|
}
|
|
|
|
// Content is little endian. Reverse if needed to match endianness of architecture.
|
|
if (!BitConverter.IsLittleEndian)
|
|
{
|
|
tempSpan.Reverse();
|
|
}
|
|
return Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(tempSpan));
|
|
}
|
|
|
|
/// <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>
|
|
public static byte[] ReadRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
|
|
{
|
|
if (size < 0)
|
|
{
|
|
throw InvalidProtocolBufferException.NegativeSize();
|
|
}
|
|
|
|
if (size <= state.bufferSize - state.bufferPos)
|
|
{
|
|
// We have all the bytes we need already.
|
|
byte[] bytes = new byte[size];
|
|
buffer.Slice(state.bufferPos, size).CopyTo(bytes);
|
|
state.bufferPos += size;
|
|
return bytes;
|
|
}
|
|
|
|
return ReadRawBytesSlow(ref buffer, ref state, size);
|
|
}
|
|
|
|
private static byte[] ReadRawBytesSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
|
|
{
|
|
ValidateCurrentLimit(ref buffer, ref state, size);
|
|
|
|
if ((!state.segmentedBufferHelper.TotalLength.HasValue && size < buffer.Length) ||
|
|
IsDataAvailableInSource(ref state, size))
|
|
{
|
|
// 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.
|
|
|
|
byte[] bytes = new byte[size];
|
|
ReadRawBytesIntoSpan(ref buffer, ref state, size, bytes);
|
|
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.
|
|
|
|
List<byte[]> chunks = new List<byte[]>();
|
|
|
|
int pos = state.bufferSize - state.bufferPos;
|
|
byte[] firstChunk = new byte[pos];
|
|
buffer.Slice(state.bufferPos, pos).CopyTo(firstChunk);
|
|
chunks.Add(firstChunk);
|
|
state.bufferPos = state.bufferSize;
|
|
|
|
// Read all the rest of the bytes we need.
|
|
int sizeLeft = size - pos;
|
|
while (sizeLeft > 0)
|
|
{
|
|
state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
|
|
byte[] chunk = new byte[Math.Min(sizeLeft, state.bufferSize)];
|
|
|
|
buffer.Slice(0, chunk.Length)
|
|
.CopyTo(chunk);
|
|
state.bufferPos += chunk.Length;
|
|
sizeLeft -= chunk.Length;
|
|
chunks.Add(chunk);
|
|
}
|
|
|
|
// OK, got everything. Now concatenate it all into one buffer.
|
|
byte[] bytes = new byte[size];
|
|
int newPos = 0;
|
|
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>
|
|
public static void SkipRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
|
|
{
|
|
if (size < 0)
|
|
{
|
|
throw InvalidProtocolBufferException.NegativeSize();
|
|
}
|
|
|
|
ValidateCurrentLimit(ref buffer, ref state, size);
|
|
|
|
if (size <= state.bufferSize - state.bufferPos)
|
|
{
|
|
// We have all the bytes we need already.
|
|
state.bufferPos += size;
|
|
}
|
|
else
|
|
{
|
|
// Skipping more bytes than are in the buffer. First skip what we have.
|
|
int pos = state.bufferSize - state.bufferPos;
|
|
state.bufferPos = state.bufferSize;
|
|
|
|
// TODO: If our segmented buffer is backed by a Stream that is seekable, we could skip the bytes more efficiently
|
|
// by simply updating stream's Position property. This used to be supported in the past, but the support was dropped
|
|
// because it would make the segmentedBufferHelper more complex. Support can be reintroduced if needed.
|
|
state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
|
|
|
|
while (size - pos > state.bufferSize)
|
|
{
|
|
pos += state.bufferSize;
|
|
state.bufferPos = state.bufferSize;
|
|
state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
|
|
}
|
|
|
|
state.bufferPos = size - pos;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a string field value from the input.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static string ReadString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
|
|
return ParsingPrimitives.ReadRawString(ref buffer, ref state, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a bytes field value from the input.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static ByteString ReadBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
|
|
return ByteString.AttachBytes(ParsingPrimitives.ReadRawBytes(ref buffer, ref state, length));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a UTF-8 string from the next "length" bytes.
|
|
/// </summary>
|
|
/// <exception cref="InvalidProtocolBufferException">
|
|
/// the end of the stream or the current limit was reached
|
|
/// </exception>
|
|
[SecuritySafeCritical]
|
|
public static string ReadRawString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
|
|
{
|
|
// No need to read any data for an empty string.
|
|
if (length == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
if (length < 0)
|
|
{
|
|
throw InvalidProtocolBufferException.NegativeSize();
|
|
}
|
|
|
|
#if GOOGLE_PROTOBUF_SUPPORT_FAST_STRING
|
|
if (length <= state.bufferSize - state.bufferPos)
|
|
{
|
|
// Fast path: all bytes to decode appear in the same span.
|
|
ReadOnlySpan<byte> data = buffer.Slice(state.bufferPos, length);
|
|
|
|
string value;
|
|
unsafe
|
|
{
|
|
fixed (byte* sourceBytes = &MemoryMarshal.GetReference(data))
|
|
{
|
|
value = WritingPrimitives.Utf8Encoding.GetString(sourceBytes, length);
|
|
}
|
|
}
|
|
|
|
state.bufferPos += length;
|
|
return value;
|
|
}
|
|
#endif
|
|
|
|
return ReadStringSlow(ref buffer, ref state, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a string assuming that it is spread across multiple spans in a <see cref="ReadOnlySequence{T}"/>.
|
|
/// </summary>
|
|
private static string ReadStringSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
|
|
{
|
|
ValidateCurrentLimit(ref buffer, ref state, length);
|
|
|
|
#if GOOGLE_PROTOBUF_SUPPORT_FAST_STRING
|
|
if (IsDataAvailable(ref state, length))
|
|
{
|
|
// Read string data into a temporary buffer, either stackalloc'ed or from ArrayPool
|
|
// Once all data is read then call Encoding.GetString on buffer and return to pool if needed.
|
|
|
|
byte[] byteArray = null;
|
|
Span<byte> byteSpan = length <= StackallocThreshold ?
|
|
stackalloc byte[length] :
|
|
(byteArray = ArrayPool<byte>.Shared.Rent(length));
|
|
|
|
try
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (byte* pByteSpan = &MemoryMarshal.GetReference(byteSpan))
|
|
{
|
|
// Compiler doesn't like that a potentially stackalloc'd Span<byte> is being used
|
|
// in a method with a "ref Span<byte> buffer" argument. If the stackalloc'd span was assigned
|
|
// to the ref argument then bad things would happen. We'll never do that so it is ok.
|
|
// Make compiler happy by passing a new span created from pointer.
|
|
var tempSpan = new Span<byte>(pByteSpan, byteSpan.Length);
|
|
ReadRawBytesIntoSpan(ref buffer, ref state, length, tempSpan);
|
|
|
|
return WritingPrimitives.Utf8Encoding.GetString(pByteSpan, length);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (byteArray != null)
|
|
{
|
|
ArrayPool<byte>.Shared.Return(byteArray);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Slow path: Build a byte array first then copy it.
|
|
// This will be called when reading from a Stream because we don't know the length of the stream,
|
|
// or there is not enough data in the sequence. If there is not enough data then ReadRawBytes will
|
|
// throw an exception.
|
|
return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates that the specified size doesn't exceed the current limit. If it does then remaining bytes
|
|
/// are skipped and an error is thrown.
|
|
/// </summary>
|
|
private static void ValidateCurrentLimit(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
|
|
{
|
|
if (state.totalBytesRetired + state.bufferPos + size > state.currentLimit)
|
|
{
|
|
// Read to the end of the stream (up to the current limit) anyway.
|
|
SkipRawBytes(ref buffer, ref state, state.currentLimit - state.totalBytesRetired - state.bufferPos);
|
|
// Then fail.
|
|
throw InvalidProtocolBufferException.TruncatedMessage();
|
|
}
|
|
}
|
|
|
|
[SecuritySafeCritical]
|
|
private static byte ReadRawByte(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
|
|
{
|
|
if (state.bufferPos == state.bufferSize)
|
|
{
|
|
state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
|
|
}
|
|
return buffer[state.bufferPos++];
|
|
}
|
|
|
|
/// <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>
|
|
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>
|
|
/// 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 32 bits to be varint encoded, thus always taking
|
|
/// 5 bytes on the wire.)
|
|
/// </remarks>
|
|
public static int DecodeZigZag32(uint n)
|
|
{
|
|
return (int)(n >> 1) ^ -(int)(n & 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decode a 64-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>
|
|
public static long DecodeZigZag64(ulong n)
|
|
{
|
|
return (long)(n >> 1) ^ -(long)(n & 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks whether there is known data available of the specified size remaining to parse.
|
|
/// When parsing from a Stream this can return false because we have no knowledge of the amount
|
|
/// of data remaining in the stream until it is read.
|
|
/// </summary>
|
|
public static bool IsDataAvailable(ref ParserInternalState state, int size)
|
|
{
|
|
// Data fits in remaining buffer
|
|
if (size <= state.bufferSize - state.bufferPos)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return IsDataAvailableInSource(ref state, size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks whether there is known data available of the specified size remaining to parse
|
|
/// in the underlying data source.
|
|
/// When parsing from a Stream this will return false because we have no knowledge of the amount
|
|
/// of data remaining in the stream until it is read.
|
|
/// </summary>
|
|
private static bool IsDataAvailableInSource(ref ParserInternalState state, int size)
|
|
{
|
|
// Data fits in remaining source data.
|
|
// Note that this will never be true when reading from a stream as the total length is unknown.
|
|
return size <= state.segmentedBufferHelper.TotalLength - state.totalBytesRetired - state.bufferPos;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read raw bytes of the specified length into a span. The amount of data available and the current limit should
|
|
/// be checked before calling this method.
|
|
/// </summary>
|
|
private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> byteSpan)
|
|
{
|
|
int remainingByteLength = length;
|
|
while (remainingByteLength > 0)
|
|
{
|
|
if (state.bufferSize - state.bufferPos == 0)
|
|
{
|
|
state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
|
|
}
|
|
|
|
ReadOnlySpan<byte> unreadSpan = buffer.Slice(state.bufferPos, Math.Min(remainingByteLength, state.bufferSize - state.bufferPos));
|
|
unreadSpan.CopyTo(byteSpan.Slice(length - remainingByteLength));
|
|
|
|
remainingByteLength -= unreadSpan.Length;
|
|
state.bufferPos += unreadSpan.Length;
|
|
}
|
|
}
|
|
}
|
|
}
|