public ushort ReadShort()
{
ushort result = NetworkOrderDeserializer.ReadUInt16(Span);
_offset += 2;
return(result);
}
public ulong ReadLonglong()
{
ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset));
_memoryOffset += 8;
return(result);
}
public ulong ReadLonglong()
{
ulong result = NetworkOrderDeserializer.ReadUInt64(Span);
_offset += 8;
return(result);
}
///<summary>Reads an AMQP "table" definition from the reader.</summary>
///<remarks>
/// Supports the AMQP 0-8/0-9 standard entry types S, I, D, T
/// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,
/// x and V types and the AMQP 0-9-1 A type.
///</remarks>
/// <returns>A <seealso cref="System.Collections.Generic.Dictionary{TKey,TValue}"/>.</returns>
public static int ReadDictionary(ReadOnlySpan <byte> span, out Dictionary <string, object> valueDictionary)
{
long tableLength = NetworkOrderDeserializer.ReadUInt32(span);
if (tableLength == 0)
{
valueDictionary = null;
return(4);
}
span = span.Slice(4);
valueDictionary = new Dictionary <string, object>();
int bytesRead = 0;
while (bytesRead < tableLength)
{
bytesRead += ReadShortstr(span.Slice(bytesRead), out string key);
object value = ReadFieldValue(span.Slice(bytesRead), out int valueBytesRead);
bytesRead += valueBytesRead;
valueDictionary[key] = value;
}
return(4 + bytesRead);
}
public ushort ReadShort()
{
ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));
_memoryOffset += 2;
return(result);
}
public static int ReadTimestamp(ReadOnlySpan <byte> span, out AmqpTimestamp value)
{
// 0-9 is afaict silent on the signedness of the timestamp.
// See also MethodArgumentWriter.WriteTimestamp and AmqpTimestamp itself
value = new AmqpTimestamp((long)NetworkOrderDeserializer.ReadUInt64(span));
return(8);
}
// Moved out of outer switch to have a shorter main method (improves performance)
static object ReadFieldValueSlow(ReadOnlySpan <byte> span, out int bytesRead)
{
var slice = span.Slice(1);
switch ((char)span[0])
{
case 'F':
bytesRead = 1 + ReadDictionary(slice, out var dictionary);
return(dictionary);
case 'A':
IList arrayResult = ReadArray(slice, out int arrayBytesRead);
bytesRead = 1 + arrayBytesRead;
return(arrayResult);
case 'l':
bytesRead = 9;
return(NetworkOrderDeserializer.ReadInt64(slice));
case 'i':
bytesRead = 5;
return(NetworkOrderDeserializer.ReadUInt32(slice));
case 'D':
bytesRead = 6;
return(ReadDecimal(slice));
case 'B':
bytesRead = 2;
return(span[1]);
case 'b':
bytesRead = 2;
return((sbyte)span[1]);
case 'd':
bytesRead = 9;
return(NetworkOrderDeserializer.ReadDouble(slice));
case 'f':
bytesRead = 5;
return(NetworkOrderDeserializer.ReadSingle(slice));
case 's':
bytesRead = 3;
return(NetworkOrderDeserializer.ReadInt16(slice));
case 'T':
bytesRead = 1 + ReadTimestamp(slice, out var timestamp);
return(timestamp);
case 'x':
bytesRead = 1 + ReadLongstr(slice, out var binaryTableResult);
return(new BinaryTableValue(binaryTableResult));
default:
bytesRead = 0;
return(ThrowInvalidTableValue((char)span[0]));
}
}
///<summary>Reads an AMQP "table" definition from the reader.</summary>
///<remarks>
/// Supports the AMQP 0-8/0-9 standard entry types S, I, D, T
/// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,
/// x and V types and the AMQP 0-9-1 A type.
///</remarks>
/// <returns>A <seealso cref="System.Collections.Generic.Dictionary{TKey,TValue}"/>.</returns>
public static Dictionary <string, object> ReadTable(ReadOnlySpan <byte> span, out int bytesRead)
{
bytesRead = 4;
long tableLength = NetworkOrderDeserializer.ReadUInt32(span);
if (tableLength == 0)
{
return(null);
}
Dictionary <string, object> table = new Dictionary <string, object>();
while ((bytesRead - 4) < tableLength)
{
string key = ReadShortstr(span.Slice(bytesRead), out int keyBytesRead);
bytesRead += keyBytesRead;
object value = ReadFieldValue(span.Slice(bytesRead), out int valueBytesRead);
bytesRead += valueBytesRead;
if (!table.ContainsKey(key))
{
table[key] = value;
}
}
return(table);
}
public static decimal ReadDecimal(ReadOnlyMemory <byte> memory)
{
byte scale = memory.Span[0];
uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(memory.Slice(1));
return(AmqpToDecimal(scale, unsignedMantissa));
}
public static decimal ReadDecimal(ReadOnlySpan <byte> span)
{
byte scale = span[0];
uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(span.Slice(1));
return(AmqpToDecimal(scale, unsignedMantissa));
}
public uint ReadLong()
{
uint result = NetworkOrderDeserializer.ReadUInt32(Span);
_offset += 4;
return(result);
}
public uint ReadLong()
{
uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset));
_memoryOffset += 4;
return(result);
}
public uint ReadLong()
{
ClearBits();
uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset).Span);
_memoryOffset += 4;
return(result);
}
public static AmqpTimestamp ReadTimestamp(ReadOnlyMemory <byte> memory)
{
ulong stamp = NetworkOrderDeserializer.ReadUInt64(memory);
// 0-9 is afaict silent on the signedness of the timestamp.
// See also MethodArgumentWriter.WriteTimestamp and AmqpTimestamp itself
return(new AmqpTimestamp((long)stamp));
}
///<summary>
/// Fill this instance from the given byte buffer stream.
///</summary>
internal ulong ReadFrom(ReadOnlyMemory <byte> memory)
{
// Skipping the first two bytes since they arent used (weight - not currently used)
ulong bodySize = NetworkOrderDeserializer.ReadUInt64(memory.Slice(2));
ReadPropertiesFrom(new ContentHeaderPropertyReader(memory.Slice(10)));
return(bodySize);
}
public void ReadFlagWord()
{
if (!ContinuationBitSet)
{
throw new MalformedFrameException("Attempted to read flag word when none advertised");
}
m_flagWord = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));
_memoryOffset += 2;
m_bitCount = 0;
}
private void ReadBits()
{
if (!ContinuationBitSet)
{
throw new MalformedFrameException("Attempted to read flag word when none advertised");
}
_bits = NetworkOrderDeserializer.ReadUInt16(Span);
_offset += 2;
_bitMask = StartBitMask;
}
public static byte[] ReadLongstr(ReadOnlySpan <byte> span)
{
uint byteCount = NetworkOrderDeserializer.ReadUInt32(span);
if (byteCount > int.MaxValue)
{
throw new SyntaxErrorException($"Long string too long; byte length={byteCount}, max={int.MaxValue}");
}
return(span.Slice(4, (int)byteCount).ToArray());
}
public static byte[] ReadLongstr(ReadOnlyMemory <byte> memory)
{
int byteCount = (int)NetworkOrderDeserializer.ReadUInt32(memory);
if (byteCount > int.MaxValue)
{
throw new SyntaxError($"Long string too long; byte length={byteCount}, max={int.MaxValue}");
}
return(memory.Slice(4, byteCount).ToArray());
}
public Command HandleFrame(InboundFrame f)
{
switch (m_state)
{
case AssemblyState.ExpectingMethod:
if (!f.IsMethod())
{
throw new UnexpectedFrameException(f);
}
m_method = m_protocol.DecodeMethodFrom(f.Payload);
m_state = m_method.HasContent ? AssemblyState.ExpectingContentHeader : AssemblyState.Complete;
return(CompletedCommand());
case AssemblyState.ExpectingContentHeader:
if (!f.IsHeader())
{
throw new UnexpectedFrameException(f);
}
m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload));
ulong totalBodyBytes = m_header.ReadFrom(f.Payload.Slice(2));
if (totalBodyBytes > MaxArrayOfBytesSize)
{
throw new UnexpectedFrameException(f);
}
m_remainingBodyBytes = (int)totalBodyBytes;
m_body = MemoryPool <byte> .Shared.Rent(m_remainingBodyBytes);
UpdateContentBodyState();
return(CompletedCommand());
case AssemblyState.ExpectingContentBody:
if (!f.IsBody())
{
throw new UnexpectedFrameException(f);
}
if (f.Payload.Length > m_remainingBodyBytes)
{
throw new MalformedFrameException($"Overlong content body received - {m_remainingBodyBytes} bytes remaining, {f.Payload.Length} bytes received");
}
f.Payload.CopyTo(m_body.Memory.Slice(_offset));
m_remainingBodyBytes -= f.Payload.Length;
_offset += f.Payload.Length;
UpdateContentBodyState();
return(CompletedCommand());
case AssemblyState.Complete:
default:
return(null);
}
}
public static int ReadLongstr(ReadOnlySpan <byte> span, out byte[] value)
{
uint byteCount = NetworkOrderDeserializer.ReadUInt32(span);
if (byteCount > int.MaxValue)
{
value = null;
return(ThrowSyntaxErrorException(byteCount));
}
value = span.Slice(4, (int)byteCount).ToArray();
return(4 + value.Length);
}
public static decimal ReadDecimal(ReadOnlySpan <byte> span)
{
byte scale = span[0];
if (scale > 28)
{
ThrowInvalidDecimalScale(scale);
}
uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(span.Slice(1));
var data = new DecimalData(((uint)(scale << 16)) | unsignedMantissa & 0x80000000, 0, unsignedMantissa & 0x7FFFFFFF, 0);
return(Unsafe.As <DecimalData, decimal>(ref data));
}
public static IList ReadArray(ReadOnlyMemory <byte> memory, out int bytesRead)
{
IList array = new List <object>();
long arrayLength = NetworkOrderDeserializer.ReadUInt32(memory);
bytesRead = 4;
while (bytesRead - 4 < arrayLength)
{
object value = ReadFieldValue(memory.Slice(bytesRead), out int fieldValueBytesRead);
bytesRead += fieldValueBytesRead;
array.Add(value);
}
return(array);
}
public static IList ReadArray(ReadOnlySpan <byte> span, out int bytesRead)
{
bytesRead = 4;
long arrayLength = NetworkOrderDeserializer.ReadUInt32(span);
if (arrayLength == 0)
{
return(null);
}
List <object> array = new List <object>();
while (bytesRead - 4 < arrayLength)
{
array.Add(ReadFieldValue(span.Slice(bytesRead), out int fieldValueBytesRead));
bytesRead += fieldValueBytesRead;
}
return(array);
}
public static InboundFrame ReadFrom(Stream reader)
{
int type;
try
{
type = reader.ReadByte();
if (type == -1)
{
throw new EndOfStreamException("Reached the end of the stream. Possible authentication failure.");
}
}
catch (IOException ioe) when
(ioe.InnerException != null &&
(ioe.InnerException is SocketException) &&
((SocketException)ioe.InnerException).SocketErrorCode == SocketError.TimedOut)
{
throw ioe.InnerException;
}
if (type == 'A')
{
// Probably an AMQP protocol header, otherwise meaningless
ProcessProtocolHeader(reader);
}
using IMemoryOwner <byte> headerMemory = MemoryPool <byte> .Shared.Rent(6);
Memory <byte> headerSlice = headerMemory.Memory.Slice(0, 6);
reader.Read(headerSlice);
int channel = NetworkOrderDeserializer.ReadUInt16(headerSlice);
int payloadSize = NetworkOrderDeserializer.ReadInt32(headerSlice.Slice(2)); // FIXME - throw exn on unreasonable value
IMemoryOwner <byte> payload = MemoryPool <byte> .Shared.Rent(payloadSize);
int bytesRead = 0;
try
{
while (bytesRead < payloadSize)
{
bytesRead += reader.Read(payload.Memory[bytesRead..payloadSize]);
///<summary>Reads an AMQP "table" definition from the reader.</summary>
///<remarks>
/// Supports the AMQP 0-8/0-9 standard entry types S, I, D, T
/// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,
/// x and V types and the AMQP 0-9-1 A type.
///</remarks>
/// <returns>A <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>
public static IDictionary <string, object> ReadTable(ReadOnlyMemory <byte> memory, out int bytesRead)
{
IDictionary <string, object> table = new Dictionary <string, object>();
long tableLength = NetworkOrderDeserializer.ReadUInt32(memory);
bytesRead = 4;
while ((bytesRead - 4) < tableLength)
{
string key = ReadShortstr(memory.Slice(bytesRead), out int keyBytesRead);
bytesRead += keyBytesRead;
object value = ReadFieldValue(memory.Slice(bytesRead), out int valueBytesRead);
bytesRead += valueBytesRead;
if (!table.ContainsKey(key))
{
table[key] = value;
}
}
return(table);
}
public static decimal ReadDecimal(ReadOnlySpan <byte> span)
{
byte scale = span[0];
if (scale > 28)
{
throw new SyntaxErrorException($"Unrepresentable AMQP decimal table field: scale={scale}");
}
uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(span.Slice(1));
return(new decimal(
// The low 32 bits of a 96-bit integer
lo: (int)(unsignedMantissa & 0x7FFFFFFF),
// The middle 32 bits of a 96-bit integer.
mid: 0,
// The high 32 bits of a 96-bit integer.
hi: 0,
isNegative: (unsignedMantissa & 0x80000000) != 0,
// A power of 10 ranging from 0 to 28.
scale: scale));
}
public static object ReadFieldValue(ReadOnlySpan <byte> span, out int bytesRead)
{
switch ((char)span[0])
{
case 'S':
bytesRead = 1 + ReadLongstr(span.Slice(1), out var bytes);
return(bytes);
case 't':
bytesRead = 2;
return(span[1] != 0 ? TrueBoolean : FalseBoolean);
case 'I':
bytesRead = 5;
return(NetworkOrderDeserializer.ReadInt32(span.Slice(1)));
case 'V':
bytesRead = 1;
return(null);
default:
return(ReadFieldValueSlow(span, out bytesRead));
}
public void TestDoubleDecoding()
{
Assert.Equal(1.234, NetworkOrderDeserializer.ReadDouble(_expectedDoubleBytes.AsSpan()));
}
public void TestReadUInt64()
{
Assert.Equal(0x89ABCDEF01234567, NetworkOrderDeserializer.ReadUInt64(new byte[] { 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67 }.AsSpan()));
}
