/// <summary>
/// Tries to build a packet from the given ringbuffer
/// </summary>
/// <param name="Buffer">
/// The Ringbuffer to build a packet from
/// </param>
/// <returns>
/// Whether it was able to build a packet or not
/// </returns>
public bool TryBuildPacket(StompRingBuffer <byte> Buffer)
{
// See if we have rx'd a packet separator or a \0 in a binary frame body
int PacketLength = Buffer.DistanceTo(0);
// We have, so what did we find?
if (PacketLength > 0)
{
// This is a really messy block of code.
// The goal is that it tries to determine whether it has a full packet or needs to wait for more data
// before building the packet and dispatching it
byte[] Data = Buffer.Peek(PacketLength);
string Header = Encoding.UTF8.GetString(Data);
string[] HeaderCheck = Header.Split('\n');
int ContentLength = 0;
bool HasContentLength = false;
// First, we look to see if our "packet" has a content-length header. Since we scanned out to a null (\0) byte, we're guaranteed to at least have the headers
// of whatever packet we're examining
for (int i = 0; i < HeaderCheck.Length && HeaderCheck[i] != "" && HeaderCheck[i] != "\r"; i++)
{
// We found a content-length header? Flag it and store how large in bytes the content should be
if (HeaderCheck[i].StartsWith("content-length:"))
{
HasContentLength = true;
ContentLength = int.Parse(HeaderCheck[i].Substring(15));
}
}
StompFrame Frame = null;
if (HasContentLength)
{
// We have a content-length header. We need to find the start of the frame body, in bytes,
// and then make sure we have (ContentLength) bytes available after that
// Look for the end of the headers, either 1.0/1.1 or 1.2 (\r\n)-friendly
int EndOfHeaders = Header.IndexOf("\r\n\r\n") + 4;
if (EndOfHeaders == 3) // (-1) + 4
{
EndOfHeaders = Header.IndexOf("\n\n") + 2;
}
// Get the byte length of the header
int Offset = Encoding.UTF8.GetByteCount(Header.Substring(0, EndOfHeaders));
// Now see if we have that many bytes available in the ring buffer (realistically, we should except for obscene frame sizes)
if (Offset + ContentLength <= Buffer.AvailableRead)
{
// If we do, peek the exact packet length we want and assemble
Frame = StompFrame.Build(Buffer.Peek(Offset + ContentLength), _FrameTypeMapping);
Buffer.Seek(Offset + ContentLength);
DispatchFrame(Frame);
return(true);
}
}
else // No content-length. We're guaranteed to be a text packet without any overshoot; no special treatment needed
{
Frame = StompFrame.Build(Data, _FrameTypeMapping);
Buffer.Seek(PacketLength);
DispatchFrame(Frame);
return(true);
}
}
return(false);
}