public override void ParsePayload(byte[] payloadData, FrameHeader frameHeader)
{
// Get Dependency Stream Id
// we need to turn the stream id into a uint
var frameStreamIdData = new byte[4];
Array.Copy(payloadData, 0, frameStreamIdData, 0, 4);
StreamDependency = Util.ConvertFromUInt31(ByteArrayExtensions.EnsureBigEndian(frameStreamIdData));
// Get the weight
weight = (ushort)payloadData [4];
}
internal void Parse(byte[] data)
{
if (data.Length < 9)
{
throw new InvalidDataException("data[] is missing frame header");
}
// Find out the frame length
// which is a 24 bit uint, so we need to convert this as c# uint is 32 bit
var flen = new byte[4];
flen [0] = 0x0;
flen [1] = data [0];
flen [2] = data [1];
flen [3] = data [2];
var frameLength = BitConverter.ToUInt32(ByteArrayExtensions.EnsureBigEndian(flen), 0);
// If we are expecting a payload that's bigger than what's in our buffer
// we should keep reading from the stream
if (data.Length - 9 < frameLength)
{
throw new InvalidDataException("Length of data[] does not match frame length in data");
}
var frameType = data [3]; // 4th byte in frame header is TYPE
var frameFlags = data [4]; // 5th byte is FLAGS
// we need to turn the stream id into a uint
var frameStreamIdData = new byte[4];
Array.Copy(data, 5, frameStreamIdData, 0, 4);
this.StreamIdentifier = Util.ConvertFromUInt31(ByteArrayExtensions.EnsureBigEndian(frameStreamIdData));
//this.Type = frameType;
this.Flags = frameFlags;
var frameHeader = new FrameHeader {
Length = frameLength,
Type = frameType,
Flags = frameFlags,
StreamIdentifier = this.StreamIdentifier
};
// Isolate the payload data
var payloadData = new byte[frameLength];
Array.Copy(data, 9, payloadData, 0, frameLength);
ParsePayload(payloadData, frameHeader);
}
public override void ParsePayload(byte[] payloadData, FrameHeader frameHeader)
{
EndStream = (frameHeader.Flags & 0x1) == 0x1;
EndHeaders = (frameHeader.Flags & 0x4) == 0x4;
Priority = (frameHeader.Flags & 0x20) == 0x20;
Padded = (frameHeader.Flags & 0x8) == 0x8;
var index = 0;
if (Padded)
{
// Get pad length (1 byte)
padLength = (ushort)payloadData [index];
index++;
}
else
{
padLength = 0;
}
if (Priority)
{
// Get Dependency Stream Id
// we need to turn the stream id into a uint
var frameStreamIdData = new byte[4];
Array.Copy(payloadData, index, frameStreamIdData, 0, 4);
StreamDependency = Util.ConvertFromUInt31(ByteArrayExtensions.EnsureBigEndian(frameStreamIdData));
// Get the weight
weight = (ushort)payloadData [index + 4];
// Advance the index
index += 5;
}
// create an array for the header data to read
// it will be the payload length, minus the pad length value, weight, stream id, and padding
HeaderBlockFragment = new byte[payloadData.Length - (index + padLength)];
Array.Copy(payloadData, index, HeaderBlockFragment, 0, HeaderBlockFragment.Length);
// Advance the index
index += HeaderBlockFragment.Length;
// Don't care about padding
}
public override void ParsePayload(byte[] payloadData, FrameHeader frameHeader)
{
// we need to turn the stream id into a uint
var frameStreamIdData = new byte[4];
Array.Copy(payloadData, 0, frameStreamIdData, 0, 4);
LastStreamId = Util.ConvertFromUInt31(ByteArrayExtensions.EnsureBigEndian(frameStreamIdData));
var errorCodeData = new byte[4];
Array.Copy(payloadData, 4, errorCodeData, 0, 4);
uint errorCode = BitConverter.ToUInt32(ByteArrayExtensions.EnsureBigEndian(errorCodeData), 0);
ErrorCode = errorCode;
if (payloadData.Length > 8)
{
AdditionalDebugData = new byte[payloadData.Length - 8];
Array.Copy(payloadData, 8, AdditionalDebugData, 0, payloadData.Length - 8);
}
}
void readed(int rx, byte[] b, out bool ended, Semaphore smp = null)
{
if (rx > 0)
{
// Add all the bytes read into our buffer list
for (int i = 0; i < rx; i++)
{
buffer.Add(b[i]);
}
while (true)
{
// We need at least 9 bytes to process the frame
// 9 octets is the frame header length
if (buffer.Count < 9)
{
break;
}
// Find out the frame length
// which is a 24 bit uint, so we need to convert this as c# uint is 32 bit
var flen = new byte[4];
flen[0] = 0x0;
flen[1] = buffer[0];
flen[2] = buffer[1];
flen[3] = buffer[2];
var frameLength = BitConverter.ToUInt32(ByteArrayExtensions.EnsureBigEndian(flen), 0);
// If we are expecting a payload that's bigger than what's in our buffer
// we should keep reading from the stream
if (buffer.Count - 9 < frameLength)
{
break;
}
// If we made it this far, the buffer has all the data we need, let's get it out to process
var data = buffer.GetRange(0, (int)frameLength + 9).ToArray();
// remove the processed info from the buffer
buffer.RemoveRange(0, (int)frameLength + 9);
// Get the Frame Type so we can instantiate the right subclass
var frameType = data[3]; // 4th byte in frame header is TYPE
// we need to turn the stream id into a uint
var frameStreamIdData = new byte[4];
Array.Copy(data, 5, frameStreamIdData, 0, 4);
uint frameStreamId = Util.ConvertFromUInt31(ByteArrayExtensions.EnsureBigEndian(frameStreamIdData));
// Create a new typed instance of our abstract Frame
var frame = Frame.Create((FrameType)frameType);
try
{
// Call the specific subclass implementation to parse
frame.Parse(data);
}
catch (Exception ex)
{
Log.Error("Parsing Frame Failed: {0}", ex);
throw ex;
}
Log.Debug("<- {0}", frame);
// If it's a settings frame, we should note the values and
// return the frame with the Ack flag set
if (frame.Type == FrameType.Settings)
{
var settingsFrame = frame as SettingsFrame;
// Update our instance of settings with the new data
Settings.UpdateFromFrame(settingsFrame, flowControlManager);
// See if this was an ack, if not, return an empty
// ack'd settings frame
if (!settingsFrame.Ack)
{
QueueFrame(new SettingsFrame {
Ack = true
});
}
}
else if (frame.Type == FrameType.Ping)
{
var pingFrame = frame as PingFrame;
// See if we need to respond to the ping request (if it's not-ack'd)
if (!pingFrame.Ack)
{
// Ack and respond
pingFrame.Ack = true;
QueueFrame(pingFrame);
}
}
else if (frame.Type == FrameType.Data)
{
// Increment our received data counter
Interlocked.Add(ref receivedDataCount, frame.PayloadLength);
}
// Some other frame type, just pass it along to the stream
var stream = streamManager.Get(frameStreamId);
stream.ProcessReceivedFrames(frame);
}
ended = false;
}
else
{
// Stream was closed, break out of reading loop
ended = true;
}
if (smp != null)
{
smp.Release();
}
}
