/// <summary>
/// Multiple Voltron packets were sent in a Aries frame.
/// </summary>
/// <param name="PacketBuf">The packet buffer containing the packets to process.</param>
private void ProcessVoltronPackets(Client Client, byte[] PacketBuf)
{
VoltronHeader Header = ReadVoltronHeader(PacketBuf, 12);
MemoryStream AriesStream = new MemoryStream(PacketBuf);
EndianBinaryReader Reader = new EndianBinaryReader(new BigEndianBitConverter(), AriesStream);
int Remaining = (int)AriesStream.Length - 12;
byte[] AriesHeader = Reader.ReadBytes(12); //Aries header.
while (Header.PacketSize < Remaining)
{
byte[] VoltronBody = Reader.ReadBytes((int)Header.PacketSize);
VoltronPacket Packet = new VoltronPacket(ReconstructVoltronPacket(AriesHeader,
VoltronBody), true);
lock (Client.ReceivedPackets)
Client.ReceivedPackets.Enqueue(Packet);
Remaining -= (int)Header.PacketSize;
if (Header.PacketSize < Remaining)
{
Header = ReadVoltronHeader(AriesStream.ToArray(), (int)(AriesStream.Position));
}
}
Reader.Close();
ReceivedData?.Invoke(this, Client);
}
private void ProcessBuffer(Client Client)
{
while (m_CurrentlyReceived >= PacketSize)
{
byte[] PacketBuf = new byte[PacketSize];
Array.Copy(Client.Buffer, PacketBuf, PacketSize);
if (PacketType != 0)
{
lock (Client.ReceivedPackets)
Client.ReceivedPackets.Enqueue(new AriesPacket(PacketBuf, true));
ReceivedData.InvokeSafely(this, Client);
m_CurrentlyReceived -= (int)PacketSize;
}
else
{
VoltronHeader Header = ReadVoltronHeader(PacketBuf, 12);
if (Header.PacketSize < (PacketBuf.Length - 12))
{
ProcessVoltronPackets(Client, PacketBuf);
}
else
{
lock (Client.ReceivedPackets)
Client.ReceivedPackets.Enqueue(new VoltronPacket(PacketBuf, true));
ReceivedData.InvokeSafely(this, Client);
}
m_CurrentlyReceived -= (int)PacketSize;
}
if (m_CurrentlyReceived > 0)
{
byte[] Remainder = new byte[m_CurrentlyReceived];
Array.ConstrainedCopy(Client.Buffer, (Client.Buffer.Length - m_CurrentlyReceived) + 1,
Remainder, 0, m_CurrentlyReceived);
//Recreate the packet buffer and copy the remainder back into it.
Client.CreateBuffer(BUFFER_SIZE);
Array.Copy(Remainder, Client.Buffer, m_CurrentlyReceived);
Remainder = null;
}
else
{
Client.CreateBuffer(BUFFER_SIZE);
}
}
}
/// <summary>
/// Multiple Voltron packets were sent in a Aries frame.
/// </summary>
/// <param name="PacketBuf">The packet buffer containing the packets to process.</param>
private void ProcessVoltronPackets(Client C, byte[] PacketBuf)
{
VoltronHeader Header = ReadVoltronHeader(PacketBuf, 12);
MemoryStream AriesStream = new MemoryStream(PacketBuf);
EndianBinaryReader Reader = new EndianBinaryReader(new LittleEndianBitConverter(), AriesStream);
int Remaining = (int)(AriesStream.Length - 1) - 12;
byte[] AriesHeader = Reader.ReadBytes(12); //Aries header.
Reader = new EndianBinaryReader(new BigEndianBitConverter(), AriesStream);
Reader.BaseStream.Position = 12; //We've already read the header.
while (Header.PacketSize < Remaining)
{
byte[] VoltronData = Reader.ReadBytes((int)Header.PacketSize);
if (Header.PacketType == 0x0044)
{
SplitBufferPDU SplitBufferPacket;
SplitBufferPacket = new SplitBufferPDU(VoltronData, false);
lock (C.ReceivedSplitBuffers)
C.ReceivedSplitBuffers.Enqueue(SplitBufferPacket);
if (SplitBufferPacket.EOF == 1)
{
CompileVoltronPackets(C);
}
}
else
{
VoltronPacket Packet = new VoltronPacket(ReconstructVoltronPacket(AriesHeader,
VoltronData), true);
lock (C.ReceivedPackets)
C.ReceivedPackets.Enqueue(Packet);
}
Remaining -= (int)Header.PacketSize;
if (Header.PacketSize < Remaining)
{
Header = ReadVoltronHeader(AriesStream.ToArray(), (int)(AriesStream.Position));
}
}
Reader.Close();
ReceivedData?.Invoke(this, C);
}
private VoltronHeader ReadVoltronHeader(byte[] Buffer, int Position = 0)
{
VoltronHeader Header = new VoltronHeader();
EndianBinaryReader Reader = new EndianBinaryReader(new BigEndianBitConverter(),
new MemoryStream(Buffer));
if (Position != 0)
{
Reader.Seek(Position, SeekOrigin.Begin);
}
Header.PacketType = Reader.ReadUInt16();
Header.PacketSize = Reader.ReadUInt32();
Reader.Close();
return(Header);
}
private void CompileVoltronPackets(Client C)
{
MemoryStream OutputStream = new MemoryStream();
EndianBinaryReader Reader;
EndianBinaryWriter Writer;
AriesHeader AHeader = new AriesHeader();
AHeader.PacketSize = m_PacketSize;
AHeader.PacketType = m_PacketType;
//Reassemble all the Voltron packets.
for (int i = 0; i < C.ReceivedSplitBuffers.Count; i++)
{
SplitBufferPDU SplitBuffer;
C.ReceivedSplitBuffers.TryDequeue(out SplitBuffer);
Reader = new EndianBinaryReader(new BigEndianBitConverter(), OutputStream);
Writer = new EndianBinaryWriter(new BigEndianBitConverter(), OutputStream);
Writer.Write(Reader.ReadBytes((int)SplitBuffer.FragmentSize));
Writer.Flush();
}
MemoryStream VoltronPackets = new MemoryStream(OutputStream.ToArray());
uint BufSize = (uint)VoltronPackets.Length;
for (int i = 0; i < BufSize; i++)
{
Reader = new EndianBinaryReader(new BigEndianBitConverter(), VoltronPackets);
VoltronHeader Header = ReadVoltronHeader(Reader.ReadBytes(12));
Reader.BaseStream.Position = 0; //Backtrack to beginning of stream.
VoltronPacket VPacket = new VoltronPacket(
ReconstructVoltronPacket(AHeader, Reader.ReadBytes((int)Header.PacketSize)), true);
C.ReceivedPackets.Enqueue(VPacket);
BufSize -= Header.PacketSize;
ReceivedData?.Invoke(this, C);
}
}
private void ProcessBuffer(Client C)
{
lock (m_LockingObj) //The following code won't execute unless it's able to acquire a lock.
{
while (m_CurrentlyReceived >= m_PacketSize)
{
byte[] PacketBuf = new byte[m_PacketSize];
if (!m_PartialPacketReceived)
{
Array.Copy(C.Buffer, PacketBuf, m_PacketSize);
}
else //The slushbuffer wasn't empty, so combine the two buffers into a packet buffer.
{
Array.ConstrainedCopy(C.SlushBuffer, 0, PacketBuf, 0, m_SizeOfSlush);
Array.ConstrainedCopy(C.Buffer, 0, PacketBuf, m_SizeOfSlush, m_CurrentlyReceived);
C.CreateSlushBuffer(0);
m_SizeOfSlush = 0;
m_PartialPacketReceived = false;
}
if (m_PacketType != 0)
{
lock (C.ReceivedPackets)
C.ReceivedPackets.Enqueue(new AriesPacket(PacketBuf, true));
m_CurrentlyReceived -= (int)m_PacketSize;
ReceivedData?.Invoke(this, C);
}
else
{
VoltronHeader Header = ReadVoltronHeader(PacketBuf, 12);
if (Header.PacketSize < ((PacketBuf.Length - 1) - 12))
{
ProcessVoltronPackets(C, PacketBuf);
}
else
{
lock (C.ReceivedPackets)
C.ReceivedPackets.Enqueue(new VoltronPacket(PacketBuf, true));
ReceivedData?.Invoke(this, C);
}
m_CurrentlyReceived -= (int)m_PacketSize;
}
if (m_CurrentlyReceived > 0)
{
byte[] Remainder = new byte[m_CurrentlyReceived];
Array.ConstrainedCopy(C.Buffer, (C.Buffer.Length - m_CurrentlyReceived) + 1,
Remainder, 0, m_CurrentlyReceived);
m_SizeOfSlush = m_CurrentlyReceived;
C.CreateBuffer(BUFFER_SIZE);
C.CreateSlushBuffer(m_SizeOfSlush);
Array.Copy(Remainder, C.SlushBuffer, m_CurrentlyReceived);
Remainder = null;
m_PartialPacketReceived = true;
}
else
{
C.CreateBuffer(BUFFER_SIZE);
}
}
}
}
