private FragmentedPacket[] SplitPacketIntoFragments()
{
int normalHeaderSize = (CRC_SIZE + SEQUENCE_SIZE) / 8;
int fragmentedHeaderSize = normalHeaderSize + // CRC + Sequence
(int)Math.Ceiling((decimal)(FrameSerializer.BitsRequired(0, dFactory.Count() - 1) + // Number of bits required to send the packet type.
FragmentedPacket.FRAGMENT_HEADER_SIZE) / 8); // Fragment ID + Number of fragments
int dataSize = MTU - fragmentedHeaderSize;
int nbOfFragments = (int)Math.Ceiling((FrameSerializer.BitPacking.ByteLength - normalHeaderSize) / (decimal)dataSize);
Span <byte> data = FrameSerializer.BitPacking.GetByteSpanBuffer();
Span <byte> dataWithoutHeader = data.Slice(normalHeaderSize);
FragmentedPacket[] packets = new FragmentedPacket[nbOfFragments];
for (int i = 0; i < nbOfFragments; i++)
{
FrameSerializer.BitPacking = new BitPacker();
packets[i] = new FragmentedPacket();
packets[i].Header = new PacketHeader(0, CurrentSequence);
packets[i].Header.BeginSerialize(FrameSerializer); // CRC + Sequence
int id = dFactory.GetID <IPacket>(packets[i]);
FrameSerializer.Serialize(ref id, 0, dFactory.Count() - 1); // Packet ID
packets[i].FragmentID = i;
packets[i].NumberOfFragments = nbOfFragments;
int length = dataSize;
if (i == nbOfFragments - 1)
{
length = dataWithoutHeader.Length % dataSize;
}
packets[i].Data = dataWithoutHeader.Slice(dataSize * i, length).ToArray();
packets[i].Serialize(FrameSerializer); // Data
AddCrcOnHeader(packets[i].Header);
}
return(packets);
}
static void Main(string[] args)
{
var from = StripQuotes(args[0]);
var to = StripQuotes(args[1]);
var parser = new FrameParser();
var romData = parser.Parse(from);
FrameSerializer.Export(to, romData);
}
public List <IPacket> Receive(byte[] pData)
{
FrameSerializer.BitPacking = BitPacker.FromArray(pData);
uint crcValue = FrameSerializer.BitPacking.ReadValue(CrcCheck.HashSize); // CRC
#if TRACE_LOG
Log("Read CRC : " + crcValue + " (" + CrcCheck.HashSize + "Bits)");
#endif
dCrcParameters.Check = crcValue;
byte[] dataCrcCalculation = FrameSerializer.BitPacking.GetByteBuffer();
if (CrcCheck.IsRight(dataCrcCalculation))
{
CurrentSequence = (ushort)FrameSerializer.BitPacking.ReadValue(SEQUENCE_SIZE); // Sequence
#if TRACE_LOG
Log("Read Sequence : " + Sequence + " (" + SEQUENCE_SIZE + "Bits)");
#endif
Debug.Assert(!Program.StopOnSequence.HasValue || CurrentSequence != Program.StopOnSequence.Value);
List <IPacket> result = new List <IPacket>();
int id = 0;
// Read the packets until an error occur or if the BitLenght is less than a byte.
// This is because when the data are sent they are always rounded at the superior byte and the end of a packet is filled with 0's.
while (FrameSerializer.BitPacking.BitLength >= 8 && !FrameSerializer.Error)
{
#if TRACE_LOG
Log("Packet ID : ");
#endif
FrameSerializer.Serialize(ref id, 0, dFactory.Count() - 1); // Packet ID
IPacket packet = dFactory.CreateInstance <IPacket>(id);
packet.Header = new PacketHeader(crcValue, CurrentSequence);
#if TRACE_LOG
Log("Packet Data : ");
#endif
if (packet.Serialize(FrameSerializer)) // Data
{
result.Add(packet);
}
}
return(result);
}
else
{
#if TRACE_LOG
Log("Refused packet !");
#endif
}
return(null);
}
public bool ProcessPacket(Packet pPacket)
{
pPacket.Header = PrepareFrame(_shouldClean); // CRC + Sequence
Debug.Assert(!Program.StopOnSequence.HasValue || CurrentSequence != Program.StopOnSequence.Value);
int bitCounter = FrameSerializer.BitPacking.BitLength;
int id = dFactory.GetID(pPacket);
#if TRACE_LOG
Log("Packet ID : ");
#endif
FrameSerializer.Serialize(ref id, 0, dFactory.Count() - 1); // Packet ID
#if TRACE_LOG
Log("Packet Data : ");
#endif
if (!pPacket.Serialize(FrameSerializer)) // Data
{
#if DEBUG
if (pPacket is PacketB)
#endif
{
#if DEBUG
PacketB p = (PacketB)pPacket;
if (p.Actors.Count == 0)
#endif
{
FrameSerializer.BitPacking.Clear();
FrameSerializer.Error = false;
return(false);
}
}
}
if (FrameSerializer.BitPacking.ByteLength > MTU)
{
SplitPacketIntoFragments();
}
else
{
AddCrcOnHeader(pPacket.Header);
}
CurrentSequence++;
_shouldClean = true;
return(!FrameSerializer.Error);
}
