129 lines
4.5 KiB
C#
129 lines
4.5 KiB
C#
using System.Net;
|
|
|
|
namespace EonaCat.Connections.Framing
|
|
{
|
|
internal static class MessageFrameDecoder
|
|
{
|
|
public static bool TryReadLengthPrefixed(MemoryStream stream, int prefixSize, bool useBigEndian, double maxMessageBytes, out byte[]? message)
|
|
{
|
|
message = null;
|
|
var buffer = stream.GetBuffer();
|
|
var bufferedLength = (int)stream.Length;
|
|
|
|
if (bufferedLength < prefixSize)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var messageLengthValue = ParseLengthPrefix(buffer, prefixSize, useBigEndian);
|
|
if (messageLengthValue <= 0 || messageLengthValue > maxMessageBytes)
|
|
{
|
|
throw new ProtocolViolationException($"Declared message length {messageLengthValue} is invalid or exceeds max allowed {maxMessageBytes} bytes.");
|
|
}
|
|
|
|
var messageLength = (int)messageLengthValue;
|
|
if (bufferedLength - prefixSize < messageLength)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
message = new byte[messageLength];
|
|
Buffer.BlockCopy(buffer, prefixSize, message, 0, messageLength);
|
|
RemoveConsumedBytes(stream, prefixSize + messageLength);
|
|
return true;
|
|
}
|
|
|
|
public static bool TryReadDelimited(MemoryStream stream, byte[] delimiter, double maxMessageBytes, out byte[]? message)
|
|
{
|
|
message = null;
|
|
if (delimiter == null || delimiter.Length == 0)
|
|
{
|
|
throw new ProtocolViolationException("Delimiter framing requires a non-empty delimiter.");
|
|
}
|
|
|
|
var buffer = stream.GetBuffer();
|
|
var bufferedLength = (int)stream.Length;
|
|
var delimiterIndex = IndexOf(buffer, bufferedLength, delimiter);
|
|
if (delimiterIndex < 0)
|
|
{
|
|
if (bufferedLength > maxMessageBytes + delimiter.Length - 1)
|
|
{
|
|
throw new ProtocolViolationException($"Delimited message exceeds the maximum allowed {maxMessageBytes} bytes.");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (delimiterIndex > maxMessageBytes)
|
|
{
|
|
throw new ProtocolViolationException($"Delimited message length {delimiterIndex} exceeds the maximum allowed {maxMessageBytes} bytes.");
|
|
}
|
|
|
|
message = new byte[delimiterIndex];
|
|
Buffer.BlockCopy(buffer, 0, message, 0, delimiterIndex);
|
|
RemoveConsumedBytes(stream, delimiterIndex + delimiter.Length);
|
|
return true;
|
|
}
|
|
|
|
public static long ParseLengthPrefix(byte[] buffer, int length, bool useBigEndian)
|
|
{
|
|
if (buffer == null || buffer.Length == 0)
|
|
{
|
|
throw new ArgumentNullException(nameof(buffer));
|
|
}
|
|
|
|
if (length < 1 || length > 8 || length > buffer.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(length), "Length must be between 1 and 8 bytes and fit in the buffer.");
|
|
}
|
|
|
|
long value = 0;
|
|
for (var index = 0; index < length; index++)
|
|
{
|
|
value = useBigEndian
|
|
? (value << 8) | buffer[index]
|
|
: value | (long)buffer[index] << (8 * index);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
private static int IndexOf(byte[] buffer, int length, byte[] delimiter)
|
|
{
|
|
if (length < delimiter.Length)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
for (var index = 0; index <= length - delimiter.Length; index++)
|
|
{
|
|
var matches = true;
|
|
for (var delimiterIndex = 0; delimiterIndex < delimiter.Length; delimiterIndex++)
|
|
{
|
|
if (buffer[index + delimiterIndex] != delimiter[delimiterIndex])
|
|
{
|
|
matches = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (matches)
|
|
{
|
|
return index;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private static void RemoveConsumedBytes(MemoryStream stream, int consumedBytes)
|
|
{
|
|
var buffer = stream.GetBuffer();
|
|
var remaining = (int)stream.Length - consumedBytes;
|
|
Buffer.BlockCopy(buffer, consumedBytes, buffer, 0, remaining);
|
|
stream.SetLength(remaining);
|
|
stream.Position = remaining;
|
|
}
|
|
}
|
|
}
|