Files
EonaCat.Connections/EonaCat.Connections/Framing/MessageFrameDecoder.cs
T
2026-11-04 07:53:40 +01:00

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;
}
}
}