public void SendPacket(IReadOnlyCollection <byte> payload)
{
if (!bluetoothCommunicator.IsConnected())
{
throw new InvalidOperationException("Fox is not connected");
}
if (payload.Count < MinPayloadLength || payload.Count > MaxPayloadLength)
{
throw new ArgumentException("Wrong payload size", nameof(payload));
}
var fullPacket = new List <byte>();
// Length
fullPacket.Add((byte)(payload.Count + AddToPacketLenght));
// Payload
fullPacket.AddRange(payload);
// CRC32
var crc = CRCGenerator.CalculateSTMCRC32(fullPacket);
fullPacket.AddRange(BitsHelper.ConvertUInt32ToBytes(crc));
bluetoothCommunicator.SendMessage(fullPacket);
}
/// <summary>
/// Called when new raw packet received
/// </summary>
public void NewRawPacketReceived(IReadOnlyCollection <byte> packet)
{
var packetAsList = new List <byte>(packet);
// Checking CRC
var crcBuffer = packetAsList
.GetRange(packet.Count - 4, 4);
var expectedCRC = BitsHelper.ConvertBytesToUint32(crcBuffer.ToArray());
var calculatedCRC = CRCGenerator.CalculateSTMCRC32(packetAsList
.GetRange(0, packetAsList.Count - 4));
if (expectedCRC != calculatedCRC)
{
return;
}
var payloadLength = packetAsList[0] - AddToPacketLenght;
var payload = packetAsList
.GetRange(1, payloadLength)
.AsReadOnly();
OnPacketReceived(payload);
}
//---------------------------------------------------------------------------------------//
protected bool AddPacket(byte[] buffer, int startIndex)
{
LCDPacket packet = CreatePacket(buffer, startIndex);
ushort calculatedCRC = CRCGenerator.GenerateCRC(buffer, startIndex, packet.DataLength + 2, CRCGenerator.CRC_SEED);
Trace.WriteLine("AddPacket(): " + packet.PacketType.ToString());
switch (packet.PacketType)
{
case LCDPacket.LCDPacketType.NORMAL_RESPONSE:
AddResponsePacket(packet);
break;
case LCDPacket.LCDPacketType.NORMAL_REPORT:
AddReportPacket(packet);
break;
case LCDPacket.LCDPacketType.ERROR_RESPONSE:
AddResponsePacket(packet);
break;
}
if (calculatedCRC != packet.CRC)
{
Trace.WriteLine("CRC ERROR!:" +
" Calculated CRC = 0x" + Convert.ToString(calculatedCRC, 16) +
" Packet CRC = 0x" + Convert.ToString(packet.CRC, 16)
);
return(false);
}
return(true);
}
public static bool ReadAndDecryptPacket(BinaryReader srcStreamReader, MemoryStream destStream, SymmetricAlgorithm alg)
{
destStream.SetLength(0);
//int tmout = srcStreamReader.BaseStream.ReadTimeout;
if (srcStreamReader.ReadChar() != 'P')
{
return(false);
}
int len = srcStreamReader.ReadInt32();
if (len > MaxInPacketLength)
{
return(false);
}
int iv = srcStreamReader.ReadInt32() - 200;
byte[] buf = srcStreamReader.ReadBytes(len - 8);
uint crc = srcStreamReader.ReadUInt32() - 200;
if (CRCGenerator.CRC32(buf, 0, buf.Length, CRCSeed) != crc)
{
return(false);
}
alg.IV = Encoding.ASCII.GetBytes(iv.ToString("X8"));
MemoryStream tmpStream = new MemoryStream(buf);
Crypto.Decrypt(tmpStream, destStream, alg, 64);
destStream.Position = 0;
return(true);
}
//-------------------------------------------------------------------------------------------------//
private LCDPacket Send(byte packetType, byte[] data, int dataLength)
{
ushort crc;
if ((data == null && dataLength != 0) ||
(data != null && dataLength > data.Length))
{
throw new ArgumentException("bad data sent to Send");
}
//
// Create packet buffer and enter header information
//
byte[] packetBuffer = new byte[dataLength + 4];
packetBuffer[0] = packetType;
packetBuffer[1] = (byte)dataLength;
//
// Enter data if there is any
//
if (dataLength != 0)
{
Array.Copy(data, 0, packetBuffer, 2, dataLength);
}
//
// Calculate and enter the checksum into the last two bytes of the packet
//
crc = CRCGenerator.GenerateCRC(packetBuffer, dataLength + 2, CRCGenerator.CRC_SEED);
packetBuffer[2 + dataLength + 1] = (byte)(crc >> 8);
packetBuffer[2 + dataLength] = (byte)crc;
//
// Send the request and return the response
//
lock (responseSignal)
{
responsePacket = null;
// Write the packet to the serial LCD
this.SendData(packetBuffer, packetBuffer.Length);
// Wait for the response packet
if (Monitor.Wait(responseSignal, MAX_RESPONSE_TIME))
{
return(responsePacket);
}
}
return(null);
}
public static bool EncryptAndWritePacket(BinaryWriter destStreamWriter, MemoryStream srcStream, SymmetricAlgorithm alg)
{
if (srcStream.Length == 0)
{
return(true);
}
int iv = GetRandom();
alg.IV = Encoding.ASCII.GetBytes(iv.ToString("X8"));
MemoryStream tmpStream = new MemoryStream();
CryptoStream encStream = new CryptoStream(tmpStream, alg.CreateEncryptor(), CryptoStreamMode.Write);
encStream.Write(srcStream.GetBuffer(), 0, (int)srcStream.Length);
encStream.FlushFinalBlock();
destStreamWriter.Write('P');
destStreamWriter.Write((Int32)(tmpStream.Length + 8));
destStreamWriter.Write(iv + 200);
int offset = 0;
while (offset < tmpStream.Length)
{
int l = (int)tmpStream.Length - offset;
if (l > 4096)
{
l = 4096;
}
destStreamWriter.Write(tmpStream.GetBuffer(), offset, l);
destStreamWriter.BaseStream.Flush();
offset += l;
}
destStreamWriter.Write(CRCGenerator.CRC32(tmpStream.GetBuffer(), 0, (int)tmpStream.Length, CRCSeed) + 200);
encStream.Close();
return(true);
}
