/// <summary>
/// 验证封装数据传输包
/// </summary>
/// <param name="packet">封装传输包</param>
/// <returns>如果验证成功返回ture,否则返回false</returns>
private bool CheckSealedPacket(byte[] packet)
{
uint packetCrc = Crc32.ComputeCrcUInt(packet, 0, packet.Length);
uint headerCrc = BytesConvertor.BytesToUInt32(sealedHeader, 8);
return(packetCrc == headerCrc);
}
/// <summary>
/// 验证一般数据传输包
/// </summary>
/// <param name="packet">一般传输包</param>
/// <returns>如果验证成功返回ture,否则返回false</returns>
private bool CheckNormalPacket(byte[] packet)
{
uint packetCrc = Crc32.ComputeCrcUInt(packet, 0, packet.Length);
uint headerCrc = BytesConvertor.BytesToUInt32(normalHeader, 4);
return(packetCrc == headerCrc);
}
/// <summary>
/// 构造一般传输包的头
/// </summary>
/// <param name="packet">一般传输包</param>
/// <returns>返回一般传输包的头</returns>
private byte[] ConstructNormalHeader(byte[] packet)
{
BytesConvertor.Int32ToBytes(packet.Length, normalHeader, 0);
uint crc = Crc32.ComputeCrcUInt(packet, 0, packet.Length);
BytesConvertor.UInt32ToBytes(crc, normalHeader, 4);
return(normalHeader);
}
/// <summary>
/// 构造封装传输包的头
/// </summary>
/// <param name="normalPacket">一般传输包</param>
/// <param name="sealedPacket">封装传输包</param>
/// <returns>返回一般传输包的头</returns>
private byte[] ConstructSealedHeader(byte[] normalPacket, byte[] sealedPacket)
{
BytesConvertor.Int32ToBytes(normalPacket.Length, sealedHeader, 0);
BytesConvertor.Int32ToBytes(sealedPacket.Length, sealedHeader, 4);
uint crc = Crc32.ComputeCrcUInt(normalPacket, 0, normalPacket.Length);
BytesConvertor.UInt32ToBytes(crc, sealedHeader, 8);
return(sealedHeader);
}
/// <summary>
/// 读取封装传输包
/// </summary>
/// <returns>返回读取的传输包</returns>
public byte[] ReceiveSealedPacket()
{
if (!socket.Connected)
{
throw new PacketException("客户端还没有打开!");
}
int offset = 0;
do
{
int length = socket.Receive(sealedHeader, offset, sealedHeaderLength - offset, SocketFlags.None);
offset += length;
} while (offset < sealedHeaderLength);
int normalPacketLength = BytesConvertor.BytesToInt32(sealedHeader, 0);
if (normalPacketLength > maxPacketLength || normalPacketLength < 0)
{
throw new PacketException("申请内存异常!");
}
int sealedPacketLength = BytesConvertor.BytesToInt32(sealedHeader, 4);
if (sealedPacketLength > maxPacketLength || sealedPacketLength < 0)
{
throw new PacketException("申请内存异常!");
}
byte[] sealedPacket = new byte[sealedPacketLength];
offset = 0;
do
{
int length = socket.Receive(sealedPacket, offset, sealedPacketLength - offset, SocketFlags.None);
offset += length;
} while (offset < sealedPacketLength);
MemoryStream ms = new MemoryStream(sealedPacket);
GZipStream decompressStream = new GZipStream(ms, CompressionMode.Decompress);
CryptoStream decryptoStream = new CryptoStream(decompressStream, decryptor, CryptoStreamMode.Read);
byte[] result = new byte[normalPacketLength];
decryptoStream.Read(result, 0, normalPacketLength);
decryptoStream.Close();
ms.Dispose();
decompressStream.Dispose();
decryptoStream.Dispose();
bool isCorrect = CheckSealedPacket(result);
if (isCorrect)
{
return(result);
}
throw new PacketException("封装传输包验证不成功!");
}
/// <summary>
/// 读取一般传输包
/// </summary>
/// <returns>返回读取的一般传输包</returns>
public byte[] ReceiveNormalPacket()
{
if (!socket.Connected)
{
throw new PacketException("客户端还没有打开!");
}
int offset = 0;
Console.WriteLine(EndPoint);
do
{
int length = socket.Receive(normalHeader, offset, normalHeaderLength - offset, SocketFlags.None);
offset += length;
} while (offset < normalHeaderLength);
int packetLength = BytesConvertor.BytesToInt32(normalHeader, 0);
if (packetLength > maxPacketLength || packetLength < 0)
{
throw new PacketException("申请内存异常!");
}
byte[] rcvMsg = new byte[packetLength];
offset = 0;
do
{
int length = socket.Receive(rcvMsg, offset, packetLength - offset, SocketFlags.None);
offset += length;
} while (offset < packetLength);
bool isCorrect = CheckNormalPacket(rcvMsg);
if (isCorrect)
{
return(rcvMsg);
}
throw new PacketException("一般传输包验证不成功!");
}